0.2.164

will move select lessons back to "educators" section

.gitattributes

@@ -12,6 +12,7 @@
 *.html text eol=lf
 *.py text eol=lf
 *.exp text eol=lf
+*.manifest text eol=lf
 
 # do not enforce text for everything - it causes issues with random binary files
 

.gitignore

@@ -1,8 +1,19 @@
 node_modules
-*.sw?
+yotta_modules
+yotta_targets
 built
-typings/
-tmp/
+typings
+tmp
+temp
+projects/**
+win10/app/bin
+win10/app/bld
+win10/*.opendb
+
+*.user
+*.sw?
 *.ts.new
 *.tgz
-temp/
+*.db
+*.suo
+*.log

.travis.yml

@@ -2,10 +2,10 @@ language: node_js
 node_js:
   - "5.7.0"
 script:
-  - "npm update"
-  - "node node_modules/kindscript/built/kind.js buildtarget"
-  - "node node_modules/kindscript/built/kind.js travis"  
-  - "node node_modules/kindscript/built/kind.js uploaddoc"
+  - "node node_modules/pxt-core/built/pxt.js travis"  
+  - "(cd libs/lang-test0; node ../../node_modules/pxt-core/built/pxt.js run)"
+  - "node node_modules/pxt-core/built/pxt.js uploaddoc"
+  - "(cd libs/hello; node ../../node_modules/pxt-core/built/pxt.js testconv ../../testconv.json)"
 sudo: false
 notifications:
   email:
@@ -13,4 +13,5 @@ notifications:
 cache:
   directories:
     - node_modules
+    - built/cache
 

.vscode/settings.json

@@ -0,0 +1,5 @@
+// Place your settings in this file to overwrite default and user settings.
+{
+    "tslint.enable": true,
+    "tslint.rulesDirectory": "node_modules/tslint-microsoft-contrib"
+}

.vscode/tasks.json

@@ -1,7 +1,7 @@
 {
 	"version": "0.1.0",
 	// Task runner is jake
-	"command": "kind",
+	"command": "pxt",
 	// Need to be executed in shell / cmd
 	"isShellCommand": true,
 	"showOutput": "always",

README.md

@@ -1,48 +1,54 @@
-# micro:bit target for KindScript
+# micro:bit target for PXT
 
-This target allow to program a [BBC micro:bit](https://www.microbit.co.uk/) using [KindScript](https://github.com/Microsoft/kindscript).
+This target allow to program a [BBC micro:bit](https://www.microbit.co.uk/) using 
+PXT ([Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt)).
 
-[![Build Status](https://travis-ci.org/Microsoft/kindscript-microbit.svg?branch=master)](https://travis-ci.org/Microsoft/kindscript-microbit)
+* [Try it live](https://m.pxt.io)
 
-# Getting started
+[![Build Status](https://travis-ci.org/Microsoft/pxt-microbit.svg?branch=master)](https://travis-ci.org/Microsoft/pxt-microbit)
 
-> If you're making changes to kindscript repository itself, proceed to **Local installation** below.
+## Local server
 
-* Clone this repo and run
+### Setup
 
+The following commands are a 1-time setup after synching the repo on your machine.
+
+* install the PXT command line
+```
+npm install -g pxt
+```
+* install the dependencies
 ```
 npm install
 ```
 
-* Install the `KindScript` tool and launch the local server:
+### Running
 
+Run this command to open a local web server (add ``sudo`` for Mac/Linux shells)
 ```
-npm install -g kindscript-cli
-kind serve
+pxt serve
 ```
-To re-build the `built/target.json` file, re-run `kind serve`.
+If the local server opens in the wrong browser, make sure to copy the URL containing the local token. 
+Otherwise, the editor will not be able to load the projects.
 
+If you need modify the `.cpp` files, turn on yotta compilation with the ``-yt`` flag (add ``sudo`` for Mac/Linux shells):
+```
+pxt serve -yt
+```
 
-## Local installation
+To make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
+```
+pxt update
+```
 
-* Clone and build [KindScript](https://github.com/Microsoft/kindscript) in a `kindscript` folder.
-* Clone this repo  in a `kindscript-microbit` folder next to `kindscript`
+More instructions at https://github.com/Microsoft/pxt#running-a-target-from-localhost 
 
-```
-npm install
-```
-* To build and deploy new changes
+## Universal Windows App
 
-```
-npm install -g kindscript-cli
-cd ../kindscript
-jake
-cd ../kindscript-microbit
-npm link ../kindscript
-```
-* run this command to build and launch a local editor
+The Windows 10 app is a [Universal Windows Hosted Web App](https://microsoftedge.github.io/WebAppsDocs/en-US/win10/CreateHWA.htm)
+that wraps ``m.pxt.io`` and provides additional features.
 
-```
-kind serve
-```
-* open `localhost:3232` to try your editor!
+### Building
+
+* Install Visual Studio 2015 Update 2 or higher. Make sure the Windows 10 templates are installed.
+* open the ``win10/app.sln`` solution and launch the ``m.pxt.io`` project.

cmds/cmds.ts

@@ -1,22 +1,22 @@
-/// <reference path="../node_modules/kindscript/built/kind.d.ts"/>
+/// <reference path="../node_modules/pxt-core/built/pxt.d.ts"/>
 
-import * as fs from 'fs';
-import * as path from 'path';
-import * as child_process from 'child_process';
+import * as fs from "fs";
+import * as path from "path";
+import * as child_process from "child_process";
 
 let writeFileAsync: any = Promise.promisify(fs.writeFile)
 let execAsync: (cmd: string, options?: { cwd?: string }) => Promise<Buffer> = Promise.promisify(child_process.exec)
 
-export function deployCoreAsync(res: ts.ks.CompileResult) {
+export function deployCoreAsync(res: ts.pxt.CompileResult) {
     return getBitDrivesAsync()
         .then(drives => {
             if (drives.length == 0) {
                 console.log("cannot find any drives to deploy to")
             } else {
-                console.log("copy microbit.hex to " + drives.join(", "))
+                console.log(`copy ${ts.pxt.BINARY_HEX} to ` + drives.join(", "))
             }
             return Promise.map(drives, d =>
-                writeFileAsync(d + "microbit.hex", res.outfiles["microbit.hex"])
+                writeFileAsync(d + ts.pxt.BINARY_HEX, res.outfiles[ts.pxt.BINARY_HEX])
                     .then(() => {
                         console.log("wrote hex file to " + d)
                     }))
@@ -40,4 +40,4 @@ function getBitDrivesAsync(): Promise<string[]> {
     } else {
         return Promise.resolve([])
     }
-}
+}

cmds/tsconfig.json

@@ -8,6 +8,6 @@
         "module": "commonjs",
         "rootDir": ".",
         "newLine": "LF",
-        "sourceMap": true
+        "sourceMap": false
     }
 }

docs/_locales/pl/_theme.json

@@ -0,0 +1,22 @@
+{
+    "name": "koduj z micro:bit",
+    "title": "koduj z micro:bit",
+    "docMenu": [
+        {
+            "name": "O nas",
+            "path": "/about"
+        },
+        {
+            "name": "Lekcje",
+            "path": "/lessons"
+        },
+        {
+            "name": "Instrukcja obsługi",
+            "path": "/reference"
+        },
+        {
+            "name": "Urządzenie",
+            "path": "/device"
+        }
+    ]
+}

docs/_locales/pl/docs.md

@@ -0,0 +1,7 @@
+# Dokumentacja
+
+Witamy na stronach dokumentacji!
+
+* Przeglądnij [instrukcje obsługi](/reference)
+* Dowiedz się więcej o [urządzeniu](/device)
+* Wystartuj z [lekcjami](/lessons)

docs/about.md

@@ -1,34 +1,9 @@
-# About
-
-The [BBC micro:bit](https://www.microbit.co.uk) is a [pocket-size computer](/device) with 25 LEDs, Bluetooth and sensors that can be programmed by anyone.
-The BBC micro:bit was made possible by [a number of partners!](https://www.microbit.co.uk/partners)
-
-The micro:bit provides a fun introduction to programming and making – switch on, program it to do something fun – wear it, customize it.
-Just like Arduino, the micro:bit can be connected to and interact with sensors, displays, and other devices. 
-
-## Block Editor or JavaScript
-
-The student can program the BBC micro:bit using a Block Editor or JavaScript.
-
-```blocks
-basic.showString("BBC micro:bit!");
-```
-
-## Compile and Flash
-
-When a user has her code ready, she can connect her BBC micro:bit to a computer via a USB cable, so it appears as a mounted drive.
-
-Compilation to the ARM thumb machine code happens in the browser.
-
-The student is prompted to save the ARM binary program to a file, which she then simply drags to the micro:bit mounted drive, 
-which flashes the micro:bit device with the new program.
-
-## Simulator: Test Your Code
-Before a student compiles her code for the micro:bit, she can run it using the micro:bit simulator, all within the confines of a web browser. 
-The simulator has support for the LED screen, buttons, as well as compass, accelerometer, and digital I/O pins.
-
 ```sim
+basic.forever(() => {
+  basic.showString("Hi!");
+})
 input.onButtonPressed(Button.A, () => {
+    led.stopAnimation();
     basic.showLeds(`
 . . . . .
 . # . # .
@@ -36,26 +11,58 @@ input.onButtonPressed(Button.A, () => {
 # . . . #
 . # # # .`);
 });
-input.onGesture(Gesture.Shake, () => {
+input.onButtonPressed(Button.B, () => {
+    led.stopAnimation();
     basic.showLeds(`
-. . . . .
 . # . # .
-. . . . .
-. # # # .
-# . . . #`);
+# . # . #
+# . . . #
+. # . # .
+. . # . .`);
 });
 ``` 
+# About
 
-To run a student's project in the web browser, KindScript compiles it into JavaScript, the scripting language built into all web browsers.
+The [BBC micro:bit](https://www.microbit.co.uk) is a [pocket-size computer](/device) with a 5x5 display of 25 LEDs, Bluetooth and sensors that can be programmed by anyone.
+The BBC micro:bit was made possible by many [partners](https://www.microbit.co.uk/partners).
 
-C++ and Touch Develop Libraries
-The C++ micro:bit library, created at Lancaster University, provides access to the hardware functions of the micro:bit, as well as a set of helper functions (such as displaying a number/image/string on the LED screen). The Touch Develop micro:bit library mirrors the functions of the C++ library. When a Touch Develop script is compiled to C++, the calls to Touch Develop micro:bit functions are replaced with calls to the corresponding C++ functions.
+The micro:bit provides an easy and fun introduction to programming and making – switch on, program it to do something fun – wear it, customize it.
+Just like Arduino, the micro:bit can be connected to and interact with sensors, displays, and other devices. 
 
-Above, see the mapping from the Touch Develop "show number" function to its corresponding the C++ function.
+## Hardware: The Device
+
+Learn about about the [hardware components](/device) of the micro:bit to make the most of it!
+
+## Programming: Blocks or JavaScript
+
+The student can program the BBC micro:bit using [Blocks](/blocks) or [JavaScript](/typescript), via the [micro:bit APIs](/reference):
+
+```blocks
+basic.showString("Hi!");
+```
+
+## Compile and Flash: Your Program!
+
+When a user has her code ready, she can connect her BBC micro:bit to a computer via a USB cable, so it appears as a mounted drive (named MICROBIT). 
+
+Compilation to ARM thumb machine code from [Blocks](/blocks) or [JavaScript](/typescript) happens in the browser.
+
+The student is prompted to save the ARM binary program to a file, which she then simply drags to the micro:bit mounted drive, 
+which flashes the micro:bit device with the new program.
+
+## Simulator: Test Your Code
+
+Before a student compiles her code for the micro:bit, she can run it using the micro:bit simulator, all within the confines of a web browser. 
+The simulator has support for the LED screen, buttons, as well as compass, accelerometer, and digital I/O pins.
 
 ## C++ Runtime
 
-The C++ BBC micro:bit library, created at [Lancaster University](http://www.lancaster.ac.uk/), provides access to the hardware functions of the micro:bit, 
+The [C++ BBC micro:bit runtime](http://lancaster-university.github.io/microbit-docs/), created at [Lancaster University](http://www.lancaster.ac.uk/), provides access to the hardware functions of the micro:bit, 
 as well as a set of helper functions (such as displaying a number/image/string on the LED screen). 
-The JavaScript micro:bit library mirrors the functions of the C++ library. 
-When code is compiled to C++, the calls to JavaScript micro:bit functions are replaced with calls to the corresponding C++ functions.
+
+The [micro:bit library](/reference) mirrors the functions of the C++ library. 
+When code is compiled to ARM machine code, the calls to JavaScript micro:bit functions are replaced with calls to the corresponding C++ functions.
+
+## Open Source
+
+The editor for the BBC micro:bit is [open source](/open-source) on GitHub. Contributors are welcome!

docs/blocks.md

@@ -0,0 +1,8 @@
+# Blocks language
+
+```namespaces
+for (let i = 0;i<5;++i) {}
+if (true){}
+let x = 0;
+Math.random(5);
+```

docs/blocks/logic.md

@@ -0,0 +1,9 @@
+# Logic
+
+```cards
+if(true) {}
+true;
+true && false;
+!true;
+1 != 0;
+```

docs/blocks/logic/boolean.md

@@ -1,10 +1,8 @@
 # Boolean
 
-true or false. #docs #boolean #var
+true or false.
 
-### @parent blocks/language
-
-A Boolean has one of two possible values: `true`; `false`.  Boolean (logical) operators (*and*, *or*, *not*) take Boolean inputs and yields a Boolean value. Comparison operators on other types ([numbers](/microbit/reference/types/number), [strings](/microbit/reference/types/string) yields a Boolean value.
+A Boolean has one of two possible values: `true`; `false`.  Boolean (logical) operators (*and*, *or*, *not*) take Boolean inputs and yields a Boolean value. Comparison operators on other types ([numbers](/reference/types/number), [strings](/reference/types/string) yields a Boolean value.
 
 The following blocks represent the true and false Boolean values, which can be plugged in anywhere a Boolean value is expected:
 
@@ -21,7 +19,7 @@ true || false;
 !true;
 ```
 
-The next six blocks represent comparison operators that yield a Boolean value. Most comparisons you will do involve [numbers](/microbit/reference/types/number):
+The next six blocks represent comparison operators that yield a Boolean value. Most comparisons you will do involve [numbers](/reference/types/number):
 
 ```blocks
 42 == 0;
@@ -32,7 +30,7 @@ The next six blocks represent comparison operators that yield a Boolean value. M
 42 >= 0;
 ```
 
-Boolean values and operators are often used with an [if](/microbit/blocks/if) or [while](/microbit/reference/loops/while) statement to determine which code will execute next. For example:
+Boolean values and operators are often used with an [if](/blocks/logic/if) or [while](/blocks/loops/while) statement to determine which code will execute next. For example:
 
 ### Functions that return a Boolean
 
@@ -96,13 +94,9 @@ if(x < 5) {
 } 
 ```
 
-See the documentation on [Numbers](/microbit/reference/types/number) for more information on comparing two Numbers. You can also [compare strings](/microbit/reference/types/string-functions) using the `equals` function.
-
-### Lessons
-
-[rotation animation](/microbit/lessons/rotation-animation), [love meter](/microbit/lessons/love-meter), [zoomer](/microbit/lessons/zoomer)
+See the documentation on [Numbers](/reference/types/number) for more information on comparing two Numbers. You can also [compare strings](/reference/types/string-functions) using the `equals` function.
 
 ### See also
 
-[if](/microbit/blocks/if), [while](/microbit/reference/loops/while), [number](/microbit/reference/types/number)
+[if](/blocks/logic/if), [while](/blocks/loops/while), [number](/reference/types/number)
 

docs/blocks/logic/if.md

@@ -0,0 +1,28 @@
+# If
+
+### @parent blocks/language
+ 
+
+Conditionally run code depending on whether a [Boolean](/blocks/logic/boolean) condition is true or false.
+
+```blocks
+if(true) {
+}
+```
+
+Click on the dark blue gear icon (see above) to add an *else* or *if* to the current block.
+
+### Example: adjusting screen brightness
+
+```blocks
+if(input.lightLevel()<100){
+    led.setBrightness(255);
+}
+```
+
+If the [light level](/reference/input/light-level) is `< 100`, this code sets the brightness to `255`:
+
+### See also
+
+[while loop](/blocks/loops/while), [for](/blocks/loops/for), [boolean](/blocks/logic/boolean)
+

docs/blocks/loops.md

@@ -0,0 +1,7 @@
+# Loops
+
+```cards
+for(let i = 0;i<5;i++) {}
+while(true) {}
+basic.forever(() => {});
+```

docs/blocks/loops/for.md

@@ -0,0 +1,20 @@
+# For
+
+### @parent blocks/language
+ 
+Run part of the program the number of times you say.
+
+### Example: Count to 4
+
+This program will show the numbers 0, 1, 2, 3, and 4 one after another on the LED screen.
+
+```blocks
+for(let i = 0; i < 5; ++i) {
+basic.showNumber(i)
+}
+```
+
+### See also
+
+[repeat](/blocks/loops/repeat), [while](/blocks/loops/while), [if](/blocks/logic/if), [show number](/reference/basic/show-number)
+

docs/blocks/loops/repeat.md

@@ -0,0 +1,12 @@
+# Repeat
+
+Run part of the program the number of times you say.
+
+### Block Editor
+
+![](/static/mb/blocks/contents-0.png)
+
+### See also
+
+[for](/blocks/loops/for), [while](/blocks/loops/while), [if](/blocks/logic/if), [show number](/reference/basic/show-number)
+

docs/blocks/loops/while.md

@@ -0,0 +1,29 @@
+# While
+
+Repeat code while a [Boolean](/blocks/logic/boolean) `condition` is true.
+
+```blocks
+while(true) {
+}
+```
+
+The while loop has a *condition* that evaluates to a [Boolean](/blocks/logic/boolean) value. After the `do` keyword, add the code that you want to run while the `condition` is `true`. The while loop concludes with `end while`.
+
+The condition is tested before any code runs. Which means that if the condition is false, the code inside the loop doesn't execute.
+
+### Example: diagonal line
+
+The following example uses a while loop to make a diagonal line on the LED screen (points `0, 0`, `1, 1`, `2, 2`, `3, 3`, `4, 4`).
+
+```blocks
+let index = 4;
+while(index >= 0) {
+    led.plot(index, index);
+    index--;
+}
+```
+
+### See also
+
+[on button pressed](/reference/input/on-button-pressed), [for](/blocks/loops/for), [if](/blocks/logic/if), [forever](/reference/basic/forever)
+

docs/blocks/math.md

@@ -0,0 +1,37 @@
+# Math
+
+[Numeric](/reference/types/number) values: 0, 1, 2, ...
+
+```blocks
+0;
+1;
+2;
+```
+
+Arithmetic binary operation (+, -, *, /)
+
+```blocks
+0+1;
+0-1;
+1*2;
+3/4;
+```
+
+Absolute value
+
+```blocks
+Math.abs(-5);
+```
+
+Minimum/maximum of two values
+
+```blocks
+Math.min(0, 1);
+Math.max(0, 1);
+```
+
+Random value
+
+```blocks
+Math.random(5);
+```

docs/blocks/math/math.md

@@ -0,0 +1,42 @@
+# Math functions
+
+### @parent blocks/language
+
+The math library includes math related functions that you can use with [Numbers](/reference/types/number).
+
+### abs
+
+math `->` abs (x : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
+
+returns the absolute value of input parameter `x`
+
+![](/static/mb/blocks/math-0.png)
+
+### max
+
+math `->` max (x : [Number](/reference/types/number), y : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
+
+returns the larger of two input numbers (`x` and `y`)
+
+![](/static/mb/blocks/math-1.png)
+
+### min
+
+math `->` min (x : [Number](/reference/types/number), y : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
+
+returns the smaller of two input numbers (`x` and `y`)
+
+![](/static/mb/blocks/math-2.png)
+
+### random
+
+math `->` random (limit : [Number](/reference/types/number)) *returns* [Number](/reference/types/number)
+
+returns a random [Number](/reference/types/number) between 0 and the parameter *limit*
+
+![](/static/mb/blocks/math-3.png)
+
+### See also
+
+[Number](/reference/types/number)
+

docs/blocks/variables.md

@@ -0,0 +1,21 @@
+## Variables
+
+[Assign](/blocks/variables/assign) (set) a variable's value
+
+```blocks
+let x = 0;
+```
+
+Get a variable's value
+
+```blocks
+let x = 0;
+x;
+```
+
+[Change](/blocks/variables/change-var) a variable's value
+
+```blocks
+let x = 0;
+x+=1;
+```

docs/blocks/variables/assign.md

@@ -0,0 +1,36 @@
+# Assignment Operator
+
+Use an equals sign to make a [variable](/blocks/variables/var) store the [number](/reference/types/number) 
+or [string](/reference/types/string) you say.
+
+When you use the equals sign to store something in a variable, the equals sign is called
+an *assignment operator*, and what you store is called a *value*.
+
+### Storing numbers in variables
+
+This program makes the variable `item` equal `5` and then shows it on the [LED screen](/device/screen).
+
+````blocks
+let item = 5
+basic.showNumber(item)
+````
+
+### Storing strings in variables
+
+This program makes the variable `name` equal `Joe` and then shows it on the [LED screen](/device/screen).
+
+````blocks
+let name = "Joe"
+basic.showString(name);
+````
+
+### Notes
+
+You can use the assignment operator with variables of 
+every [type](/reference/types). A *type* is which kind of thing
+a variable can store, like a number or string.
+
+### See also
+
+[variable](/blocks/variables/var), [types](/reference/types)
+

docs/blocks/variables/change-var.md

@@ -0,0 +1,40 @@
+# Change Value
+
+Set the value for local and global variables.
+
+### @parent blocks/change-value
+
+Change the value of a variable
+
+```blocks
+let x = 0
+x += 1
+```
+
+### Declare a variable
+
+Use the assignment operator to set the value of a [variable](/blocks/variables/var). Change the value of a variable from 0 to 1 using the change item block. Like this:
+
+```blocks
+let x = 0
+x += 1
+```
+
+### Example
+
+Use the assignment operator to set the value of a [variable](/blocks/variables/var). Change the value of a variable from 0 to 1 using the change item block. Then display the new value of the variable on the LED screen. Like this:
+
+```blocks
+let x = 0;
+x += 1;
+basic.showNumber(x);
+```
+
+### Notes
+
+* You can use the assignment operator with variables of each of the supported [types](/reference/types).
+
+### See also
+
+[variable](/blocks/variables/var), [types](/reference/types)
+

docs/blocks/variables/var.md

@@ -0,0 +1,87 @@
+# Local Variables
+
+How to define and use local variables.
+
+### @parent language
+
+A variable is a place where you can store and retrieve data. Variables have a name, a [type](/reference/types), and value:
+
+* *name* is how you'll refer to the variable
+* *type* refers to the kind of data a variable can store
+* *value* refers to what's stored in the variable
+
+### Var statement
+
+Use the Block Editor variable statement to create a variable 
+and the [assignment operator](/blocks/variables/assign) 
+to store something in the variable.
+
+For example, this code stores the number `2` in the `x` variable:
+
+```blocks
+let x = 2;
+```
+Here's how to define a variable in the Block Editor:
+
+1. Click `variables`.
+
+2. Change the default variable name if you like.
+
+3. Drag a block type on the right-side of the [assignment operator](/blocks/variables/assign) and click the down arrow to change the variable name.
+
+A variable is created for the number returned by the [brightness](/reference/led/brightness) function.
+
+```blocks
+let b = led.brightness();
+```
+
+### Using variables
+
+Once you've defined a variable, just use the variable's name whenever you need what's stored in the variable. For example, the following code shows the value stored in `counter` on the LED screen:
+
+```blocks
+let counter = 1;
+basic.showNumber(counter);
+```
+
+To change the contents of a variable use the assignment operator. The following code sets `counter` to 1 and then increments `counter` by 10:
+
+```blocks 
+let counter = 1;
+counter = counter + 10;
+basic.showNumber(counter);
+```
+
+### Why use variables?
+
+If you want to remember and modify data, you'll need a variable. 
+A counter is a great example:
+
+```blocks
+let counter = 0;
+input.onButtonPressed(Button.A, () => { 
+  counter = counter + 1;
+  basic.showNumber(counter);
+});
+```
+
+### Local variables
+
+Local variables exist only within the function or block of code where they're defined. For example:
+
+```blocks
+// x does NOT exist here.
+if (led.brightness() > 128) {
+  // x exists here
+  let x = 0;
+}
+```
+
+#### Notes
+
+* You can use the default variable names if you'd like, however, it's best to use descriptive variable names. To change a variable name in the editor, select the down arrow next to the variable and then click "new variable".
+
+### See also
+
+[types](/reference/types), [assignment operator](/blocks/variables/assign)
+

docs/device.md

@@ -4,121 +4,86 @@ All the bits and pieces that make up your BBC micro:bit
 
 ![](/static/mb/device-0.png)
 
-### Lights
+### LED Screen and Status LED
 
-### What are the red lights on the front?
+The red lights are [LEDs](/device/screen) (light emitting diodes) and form a 5 x 5 LED Screen. 
+They can be set to on/off and the brightness can be controlled.
 
-The red lights are [LEDs](/microbit/device/screen) (light emitting diodes) and form a 5 x 5 grid. They can be set to on/off and the brightness can be controlled.
-
-### What is the yellow light on the back of the micro:bit?
-
-It is the status LED. It flashes yellow when the system wants to tell the user that something has happened.
+The yellow light on the back of the micro:bit is the status LED.
+It flashes yellow when the system wants to tell the user that something has happened.
 
 ### Buttons
 
-### What are the buttons for?
+Buttons A and B are a form of input.  When you press a button, it completes an electrical circuit. 
+The micro:bit can detect either of its two buttons being pressed/released and be programmed 
+to act on these events.
 
-Buttons A and B are a form of input. They detect when the button is being pressed. When you press one of the buttons, it completes an electrical circuit. The micro:bit can detect either of its two buttons being pressed and un-pressed and be programmed to act on that or send the information to another device.
+Button R on the back of the micro:bit is a system button. It has different uses. 
+When you have downloaded and run your code onto your micro:bit, press Button R to restart and run your program from the beginning.
 
-Button R on the back of the micro:bit is a system button. It has different uses.  When you have downloaded and run your code onto your micro:bit, press Button R to restart  and run your program from the beginning.
+### USB connection
 
-When you plug in your micro:bit, it should appear as MICROBIT. If you accidentally hold down the reset button as you’re plugging in your micro:bit, the micro:bit will appear as a MAINTENANCE drive instead of MICROBIT. This is known as maintenance mode.**
+When you plug in your micro:bit, it should appear as MICROBIT. 
+If you accidentally hold down the reset button as you’re plugging in your micro:bit, 
+the micro:bit will appear as a MAINTENANCE drive instead of MICROBIT. This is known as maintenance mode.**
 
 To continue programming your micro:bit YOU MUST unplug your USB and reconnect it. Check that the drive now shows as MICROBIT.
 
-**Use with caution. If you click on the drive while it shows as MAINTENANCE, you can see which version of firmware you have running on your micro:bit. Firmware on your micro:bit should be up-to-date already. You can find the version of firmware in the 'version.txt' file on the micro:bit. Further information on the firmware can be found here:
+**Use with caution. If you click on the drive while it shows as MAINTENANCE, 
+you can see which version of firmware you have running on your micro:bit. 
+Firmware on your micro:bit should be up-to-date already. 
+You can find the version of firmware in the 'version.txt' file on the micro:bit. Further information on the firmware can be found here:
 
 https://developer.mbed.org/platforms/Microbit/#firmware
 
 ### Compass
 
-### Why is there a compass on the micro:bit?
-
-The compass can detect magnetic fields such as the Earth’s magnetic field. As the micro:bit has this compass, it is possible to detect the direction it is moving in. The micro:bit can detect where it is facing and movement in degrees. This data can be used by the micro:bit in a program or be sent to another device.
+The compass can detect magnetic fields such as the Earth’s magnetic field. 
+As the micro:bit has this compass, it is possible to detect the direction it is moving in. 
+The micro:bit can detect where it is facing and movement in degrees. 
+This data can be used by the micro:bit in a program or be sent to another device.
 
 ### Accelerometer
 
-### Why is there an accelerometer on the micro:bit?
+There is an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. 
+It converts analogue information into digital form that can be used in micro:bit programs. 
+Output is in milli-g. The device will also detect a small number of standard actions e.g. shake, tilt and free-fall.
 
-There is a an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. It converts analogue information into digital form that can be used in micro:bit programs. Output is in milli-g. The device will also detect a small number of standard actions e.g. shake, tilt and free-fall.
+### Pins
 
-### PINS
-
-### What are the rings labelled 0, 1, 2 on the bottom edge of the micro:bit?
-
-These are labels for the input/output pins P0, P1, P2, which you can attach external sensors to such as thermometers or moisture detectors. The pins can be a form of input or output. You can read more about large and small pins [here](/microbit/device/pins).
+The pins can be a form of input or output. 
+There are labels for the input/output pins P0, P1, P2, which you can attach external sensors to such as thermometers or moisture detectors. 
+You can read more about large and small pins [here](/device/pins).
 
 ### How do I connect the micro:bit to my computer?
 
-It can be connected to your computer or device with a micro USB. Data can be sent and received between the micro:bit and the computer so programs can be downloaded from Windows and Macs onto the micro:bit via this USB data connection. You can read more information on how to run scripts on your micro:bit [here](/microbit/device/usb), and about the error messages you might get [here](/microbit/device/error-codes).
+Your micro:bit can be connected to your computer via a micro USB cable. 
+Data can be sent and received between the micro:bit and the computer so programs 
+can be downloaded from Windows, Macs and Chromebooks onto the micro:bit via this USB data connection. 
+You can read more information on how to run scripts on your micro:bit [here](/device/usb), 
+and about the error messages you might get [here](/device/error-codes).
 
-### Batteries
+### Powering your micro:bit
 
-### How do I power my micro:bit?
+When your micro:bit is connected to your computer with the micro USB, it doesn’t need another power source.  
+When your micro:bit isn’t connected to your computer, tablet or mobile, you will need 2 x AAA 1.5 V batteries to power it.
 
-When your micro:bit  is connected to your computer with the micro USB, it doesn’t need another power source.  When your micro:bit isn’t connected to your computer, tablet or mobile, you will need 2 x AAA 1.5 V batteries to power it.
+The pins labelled 3V and GND are the power supply pins. 
+You can attach an external device such as a motor to these and power it using the battery or USB.
 
-### 3V GND
+### Serial Communication
 
-### What are the rings labelled 3V and GND?
+The BBC micro:bit can send an receive data via [serial communication](/device/serial). The serial data can be transfered via USB or BlE.
 
-The pins labelled 3V and GND are the power supply pins. You can attach an external device such as a motor to these and power it using the battery or USB.
+### Bluetooth Low Energy (BLE) Antenna
 
-### What is a Bluetooth Low Energy Antenna?
-
-You will see this labelled BLE ANNTENA on the back of your micro:bit. It is for a messaging service, built for the Internet of Things so that devices can talk to each other. The micro:bit is a peripheral device which can talk to a central device like a smart phone or tablet that has Bluetooth Low Energy (BLE). The micro:bit can send signals and receive signals from a central device so another BLE device can control the micro:bit or the micro:bit can control another BLE device.
-
-### What is Bluetooth Low Energy?
-
-Bluetooth wireless technology was developed as an alternative to data cables and allowed wireless communication between devices such as PCs, smartphones and tablets. Bluetooth® Smart or Bluetooth Low Energy is a power-friendly version of Bluetooth wireless technology.
-
-### What is the Internet of Things?
-
-The Internet of Things (IoT) was first talked about more than 15 years ago, when it was speculated that objects and people would be able to connect wirelessly over the internet.  Objects can be detected and controlled remotely, allowing greater integration between the physical and computer based world.  It will let you to remotely control your alarm system, thermostat or lights in your home. It has many applications in different fields including manufacturing, health and fitness, consumer electronics and the home.
+You will see the label BLE ANTENNA on the back of your micro:bit. It is for a messaging service, 
+so that devices can talk to each other. The micro:bit is a peripheral 
+device which can talk to a central device like a smart phone or tablet that has Bluetooth Low Energy (BLE). 
+The micro:bit can send signals and receive signals from a central device so another BLE device can 
+control the micro:bit or the micro:bit can control another BLE device.
 
 ### Technical Information
 
-The micro:bit has been designed to be a bare-board micro controller for use by children aged 11-12. The device has been through extensive safety and compliance testing to the following standards:
-
-### Safety
-
-IEC 60950-1:2005 (Second Edition) + Am 1:2009 + Am 2:2013
-
-### EMC
-
-EN 55032: 2012
-
-EN 55024: 2010
-
-EN 55022:2010
-
-EN 301 489-1 V1.9.2 (2011-09)
-
-EN 301 489-17 V2.2.1 (2012-09)
-
-### Radio Spectrum
-
-ETSI EN 300 328 V1.9.1 (2015-02)
-
-EN 62479:2010
-
-### Chemical
-
-Restriction of Hazardous Substances (RoHS) 2011/65/EU Annex II article 4(1)
-
-EN71-3:2013 + A1:2014 - Migration of certain elements.
-
-Analysis of the 163 substances of very high concern (SVHC) on the Candidate List for authorization, concerning Regulation (EC) No. 1907/2006 as published on the European Chemicals Agency (ECHA) website.
-
-![](/static/mb/device-1.jpg)
-
-The micro:bit device features Bluetooth Low Energy radio. The radio on the device operates in the following frequencies:
-
-Frequency Range: 2402MHz to 2480MHz
-
-Bluetooth Version: V4.0 Bluetooth Low Energy
-
-### Declaration of Conformity
-
-The document can be downloaded by clicking here for the [Declaration of Conformity](https://microbit0.blob.core.windows.net/pub/hkeghjes/declaration-of-conformity.pdf)
-
+The micro:bit has been designed to be a bare-board micro controller for use by children aged 11-12. 
+More information is available at the [BBC web site](http://www.microbit.co.uk/device).

docs/device/contents.md

@@ -1,21 +1,19 @@
 # micro:bit - the device
 
-The micro:bit device #docs
-
 The micro:bit is a very capable device with many components:
 
-* [the USB connector](/microbit/device/usb)
-* [the LED screen](/microbit/device/screen)
+* [the USB connector](/device/usb)
+* [the LED screen](/device/screen)
 * [the buttons]
 * [the accelerometer]
 * [the compass]
-* [the pins](/microbit/device/pins)
+* [the pins](/device/pins)
 * [the battery plug]
 
 The micro:bit embodies many fundamental concepts in computer science. To learn more, read:
 
-* [the micro:bit - a reactive system](/microbit/device/reactive)
+* [the micro:bit - a reactive system](/device/reactive)
 
 Sometimes, your micro:bit may display an error code. For more information, see:
 
-* [the error codes](/microbit/device/error-codes)
+* [the error codes](/device/error-codes)

docs/device/crocodile-clips.md

@@ -1,8 +1,7 @@
 # crocodile clips
 
-The on pin pressed accessories. 
-
-Register an [event handler](/microbit/reference/event-handler) that will execute whenever the user attaches one side of the crocodile clip to the `GND` pin, then connects and disconnects the unattached side of the crocodile clip to pin `0`, `1`, or `2`.
+The large holes at the bottom of the board are designed to attach alligator/crocodile clips.
+Register an event that will execute whenever the user attaches one side of the crocodile clip to the `GND` pin, then connects and disconnects the unattached side of the crocodile clip to pin `0`, `1`, or `2`.
 
 ### Example: on pin pressed with random numbers
 
@@ -12,15 +11,7 @@ This example displays a random number every time the crocodile clip holds  `GND`
 
 ### Connecting Crocodile Clips
 
-![](/static/mb/crocodile-clips-1.jpg)
-
-![](/static/mb/crocodile-clips-2.jpg)
-
-### Lessons
-
-[love meter](/microbit/lessons/love-meter)
-
 ### See also
 
-[micro:bit pins](/microbit/device/pins), [pin is pressed](/microbit/reference/input/pin-is-pressed), [analog read pin](/microbit/reference/pins/analog-read-pin), [analog write pin](/microbit/reference/pins/analog-write-pin), [digital read pin](/microbit/reference/pins/digital-read-pin), [digital write pin](/microbit/reference/pins/digital-write-pin)
+[micro:bit pins](/device/pins), [pin is pressed](/reference/input/pin-is-pressed), [analog read pin](/reference/pins/analog-read-pin), [analog write pin](/reference/pins/analog-write-pin), [digital read pin](/reference/pins/digital-read-pin), [digital write pin](/reference/pins/digital-write-pin)
 

docs/device/error-codes.md

@@ -1,6 +1,6 @@
 # Error codes
 
-The micro:bit error codes #docs
+The micro:bit error codes
 
 Your micro:bit may encounter a situation that prevents it from running your code. When this happens, a frowny face will appear on your micro:bit screen (see picture) followed by an error number.
 
@@ -13,5 +13,5 @@ Below is a list of error numbers and what they mean:
 
 ### See also
 
-[Run scripts on your micro:bit](/microbit/device/usb)
+[Run scripts on your micro:bit](/device/usb)
 

docs/device/reactive.md

@@ -1,7 +1,5 @@
 # The micro:bit - a reactive system
 
-The micro:bit is a reactive system. #docs
-
 ### Computing systems
 
 What sort of a *computing system* is the micro:bit?
@@ -18,7 +16,7 @@ The micro:bit is a *reactive system* – it reacts continuously to external even
 
 We want reactive systems to be responsive, which means to react in a timely manner to events. For example, when you play a computer game, it’s frustrating if you press a button to make a character jump, but it doesn’t immediately jump.  A delay in reacting, or lack of responsiveness , can be the difference between life and death, both in the real and virtual worlds.
 
-Let’s consider a simple example: you want to program your micro:bit to accurately count the number of times the A button has been pressed and continuously display the current count on the 5x5 [LED screen](/microbit/device/screen).   Because the LED screen is small, we can only display one digit of a number at a time on it. The [show number](/microbit/reference/basic/show-number) function will scroll the digits of a number across the screen so you can read it.
+Let’s consider a simple example: you want to program your micro:bit to accurately count the number of times the A button has been pressed and continuously display the current count on the 5x5 [LED screen](/device/screen).   Because the LED screen is small, we can only display one digit of a number at a time on it. The [show number](/reference/basic/show-number) function will scroll the digits of a number across the screen so you can read it.
 
 Let’s say that the current count is 42 and the number 42 is scrolling across the LED screen. This means there is some code executing to perform the scroll.  So, what should happen if you press the A button during the scroll?  It would be a bad idea to ignore the button press, so some code should record the occurrence of the button press. But we just said there already is code running in order to scroll the number 42!  If we wait until the code scrolling the 42 has finished to look for a button press, we will miss the button press.  We want to avoid this sort of unresponsiveness.
 
@@ -52,7 +50,7 @@ The first job of the scheduler is to allow multiple *subprograms* to be queued u
 
 ```
 export function countButtonPresses() {
-    input.onButtonPressed("A", () => {
+    input.onButtonPressed(Button.A, () => {
         count = count + 1
     })
     basic.forever(() => {
@@ -65,7 +63,7 @@ export function countButtonPresses() {
 The program above contains three statements that execute in order from top to bottom. The first statement
 
 ```
-input.onButtonPressed("A", () => {
+input.onButtonPressed(Button.A, () => {
     count = count + 1
 })
 ```
@@ -132,14 +130,14 @@ As a result, you can easily add a new capability to the micro:bit by just adding
 
 ```
 export function countButtonPressesWithReset() {
-    input.onButtonPressed("A", () => {
+    input.onButtonPressed(Button.A, () => {
         count = count + 1
     })
     basic.forever(() => {
         basic.showNumber(count, 150)
     })
     count = 0
-    input.onButtonPressed("B", () => {
+    input.onButtonPressed(Button.B, () => {
         count = 0
     })
 }

docs/device/screen.md

@@ -2,56 +2,89 @@
 
 The micro:bit LED screen 
 
-![](/static/mb/device/screen-0.png)
+```sim
+    basic.showLeds(`
+        # . # . #
+        . # . # .
+        # . # . #
+        . # . # .
+        # . # . #
+        `);
+```
 
 The micro:bit LED screen consists of 25 red LED lights arranged in a 5X5 grid (5 LEDs across by 5 LEDs down).
+In the screen above, we created a checkerboard pattern using the LEDs.
 
 ### Which LED?
 
-You use ``x , y`` coordinates to specify a particular LED in the grid; where ``x`` is the horizontal position and ``y`` is the vertical position (0, 1, 2, 3, 4). To figure out the ``x``, ``y`` coordinates, position your micro:bit horizontally, like a credit card (see picture above).
+You use `(x ,y)` coordinates to specify a particular LED in the grid; 
+where `x` is the horizontal position (0,1,2,3,4) and `y` is the vertical position 
+(0, 1, 2, 3, 4). 
+
+To figure out the ``x``, ``y`` coordinates, position your micro:bit horizontally, like a credit card (see picture above).
 
 Here are the x, y coordinates for the LEDs in the 5X5 grid:
 
-`0, 0` `1, 0` `2, 0` `3, 0` `4, 0`
+`(0,0)` `(1,0)` `(2,0)` `(3,0)` `(4,0)`
 
-`0, 1` `1, 1` `2, 1` `3, 1` `4, 1`
+`(0,1)` `(1,1)` `(2,1)` `(3,1)` `(4,1)`
 
-`0, 2` `1, 2` `2, 2` `3, 2` `4, 2`
+`(0,2)` `(1,2)` `(2,2)` `(3,2)` `(4,2)`
 
-`0, 3` `1, 3` `2, 3` `3, 3` `4, 3`
+`(0,3)` `(1,3)` `(2,3)` `(3,3)` `(4,3)`
 
-`0, 4` `1, 4` `2, 4` `3, 4` `4, 4`
+`(0,4)` `(1,4)` `(2,4)` `(3,4)` `(4,4)`
 
-The x, y coordinates for the LED in the centre of the grid are `2, 2`. Starting from `0, 0` count over 2 columns and then down 2 rows.
+The x, y coordinates for the LED in the centre of the grid are `(2,2)`. Starting from `(0,0)` count over 2 columns and then down 2 rows.
+
+### Check your understanding
+
+Which LEDs are turned on in the checkboard pattern above? 
 
 ### Row, column - 1
 
-Since the row and column numbers start at 0, an easy way to figure out the x, y coordinates is to subtract 1 from the row and column number (when counting from 1). In other words, to specify the LED in the 4th column 5th row, subtract 1 from each number to get coordinates `3, 4`.
+Since the row and column numbers start at 0, an easy way to figure out the (x,y) coordinates 
+is to subtract 1 from the row and column number (when counting from 1). 
+In other words, to specify the LED in the 4th column 5th row, subtract 1 from each number to get coordinates `(3,4)`.
 
 ### Turn a LED on/off
 
-Use [plot](/microbit/led/plot) and [unplot](/microbit/led/unplot) to turn a LED on or off
+Use [plot](/reference/led/plot) and [unplot](/reference/led/unplot) to turn a LED on or off
+
+```blocks
+led.plot(0,0);
+led.plot(1,1);
+basic.pause(1000);
+led.unplot(0,0);
+basic.pause(1000);
+led.unplot(1,1);
+```
 
 ### Is a LED on/off?
 
-Use the [point](/microbit/led/point) function to find out if a LED is on or off.
+Use the [point](/reference/led/point) function to find out if a LED is on or off.
+
+```blocks
+if(led.point(0,0)) {
+}
+```
 
 ### Display images, strings and numbers
 
-Instead of turning individual LEDs on or off, as above, you can display an [image](/microbit/reference/image/image) directly to the screen or show text/numbers on screen using the [show number](/microbit/reference/basic/show-number)/[show string](/microbit/reference/basic/show-string) function.
+Instead of turning individual LEDs on or off, as above, you can display an [image](/reference/images/image) directly to the screen or show text/numbers on screen using the [show number](/reference/basic/show-number)/[show string](/reference/basic/show-string) function.
 
 ### The display buffer
 
 The micro:bit runtime keeps an in-memory representation of the state of all 25 LEDS. This state is known as the "display buffer" and controls which LEDS are on and which are off. The plot/unplot/point functions access the display buffer directly. On the other hand, the functions that show an image, number or string overwrite the buffer completely. To illustrate, first try running this code sequence
 
-```
-basic.showString("d", 150)
+```blocks
+basic.showString("d")
 led.plot(0, 0)
 ```
 
 You will see the letter "d" displayed as well as the LED in position `0,0` lit up. Now try reversing the order of the two statements above:
 
-```
+```blocks
 led.plot(0, 0)
 basic.showString("d", 150)
 ```

docs/device/serial.md

@@ -0,0 +1,83 @@
+# Serial
+
+The [serial](/reference/serial) supports [serial communication](https://en.wikipedia.org/wiki/Serial_port) between the BBC micro:bit and another computer. Basically, this allows you to send data from the micro:bit to your own computer. This is very useful for debugging purposes: you can add `write line` statements in your code and see them display on your computer as the program executes.
+
+The code below shows a simple script that sends a line when the BBC micro:bit starts and another line each time the button ``A`` is pressed.
+
+```blocks
+serial.writeLine("started...")
+input.onButtonPressed(Button.A, () => {
+    serial.writeLine("A pressed")
+})
+```
+
+Data is also automatically streamed to serial by the ** bar graph** block
+and picked up by the editor. This data can be streamed to the cloud as well.
+
+```blocks
+basic.forever(() => {
+   led.plotBarGraph(input.acceleration(Dimension.X), 0);
+});
+```
+
+## How to read the micro:bit's serial output from your computer
+
+Unfortunately, using the serial library requires quite a bit of a setup.
+
+### BBC micro:bit Chrome Extension
+
+If you are using the Google Chrome browser, you can use our extension to get serial data streaming in the editor.
+
+* Install the [Extension for BBC micro:bit](https://chrome.google.com/webstore/detail/extension-for-bbc-microbi/cihhkhnngbjlhahcfmhekmbnnjcjdbge?hl=en-US) on the Chrome Web Store.
+* Restart Chrome and open the web editor.
+
+### Windows
+
+You must install a device driver (for the computer to recognize the serial interface of the micro:bit); then, you must also install a terminal emulator (which is going to connect to the micro:bit and read its output). Here's how to do it:
+
+* Follow instructions at https://developer.mbed.org/handbook/Windows-serial-configuration in order to install the device driver
+
+#### Windows > Tera Term
+
+* Install the terminal emulator [Tera Term](https://ttssh2.osdn.jp/index.html.en). At the time of this writing, the latest version is 4.88 and can be downloaded [from here](http://en.osdn.jp/frs/redir.php?m=jaist&f=%2Fttssh2%2F63767%2Fteraterm-4.88.exe). Follow the instructions from the installer.
+
+Once both the driver and the terminal emulator are installed, plug in the micro:bit and wait until the device is fully setup. Then, open TeraTerm.
+
+* Hit `File` > `New Connection`
+* Check "Serial"; in the dropdown menu, pick the COM port that says "mbed Serial Port". Hit `Ok`.
+* In the menus, hit `Setup` > `Serial Port` and set the baud rate to `115200`.
+
+You should be good. Feel free to hit `Setup` > `Save Setup` in the menus to erase the default configuration file with a new one so that you don't have to type in the settings again.
+
+Please note that Windows will assign you a different COM port if you plug in another micro:bit. If you're juggling between micro:bits, you'll have to change the COM port every time.
+
+#### Windows > Putty
+
+If you prefer another terminal emulator (such as [PuTTY](http://www.putty.org/)), here are some instructions.
+
+* Open Windows's [Device Manager](https://windows.microsoft.com/en-us/windows/open-device-manager); expand the section called "Ports (COM & LPT)"; write down the com number for "mbed Serial Port" (e.g. COM14)
+* Open PuTTY; on the main screen, use the following settings: Serial / COM14 / 115200. Replace COM14 with the COM port number you wrote down previously. Feel free to type in a name and hit "Save" to remember this configuration.
+
+![](/static/mb/serial-library-0.png)
+
+* (optional): in the "Terminal" section, check "implicit cr in every lf"
+
+![](/static/mb/serial-library-1.png)
+
+### Linux
+
+(Untested).
+
+* Plug in the micro:bit
+* Open a terminal
+* `dmesg | tail` will show you which `/dev/` node the micro:bit was assigned (e.g. `/dev/ttyUSB0`)
+* Then, do: `screen /dev/ttyUSB0 115200` (install the `screen` program if you don't have it). To exit, run `Ctrl-A` `Ctrl-D`.
+
+Alternative programs include minicom, etc.
+
+### Mac OS
+
+* Plug in the micro:bit
+* Open a terminal
+* `ls /dev/cu.*` will return to you a list of serial devices; one of them will look like `/dev/cu.usbmodem1422` (the exact number depends on your computer)
+* `screen /dev/cu.usbmodem1422 115200` will open up the micro:bit's serial output. To exit, hit `Ctrl-A` `Ctrl-D`.

docs/device/simulator.md

@@ -0,0 +1,25 @@
+# Simulator
+
+The JavaScript simulator allows to test and execute most BBC micro:bit programs in the browser.
+It allows to emulate sensor data or user interactions.
+
+```sim
+input.onButtonPressed(Button.A, () => {
+   basic.showString("A");
+});
+input.onButtonPressed(Button.B, () => {
+   basic.showString("B");
+});
+input.onPinPressed(TouchPin.P0, () => {
+   basic.showString("0");
+});
+input.onPinPressed(TouchPin.P1, () => {
+   basic.showString("1");
+});
+input.onPinPressed(TouchPin.P2, () => {
+   basic.showString("2");
+});
+input.temperature()
+input.compassHeading()
+input.lightLevel()
+```

docs/device/usb.md

@@ -1,8 +1,9 @@
 # Run Scripts on your micro:bit
 
-How to compile, transfer, and run a script on your micro:bit. #docs #USB #compile #transfer
+How to compile, transfer, and run a script on your micro:bit.
 
-While you're writing and testing your Block Editor or Touch Develop scripts, you'll mostly be running scripts in your browser by clicking the `Run` button (see [run code in your browser](/microbit/js/simulator) for info about this).
+While you're writing and testing your scripts, you'll mostly be running scripts in your browser by clicking the `PLay` button 
+(see [run code in your browser](/device/simulator) for info about this).
 
 Once your masterpiece is complete, you can compile your script and run it on your micro:bit.
 
@@ -31,12 +32,6 @@ Windows
 Mac (picture bvabdbco)
 WARN: unknown picture: bvabdbco:5x3
 
-### ~hide
-
-If your computer doesn't recognise your micro:bit, please see [troubleshooting USB problems](/microbit/diagnosing-usb).
-
-### ~
-
 ## Step 2: Compile your script
 
 Next, compile your script:
@@ -133,5 +128,5 @@ Or it may appear that there are two hex files on your micro:bit so the micro:bit
 
 ### See also
 
-[Run code in a browser](/microbit/js/simulator)
+[Run code in a browser](/device/simulator)
 

docs/docs.md

@@ -1,7 +1,36 @@
 # Documentation
 
-Welcome to the documentation.
+```sim
+basic.forever(() => {
+  basic.showString("DOCS ");
+})
+input.onButtonPressed(Button.A, () => {
+    led.stopAnimation();
+    basic.showLeds(`
+. . . . .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+});
+input.onButtonPressed(Button.B, () => {
+    led.stopAnimation();
+    basic.showLeds(`
+. # . # .
+# . # . #
+# . . . #
+. # . # .
+. . # . .`);
+});
+``` 
 
-* Browse the [reference](/microbit/reference)
-* Learn more about the [device](/microbit/device)
-* Get started with [lessons](/microbit/lessons)
+* **[getting started](/getting-started)**
+* Get started with [projects](/projects)
+* Browse the [micro:bit APIs](/reference)
+* Learn more about the [micro:bit device](/device)
+* Frequently Asked Question [faq](/faq)
+* Follow up with the [release notes](/release-notes)
+
+### Developers
+
+* Learn about [packages](/packages) (possibly using C++ or ARM thumb)

docs/faq.md

@@ -0,0 +1,6 @@
+# Frequently Asked Questions
+
+## Where can I get a BBC micro:bit?
+
+More information at [http://uk.farnell.com/bbc-microbit](http://uk.farnell.com/bbc-microbit).
+

docs/getting-started.md

@@ -0,0 +1,502 @@
+# Getting started
+
+## ~avatar
+
+Are you ready to build cool BBC micro:bit programs?
+
+Here are some challenges for you. Arrange the blocks in the editor
+to make real programs that work!
+
+## ~
+
+### Happy face
+
+There are three blocks in the editor (the area to the left).
+Arrange them to look like this:
+
+```blocks
+basic.forever(() => {
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . . . . .
+        . . . . .
+        . . . . .
+        . . . . .
+        `)
+});
+```
+
+When you run this program, you will see a smiley face, then a blank
+screen, then a smiley again -- it never stops! (That's because of the
+``forever`` block.)
+
+Click **Compile** to move your program to the BBC micro:bit!
+
+### Happy unhappy face
+
+Draw an unhappy face instead of the blank screen.  Click on the dots
+in the second ``show leds`` block until it matches the blocks below.
+Now you have an **animation** (cartoon) that shows a happy face,
+then an unhappy one, then a happy one again, forever (or until
+you turn off your micro:bit)!
+
+```blocks
+basic.forever(() => {
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        . # # # .
+        # . . . #
+        `)
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+### Your turn!
+
+Pile up more ``show leds`` blocks to create your animation! Create an
+animation with at least 5 pictures.  What does this animation show?
+
+```blocks
+basic.forever(() => {
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # # # # #
+        . . . . .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        . # # # .
+        # . . . #
+        `)
+    basic.showLeds(`
+        . . . . .
+        . # . # .
+        . . . . .
+        # # # # #
+        . . . # #
+        `)
+    basic.showLeds(`
+        . . . . .
+        # . # . .
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+    basic.showLeds(`
+        . . . . .
+        . . # . #
+        . . . . .
+        # . . . #
+        . # # # .
+        `)
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+#### ~hint
+
+You can find the ``show leds`` block in the **Basic** part of the editor.
+
+#### ~
+
+### Button A and button B
+
+This program will show the word **ANTEATER** on the LED
+screen when you press button `A`.
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    basic.showString("ANTEATER");
+});
+```
+
+#### ~hint
+
+The ``showString`` block can show letters, numbers, and punctuation
+on the micro:bit screen.
+
+#### ~
+
+Now try to unscramble these blocks in the editor so that the micro:bit
+shows **BANANA** when you press button `B`.
+
+```shuffle
+input.onButtonPressed(Button.B, () => {
+    basic.showString("BANANA");
+});
+```
+#### ~hint
+
+You can find the letter `B` by clicking the letter `A` on the
+``onButtonPressed`` block.
+
+#### ~
+
+Click **Compile** to move your program to the BBC micro:bit!
+
+#### Your turn!
+
+Can you combine these blocks so your program shows your real name
+instead of **ANTEATER** when you press `A`, but _your secret agent
+name_ instead of **BANANA** when you press `B`?
+
+### Shake
+
+You can find when someone is shaking the BBC micro:bit by checking its
+**accelerometer** (it finds whether the micro:bit is speeding up or
+slowing down).
+
+Unscramble these blocks in the editor to show a frownie when someone
+shakes the micro:bit. (Ouch!)
+
+```shuffle
+input.onGesture(Gesture.Shake, () => {
+    basic.showLeds(`
+. . . . .
+. # . # .
+. . . . .
+. # # # .
+# . . . #`);
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+### Pins
+
+You can also use the pins as buttons.  (The pins are the holes in the
+metal stripe at the bottom of the micro:bit board.)  For example, hold
+the ``GND`` button with one hand and touch the ``0`` pin (called
+``P0``) with your other hand to tell the micro:bit you're pressing it.
+
+Unscramble the blocks in the editor to show a heart when you touch
+pin ``P0``.
+
+```shuffle
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showLeds(`
+. # . # .
+# . # . #
+# . . . #
+. # . # .
+. . # . .`);
+});
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+## ~hint
+
+Try this experiment: find a friend and hold hands. Touch the ``GND``
+pin while your friend presses the ``P0`` pin. You should see the
+heart! The electric current is going through your bodies and across
+your handshake to make it happen!
+
+## ~
+
+## The amazing coin flipper
+
+### ~avatar avatar
+
+Are you trying to choose whether to play soccer or go to the movies
+instead, or which toppings to have on your pizza?  Build a coin
+flipping machine with the BBC micro:bit to choose for you!
+
+### ~
+
+Here are the blocks to make your coin flipper.  When you press button
+`B`, the coin flipper will show either `H` for heads or `T` for tails
+on the LED screen.
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    if (Math.randomBoolean()) {
+        basic.showString("H");
+    } else {
+        basic.showString("T");
+    }
+});
+```
+### ~hint
+
+The ``pick random true or false`` block randomly tells the ``if``
+block `true` or `false`.  If the ``pick`` block picked `true`, the
+``if`` block shows the letter `H`. Otherwise, it shows the letter `T`.
+
+That's it!
+
+### ~
+
+### Keeping score
+
+#### ~avatar
+
+To keep track out of how many guesses you've won,
+add these blocks to your coin flipper:
+
+#### ~
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1);
+});
+input.onButtonPressed(Button.AB, () => {
+    basic.showNumber(game.score());
+});
+```
+
+These blocks mean that if you press button `A`, you will add `1` to
+your score, and if you press `A` and `B` together, the micro:bit will
+show your score.
+
+When you're done, your coin flipping program should look like this:
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    if (Math.randomBoolean()) {
+        basic.showString("H");
+    } else {
+        basic.showString("T");
+    }
+});
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1);
+});
+input.onButtonPressed(Button.AB, () => {
+    basic.showNumber(game.score());
+});
+```
+
+Flip until your thumbs get tired!
+
+## Let's play Rock Paper Scissors!
+
+### ~avatar avatar
+
+Build a Rock Paper Scissors game with the BBC micro:bit!  You can play
+the game with a friend who has it on a micro:bit.  You can also play
+it with friends who are just using their hands.  (The game is built
+like a coin flipper, but with three choices instead of two.)
+
+### ~
+
+## Step 1: Getting started
+
+We want the micro:bit to choose rock, paper, or scissors when you
+shake it.  Try creating an ``on shake`` block so when you shake the
+micro:bit, it will run part of a program.
+
+Clear up the blocks and add the blocks below.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    
+})
+```
+
+Next, when you shake the micro:bit, it should pick a random number from `0` to `2`
+and store it in the variable `item`.
+
+Add a ``set`` block with a variable. Then add a ``pick random`` block,
+and store the random number in the variable,
+like this:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+})
+
+```
+
+### ~hint
+No one can predict random numbers. That's what makes them great for Rock Paper Scissors!
+### ~
+
+Each possible number these blocks can make (`0`, `1`, or `2`) means a different picture.
+We will show the right picture for that number on the LED screen.
+
+
+## Step 2: Picking paper
+
+Put an ``if`` block after the ``let`` block that checks whether
+`item` is `0`. Make sure the ``if`` block has an ``else if`` part
+and an ``else`` part.
+
+Next, add a ``show leds`` block that shows a
+picture of a piece of paper:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+    } else if (false) {
+
+    } else {
+
+    }
+})
+```
+
+## Step 3: A random rock
+
+Now we are going to add a new picture for the micro:bit to show
+when another random number comes up.
+
+Make the ``else if`` part check if the variable `item` is `1`.
+Then add a ``show leds`` block with a picture of a rock.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+    } else if (item == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+
+    }
+})
+```
+
+## Step 4: Suddenly scissors
+
+Add a ``show leds`` block with a picture of scissors to the ``else`` part:
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let item = Math.random(3)
+    if (item == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (item == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+        basic.showLeds(`
+            # # . . #
+            # # . # .
+            . . # . .
+            # # . # .
+            # # . . #
+            `)
+    }
+})
+
+```
+
+### ~hint
+
+You don't need to check if `item` is `2` because `2` is the only number left out of `0`, `1`, and `2`.
+That's why you can use an ``else`` instead of an ``else if``.
+
+### ~
+
+Your game is ready!
+
+Click **Compile** to move your program to the BBC micro:bit!
+
+Have fun!
+
+## Step 5: Are you the greatest?
+
+Here is a way you can make your Rock Paper Scissors game better.
+When button ``A`` is pressed, 
+the micro:bit will add `1` to your score.
+
+Open the ``Game`` drawer, and then add the block ``change score by 1`` to your program,
+like this:
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+})
+
+```
+
+## Step 6: Prove you're the greatest!
+
+After your micro:bit can add `1` to the score, show how many wins you have.
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+    basic.showString("WINS:")
+    basic.showNumber(game.score())
+})
+```
+## Step 7: Staying honest
+
+Success! Your micro:bit can track wins!
+But what about losses? 
+Use the ``Game`` drawer to subtract `1` from your score when you press button `B`. 
+
+Here are all the blocks you will need:
+
+```shuffle
+input.onButtonPressed(Button.B, () => {
+    game.addScore(-1)
+    basic.showString("LOSSES:")
+    basic.showNumber(game.score())
+})
+```
+Click **Compile** to move your program to the BBC micro:bit!
+
+## Your turn!
+
+How else can you make your game better?
+Ever hear of [Rock Paper Scissors Spock Lizard](http://www.samkass.com/theories/RPSSL.html)?

docs/lessons.md

@@ -1,26 +1,24 @@
 # Lessons 
 
-Overview of lessons for the BBC micro:bit.
-
 ### @short Lessons
 
 ### ~column 
 
 ## Beginner
 
-* [Beautiful Image](/microbit/lessons/beautiful-image), show a beautiful image with show LEDs
-* [Lucky 7](/microbit/lessons/lucky-7), show a number on the LED screen with show number
-* [Answering Machine](/microbit/lessons/answering-machine), show a text message with show string
-* [Game of Chance](/microbit/lessons/game-of-chance), show a text message with game over
-* [Smiley,](/microbit/lessons/smiley) smiley and frowney faces that transition on button pressed
-* [Magic Logo,](/microbit/lessons/magic-logo) show an image on logo up
-* [Snowflake Fall](/microbit/lessons/snowflake-fall), repeat a series of images with forever
-* [Screen Wipe](/microbit/lessons/screen-wipe), turn off the LEDs with clear screen
-* [Flashing Heart](/microbit/lessons/flashing-heart), display images with a pause
-* [Blink](/microbit/lessons/blink), turn an LED on and off with plot
-* [Night Light](/microbit/lessons/night-light), dim the LEDs with set brightness
-* [Game Counter](/microbit/lessons/game-counter), displays the player's score with score and add points to score
-* [Happy Birthday](/microbit/lessons/happy-birthday), create a popular song
+* [Beautiful Image](/lessons/beautiful-image), show a beautiful image with show LEDs
+* [Lucky 7](/lessons/lucky-7), show a number on the LED screen with show number
+* [Answering Machine](/lessons/answering-machine), show a text message with show string
+* [Game of Chance](/lessons/game-of-chance), show a text message with game over
+* [Smiley,](/lessons/smiley) smiley and frowney faces that transition on button pressed
+* [Magic Logo,](/lessons/magic-logo) show an image on logo up
+* [Snowflake Fall](/lessons/snowflake-fall), repeat a series of images with forever
+* [Screen Wipe](/lessons/screen-wipe), turn off the LEDs with clear screen
+* [Flashing Heart](/lessons/flashing-heart), display images with a pause
+* [Blink](/lessons/blink), turn an LED on and off with plot
+* [Night Light](/lessons/night-light), dim the LEDs with set brightness
+* [Game Counter](/lessons/game-counter), displays the player's score with score and add points to score
+* [Happy Birthday](/lessons/happy-birthday), create a popular song
 
 ### ~
 
@@ -28,44 +26,40 @@ Overview of lessons for the BBC micro:bit.
 
 ## Intermediate
 
-* [Magic 8](/microbit/lessons/magic-8), a fortune teller game with the BBC micro:bit
-* [Guess the Number](/microbit/lessons/guess-the-number),  guess a random number with pick number
-* [Counter](/microbit/lessons/counter), display a number with a variable
-* [Love Meter](/microbit/lessons/love-meter), create a love meter with on pin pressed
-* [Rock Paper Scissors](/microbit/lessons/rock-paper-scissors), create the classic game of rock paper scissors with if statement
-* [Truth or Dare](/microbit/lessons/truth-or-dare), a game that forces each player to reveal a secret or do something funny with if statement
-* [Spinner](/microbit/lessons/spinner), spin the arrow with multiple if statements
-* [Die Roll](/microbit/lessons/die-roll), spin with more if statements
-* [Looper](/microbit/lessons/looper), display a series of numbers with a for loop index
-* [Strobe Light](/microbit/lessons/strobe-light), develop shapes with a nested for loops
-* [Temperature](/microbit/lessons/temperature), get the ambient temperature (degree Celsius °C)
-* [Digi Yoyo](/microbit/lessons/digi-yoyo), create a counter with a while loop
-* [Rotation Animation](/microbit/lessons/rotation-animation), control an animation with a boolean variable
-* [Compass](/microbit/lessons/compass), displays the direction the BBC micro:bit is pointing with compass
-* [Zoomer](/microbit/lessons/zoomer), measure the force with acceleration
-* [Glowing Pendulum](/microbit/lessons/glowing-pendulum), construct a pendulum that glows using acceleration
-* [Classic Beatbox](/microbit/lessons/classic-beatbox), make a beatbox music player with variables
-* [Light Beatbox](/microbit/lessons/light-beatbox), make a beatbox music player with light level
+* [Magic 8](/lessons/magic-8), a fortune teller game with the BBC micro:bit
+* [Guess the Number](/lessons/guess-the-number),  guess a random number with pick number
+* [Counter](/lessons/counter), display a number with a variable
+* [Love Meter](/lessons/love-meter), create a love meter with on pin pressed
+* [Truth or Dare](/lessons/truth-or-dare), a game that forces each player to reveal a secret or do something funny with if statement
+* [Spinner](/lessons/spinner), spin the arrow with multiple if statements
+* [Dice Roll](/lessons/dice-roll), spin with more if statements
+* [Looper](/lessons/looper), display a series of numbers with a for loop index
+* [Strobe Light](/lessons/strobe-light), develop shapes with a nested for loops
+* [Temperature](/lessons/temperature), get the ambient temperature (degree Celsius °C)
+* [Digi Yoyo](/lessons/digi-yoyo), create a counter with a while loop
+* [Rotation Animation](/lessons/rotation-animation), control an animation with a boolean variable
+* [Compass](/lessons/compass), displays the direction the BBC micro:bit is pointing with compass
+* [Zoomer](/lessons/zoomer), measure the force with acceleration
+* [Glowing Pendulum](/lessons/glowing-pendulum), construct a pendulum that glows using acceleration
+* [Classic Beatbox](/lessons/classic-beatbox), make a beatbox music player with variables
 
 ### ~
 
 ### ~column 
 
 ## Maker
+* [Pogo](/lessons/pogo), create a pogo game to test your jumping abilities
 
-* [The Watch](/microbit/lessons/the-watch), design and create The Watch
-* [Hack your Headphones](/microbit/lessons/hack-your-headphones), create music on the BBC micro:bit by hacking your headphones
-* [Banana Keyboard](/microbit/lessons/banana-keyboard), create music with fruits
-* [Telegraph](/microbit/lessons/telegraph), play the telegraph game between two BBC micro:bits
-* [Ornament Chain](/microbit/lessons/ornament-chain), play the ornament chain game between two BBC micro:bits
+## Science
+* [Charting](/lessons/charting), measure and chart acceleration
+* [Seismograph](/lessons/seismograph), create a seismograph with household items
 
 ## Advanced
-
-* [Hero](/microbit/lessons/hero), reconstruct the classic arcade game pac man with the BBC micro:bit
-
+* [Prank WiFi](/lessons/prank-wifi), create fake WiFi to trick your friends
+* [Speed Button](/lessons/speed-button), code a speed game with running time
+* [Headbands](/lessons/headbands), create a charades game with a collection of strings that hold the words
+* [Hero](/lessons/hero), reconstruct the classic arcade game pac man with the BBC micro:bit
+* [Catch the Egg](/lessons/catch-the-egg-game), catch falling eggs in a basket with an acceleration controller
 ### ~
 
 ### @section full
-
-The lessons promote computational thinking and computer science literacy[ read more...](/microbit/lessons/teach)
-

docs/lessons/answering-machine.md

@@ -1,8 +1,6 @@
 # answering machine blocks lesson
 
-create an answering machine on the BBC micro:bit #docs
-
-### @video td/videos/answering-machine-0
+Create an answering machine on the BBC micro:bit
 
 ## Topic
 
@@ -10,14 +8,11 @@ Show String
 
 ## Quick Links
 
-* [activity](/microbit/lessons/answering-machine/activity)
-* [quiz](/microbit/lessons/answering-machine/quiz)
-* [quiz answers](/microbit/lessons/answering-machine/quiz-answers)
-* [challenges](/microbit/lessons/answering-machine/challenges)
+* [activity](/lessons/answering-machine/activity)
+* [quiz](/lessons/answering-machine/quiz)
+* [quiz answers](/lessons/answering-machine/quiz-answers)
+* [challenges](/lessons/answering-machine/challenges)
 
-## Class
-
-Year 7
 
 ## Prior learning / place of lesson in scheme of work
 
@@ -25,56 +20,13 @@ Learn how to creating a message with a **string**, `show string` to write your m
 
 ## Documentation
 
-* **show string** : [read more...](/microbit/reference/basic/show-string)
-* **on button pressed** : [read more...](/microbit/reference/input/on-button-pressed)
+```cards
+basic.showString('Hi!')
+input.onButtonPressed(Button.A, () => {})
+```
 
 ## Objectives
 
 * learn how to show a string on the LED screen one character at a time
 * learn how to use to register an event handler that will execute whenever an input button is pressed
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-*  Uses logical reasoning to predict  outputs, showing an awareness of inputs (AL)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-
-#### Hardware & Processing
-
-* Knows that computers collect data from various input devices, including sensors and application software (AB)
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-* Uses criteria to evaluate the quality of solutions, can identify improvements making some refinements to the solution, and future  solutions (EV)
-* Evaluates the appropriatness of digital devices, internet services and application software to achieve given goals (EV)
-* Recognises ethical issues surrounding the application of information technology beyond school.
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/answering-machine/activity)
-* [quiz](/microbit/lessons/answering-machine/quiz)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/answering-machine/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/answering-machine/challenges)
-

docs/lessons/answering-machine/activity.md

@@ -4,7 +4,6 @@ Learn to create an answering machine on the micro:bit
 
 ### ~avatar avatar
 
-### @video td/videos/answering-machine-0
 
 Let's learn how to create an answering machine!
 
@@ -18,7 +17,7 @@ basic.showString("ASK ME A QUESTION")
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/answering-machine/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/answering-machine/challenges)!
 
 ### ~
 

docs/lessons/answering-machine/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the answering machine tutorial.
 
 ## Before we get started
 
-Complete the [answering machine](/microbit/lessons/answering-machine/activity) activity and your code will look like this:
+Complete the [answering machine](/lessons/answering-machine/activity) activity and your code will look like this:
 
 ```blocks
 basic.showString("ASK ME A QUESTION")
@@ -12,8 +12,6 @@ basic.showString("ASK ME A QUESTION")
 
 ### Challenge 1
 
-### @video td/videos/answering-machine-1
-
 Now we need to reply after someone asks micro:bit a  yes or no question. We want to respond `YES` when button `A` is pressed. Add a condition for button `A` and inside it show the string `YES`.
 
 ```blocks
@@ -21,15 +19,12 @@ basic.showString("ASK ME A QUESTION")
 input.onButtonPressed(Button.A, () => {
     basic.showString("Yes")
 })
-
 ```
 
 * `Run` the code to see if it works as expected.
 
 ### Challenge 2
 
-### @video td/videos/answering-machine-2
-
 What if micro:bit's answer to the question is no? Let's have `NO` be displayed when button `B` is pressed. Add a condition for button `B` and inside it show the string `NO`.
 
 ```blocks
@@ -45,7 +40,6 @@ input.onButtonPressed(Button.B, () => {
 
 * `Run` the code to see if it works as expected.
 
-**Challenge 3**
-
-When you are asked a yes or no question, do you always say yes or no? Add a condition for `on shake` that displays `MAYBE`.
+### Challenge 3
 
+When you are asked a yes or no question, do you always say yes or no? Add a condition for `on shake` that displays `MAYBE`.

docs/lessons/answering-machine/quiz-answers.md

@@ -1,8 +1,8 @@
 # answering machine blocks quiz answers
 
-Create an answering machine on the micro:bit. #LED #screen #show #math #docs #input
+Create an answering machine on the micro:bit.
 
-This is the answer key for the [answering machine quiz](/microbit/lessons/answering-machine/quiz).
+This is the answer key for the [answering machine quiz](/lessons/answering-machine/quiz).
 
 ## 1. Define what `show string` does?
 
@@ -12,7 +12,6 @@ Answers may vary. This is a function that will show a string on the LED screen o
 
 ```blocks
 basic.showString("Y")
-
 ```
 
 ![](/static/mb/lessons/answering-machine-0.png)
@@ -22,7 +21,6 @@ basic.showString("Y")
 
 ```blocks
 basic.showString("Hi")
-
 ```
 
 ![](/static/mb/lessons/answering-machine-1.png)
@@ -32,5 +30,9 @@ basic.showString("Hi")
 
 ![](/static/mb/lessons/answering-machine-2.png)
 
-![](/static/mb/blocks/lessons/answering-machine-5.png)
+
+```blocks
+basic.showString("Z")
+```
+
 

docs/lessons/answering-machine/quiz.md

@@ -1,12 +1,12 @@
 # answering machine blocks quiz
 
-Create an answering machine on the micro:bit. #LED #screen #show #math #docs #input
+Create an answering machine on the micro:bit.
 
 ## Name
 
 ## Directions
 
-Use this activity document to guide your work in the [answering machine activity](/microbit/lessons/answering-machine/activity).
+Use this activity document to guide your work in the [answering machine activity](/lessons/answering-machine/activity).
 
 Answer the questions while completing the activity. Pay attention to the dialogues!
 

docs/lessons/banana-keyboard.md

@@ -1,25 +0,0 @@
-# banana keyboard blocks lesson
-
-display beautiful images on the BBC micro:bit #var #pause #docs
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/microbit/lessons/banana-keyboard/activity)
-
-## Class
-
-Year 7
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to convert your BBC micro:bit into a music player using pins P0 and GND, earphones (or speakers), as well as crocodile clips (or spring clips). The connect fruit using pins P1 and GND.
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with earphones to play music
-* learn how to setup the BBC micro:bit with fruit be the musical instrument
-

docs/lessons/beatbox.md

@@ -1,62 +0,0 @@
-# beatbox blocks lesson
-
-display beautiful images on the BBC micro:bit #var #pause #docs
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/microbit/lessons/beatbox/activity)
-* [challenges](/microbit/lessons/beatbox/challenges)
-
-## Class
-
-Year 7
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to make a beatbox music player using pins P1 and P2. We will be learning how to code musical notes using a local variable, for loop, on pin pressed as well as simple commands such as play and notes.
-
-## Objectives
-
-* learn how to code music on the BBC micro:bit
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-* Selects the appropriate data types(AL) (AB
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/beatbox/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/beatbox/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/beatbox/challenges)
-

docs/lessons/beautiful-image.md

@@ -1,8 +1,6 @@
 # beautiful image lesson
 
-display beautiful images on the BBC micro:bit #var #pause #docs
-
-### @video td/videos/beautiful-image-0
+Display beautiful images on the BBC micro:bit.
 
 ## Topic
 
@@ -10,12 +8,9 @@ Show LEDs
 
 ## Quick Links
 
-* [activity](/microbit/lessons/beautiful-image/activity)
-* [challenges](/microbit/lessons/beautiful-image/challenges)
+* [activity](/lessons/beautiful-image/activity)
+* [challenges](/lessons/beautiful-image/challenges)
 
-## Class
-
-Year 7
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -23,50 +18,19 @@ Learn how to **show LEDs**,  to show an image on the BBC micro:bit's LED screen.
 
 ## Documentation
 
-* **show LEDs** : [read more...](/microbit/reference/basic/show-leds)
-* **pause** : [read more...](/microbit/reference/basic/pause)
+```cards
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+basic.pause(100)
+```
 
 ## Objectives
 
 * learn how to display an image on the micro:bit's LED screen
 * learn how to pause your code for the specified number of milliseconds
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-* Represents solutions using a structured notation (AL) (AB)
-*  Can identify similarities and differences in situations and can use these to solve problems (pattern recognition)(GE)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-*  Declares and assigns variables(AB)
-* Selects the appropriate data types(AL) (AB
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/beautiful-image/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/beautiful-image/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/beautiful-image/challenges)
-

docs/lessons/beautiful-image/activity.md

@@ -1,17 +1,13 @@
 # beautiful image blocks activity
 
-Generate and show a beautiful image. #docs #microbit
+Generate and show a beautiful image.
 
 ### ~avatar avatar
 
-### @video td/videos/beautiful-image-0
-
 Let's learn how to show an image on the LED screen.
 
 ### ~
 
-To create a new script, go to the [Create Code](/microbit/create-code) page and tap *New Project* under the *Block Editor*.
-
 We will use *show LEDs* to draw an image on the LED screen. This function immediately writes on the screen.
 
 ```blocks
@@ -26,7 +22,7 @@ basic.showLeds(`
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/beautiful-image/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/beautiful-image/challenges)!
 
 ### ~
 

docs/lessons/beautiful-image/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the beautiful image tutorial.
 
 ## Before we get started
 
-Complete the [beautiful image](/microbit/lessons/beautiful-image/activity) activity and your code will look like this:
+Complete the [beautiful image](/lessons/beautiful-image/activity) activity and your code will look like this:
 
 ```blocks
 basic.showLeds(`
@@ -18,8 +18,6 @@ basic.showLeds(`
 
 ### Challenge 1
 
-### @video td/videos/beautiful-image-1-2
-
 Now show an new image that will display on the micro:bit.
 
 ```blocks
@@ -39,9 +37,9 @@ basic.showLeds(`
     `)
 ```
 
-* *Run* your code to see if it works as expected.
+* Does your code work as expected?
 
 ### Challenge 2
 
-Nice job! Why don't we create a third image that will show after the other two? Remember to add a pause before you create and show the image.
+Nice job! Why don't we create a third image that will show after the other two?
 

docs/lessons/beautiful-image/tutorial.md

@@ -0,0 +1,48 @@
+# beautiful image blocks challenges
+
+Beautiful Image tutorial. 
+
+### ~avatar avatar
+
+### @video td/videos/beautiful-image-0
+
+Rebuild the game!
+
+The blocks have been shuffled! Put them back together so that…
+
+* display images on the screen with show LEDs
+
+
+```shuffle
+basic.showLeds(`
+    # # # # #
+    # # . # #
+    # . # . #
+    # # . # #
+    # # # # #
+    `)
+basic.showLeds(`
+    # . # . #
+    . # # # .
+    . . # . .
+    . # # # .
+    # . # . #
+    `)
+basic.pause(100)
+```
+
+Hints and tips
+
+Cut out these documentation cards to help you!
+
+```cards
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+basic.pause(100)
+
+```

docs/lessons/blink.md

@@ -1,8 +1,6 @@
 # blink blocks lesson
 
-Learn how to create a blinking LED. #LED #screen  #plot #docs #lesson
-
-### @video td/videos/blink-0
+Learn how to create a blinking LED.
 
 ## Topic
 
@@ -10,41 +8,25 @@ Plot
 
 ## Quick links
 
-* [activity](/microbit/lessons/blink/activity)
-* [quiz](/microbit/lessons/blink/quiz)
-* [quiz answers](/microbit/lessons/blink/quiz-answers)
-* [challenges](/microbit/lessons/blink/challenges)
+* [activity](/lessons/blink/activity)
+* [quiz](/lessons/blink/quiz)
+* [quiz answers](/lessons/blink/quiz-answers)
+* [challenges](/lessons/blink/challenges)
 
-## Class
-
-Year 7
 
 ## Prior learning / place of lesson in scheme of work 
 
 Learn how to control a blinking LED. We will be learning how to create a blinking app using forever as well as simple commands, such as plot, unplot and pause.
 
-## What the teacher needs to know / QuickStart Computing Glossary
-
-**Program:** A stored set of instructions encoded in a language understood by the computer that does some form of computation, processing input and/or stored data to generate output.
-
-**Algorithm:** An unambiguous set of rules or a precise step-by-step guide to solve a problem or achieve a particular objective. The guided tutorial follows a algorithm and is a precise step-by-step guide to solve a problem
-
-**Loop:** A block of code repeated automatically under the program’s control. The blink program introduces Forever. The forever loop repeats code in the background forever.
-
-**Command:** An instruction for the computer to execute, written in a particular programming language.
 
 ## Documentation
 
-* **plot**: [read more...](/microbit/reference/led/plot)
-* **unplot**: [read more...](/microbit/reference/led/unplot)
-* **pause**: [read more...](/microbit/reference/basic/pause)
-* **forever**: [read more...](/microbit/reference/basic/forever)
-
-## Resources
-
-* Activity: [activity](/microbit/lessons/blink/activity)
-* Activity: [quiz](/microbit/lessons/blink/quiz)
-* Extended Activity: [challenges](/microbit/lessons/blink/challenges)
+```cards
+led.plot(0, 0)
+led.unplot(0, 0)
+basic.pause(100)
+basic.forever(() => {})
+```
 
 ## Objectives
 
@@ -52,41 +34,3 @@ Learn how to control a blinking LED. We will be learning how to create a blinkin
 * learn how to turn off LED lights on the LED screen
 * learn how to pause program execution for the specified number of milliseconds
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Understands that iteration is the repetition of a process such as a loop. (AL)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals. (AL)
-
-#### Data & Data Representation
-
-* Understands the difference between data and information. (AB)
-* Defines data types: real numbers and Boolean. (AB)
-
-#### Information Technology
-
-*  Collects, organises and presents data and information in digital content. (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution. (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/blink/activity)
-* [quiz](/microbit/lessons/blink/quiz)
-* [quiz answers](/microbit/lessons/blink/quiz-answers)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/blink/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/blink/challenges)
-

docs/lessons/blink/activity.md

@@ -4,9 +4,15 @@ Turn an LED on and off with forever
 
 ### ~avatar avatar
 
-### @video td/videos/blink-0
-
-To create a new script, go to the [Create Code](/microbit/create-code) page and tap *New Project* under *Block Editor*.
+```sim
+basic.forever(() => {
+    led.plot(2, 2)
+    basic.pause(500)
+    led.unplot(2, 2)
+    basic.pause(500)
+})
+```
+Let's build a blinking light!
 
 ### ~
 
@@ -45,12 +51,11 @@ basic.forever(() => {
     led.unplot(2, 2)
     basic.pause(500)
 })
-
 ```
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/blink/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/blink/challenges)!
 
 ### ~
 

docs/lessons/blink/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the blink tutorial
 
 ## Before we get started
 
-Complete the [blink](/microbit/lessons/blink/activity) activity and your code will look like this:
+Complete the [blink](/lessons/blink/activity) activity and your code will look like this:
 
 ```blocks
 basic.forever(() => {
@@ -17,8 +17,6 @@ basic.forever(() => {
 
 ### Challenge 1
 
-### @video td/videos/blink-1
-
 Let's display a "smiley face" on the screen! We'll start by plotting the eyes.
 
 Add `plot(1,1)` and `plot(3,1)` under `plot(2,2)` ; then add `unplot(1,1)`, `unplot(3,1)` and `unplot(2,2)` after `pause`. When you're ready, don't forget to run your code to try it out!
@@ -38,8 +36,6 @@ basic.forever(() => {
 
 ### Challenge 2
 
-### @video td/videos/blink-2
-
 Let's add the code to plot the mouth by using `plot` and `unplot` to the following coordinates: (1,4), (2,4) and (3,4). When you're ready, don't forget to run your code to try it out!
 
 ```blocks
@@ -63,8 +59,6 @@ basic.forever(() => {
 
 ### Challenge 3
 
-### @video td/videos/blink-3
-
 Let's keep using `plot` to convert the mouth into a smiley face.
 
 ```` bitmatrix

docs/lessons/blink/quiz-answers.md

@@ -1,8 +1,8 @@
 # blink blocks quiz answers
 
-Learn how to create a blinking LED script. #LED #screen  #plot #docs
+Learn how to create a blinking LED script.
 
-This is the answer key for the [blink quiz](/microbit/lessons/blink/quiz).
+This is the answer key for the [blink quiz](/lessons/blink/quiz).
 
 ## 1. Describe what `plot` does?
 
@@ -10,7 +10,10 @@ Answers will vary. In general, plot refers to the code that turns on a specific
 
 ## 2. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-6.png)
+```blocks
+led.plot(2, 2)
+
+```
 
 ![](/static/mb/lessons/blink-0.png)
 
@@ -18,7 +21,10 @@ By default, the position of an LED on *Blink Tutorial* is set to the centre of t
 
 ## 3. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-7.png)
+```blocks
+led.plot(0, 0)
+
+```
 
 ![](/static/mb/lessons/blink-1.png)
 
@@ -29,7 +35,10 @@ This code turns on specific LED. Plot turns on the specified LED on the LED scre
 
 ## 4. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-8.png)
+```blocks
+led.plot(4, 4)
+
+```
 
 ![](/static/mb/lessons/blink-2.png)
 

docs/lessons/blink/quiz.md

@@ -1,34 +1,45 @@
 # blink blocks quiz
 
-Learn how to create a blinking LED script. #LED #screen  #plot #docs
+Learn how to create a blinking LED script.
 
 ## Name
 
 ## Directions
 
-Use this activity document to guide your work in the [blink activity](/microbit/lessons/blink/activity).
+Use this activity document to guide your work in the [blink activity](/lessons/blink/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
 ## 1. Describe what `plot` does?
 
-<br/>
+
 
 ## 2. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-6.png)
+```blocks
+led.plot(2, 2)
+
+```
 
 ![](/static/mb/empty-microbit.png)
 
 ## 3. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-7.png)
+```blocks
+led.plot(0, 0)
+
+```
 
 ![](/static/mb/empty-microbit.png)
 
 ## 4. Draw which LED is ON after running this code
 
-![](/static/mb/blocks/lessons/blink-8.png)
+
+```blocks
+led.plot(4, 4)
+
+```
+
 
 ![](/static/mb/empty-microbit.png)
 

docs/lessons/blocks-conditions.md

@@ -1,6 +1,6 @@
 # blocks - if statements
 
-An introduction to conditions for the Block Editor. #docs
+An introduction to conditions for the Block Editor.
 
 ## Introduction to conditions
 

docs/lessons/bop-it/activity.md

@@ -1,18 +1,14 @@
 # bop it challenges
 
-a game similar to "Simon Says" with the BBC micro:bit. #docs
+a game similar to "Simon Says" with the BBC micro:bit.
 
 ## Before we get started
 
-Complete the following guided tutorial:
+Complete the following guided tutorial. Your code should look like this:
 
-* [tutorial](/microbit/lessons/bop-it/tutorial)
-
-At the end of the tutorial, click `keep editing`. Your code should look like this:
-
-```
+```blocks
 newAction() // ***
-input.onButtonPressed("A", () => {
+input.onButtonPressed(Button.A, () => {
     if (action == 0) {
         game.addScore(1) // ***
         newAction() // ***
@@ -21,27 +17,27 @@ input.onButtonPressed("A", () => {
 input.onLogoDown(() => {
     if (action == 1) {
         game.addScore(1) // ***
-        newAction() // ***
+        newAction() 
     }
-}) // ***
+}) 
 input.onGesture(Gesture.Shake, () => {
     if (action == 2) {
-        game.addScore(1) // ***
-        newAction() // ***
+        game.addScore(1)
+        newAction()
     }
-}) // ***
-input.onButtonPressed("B", () => {
+}) 
+input.onButtonPressed(Button.B, () => {
     basic.showNumber(game.score(), 150) // ***
     basic.pause(2000) // ***
     newAction() // ***
-}) // ***
+}) 
 ```
 
 ### Challenge 1
 
 Now let's add some more types of instructions for the player to follow. Let's add `PRESS PIN 0`. Change the global variable `action` to `math->random(4)` so that we can add a new **IF** statement that checks if `action=3`. If it does, display instructions to press pin 0.
 
-```
+```blocks
 /**
  * {highlight}
  */
@@ -68,12 +64,12 @@ Now let's implement `PRESS PIN 0` in the main. Create a condition of `input->on
 
 ```
 // **. . .**
-input.onButtonPressed("B", () => {
+input.onButtonPressed(Button.B, () => {
     basic.showNumber(game.score(), 150) // ***
     basic.pause(2000) // ***
     newAction() // ***
 }) // ***
-input.onPinPressed("P0", () => {
+input.onPinPressed(TouchPin.P0, () => {
     if (action == 3) {
         game.addScore(1) // ***
         newAction() // ***

docs/lessons/bop-it/quiz-answers.md

@@ -1,28 +1,25 @@
 # bop it quiz answers
 
-a game where you have to keep up with the commands #math #random #docs
+a game where you have to keep up with the commands.
 
 ## Name
 
 ## Directions
 
-Use this activity document to guide your work in the [bop it tutorial](/microbit/lessons/bop-it/tutorial).
+Use this activity document to guide your work in the [bop it activity](/lessons/bop-it/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
 ## 1. Write the code that will store the global variable named 'action' and returns a random number between 0 and 2
 
-<br/>
-
-```
-action = Math.random(3)
+```blocks
+let action = Math.random(3)
 ```
 
 ## 2. Write the code that will display the string, "PUSH A" if the global variable called 'action' is equal to 0
 
-<br />
-
-```
+```blocks
+let action = Math.random(3)
 if (action == 0) {
     basic.showString("PUSH A", 150)
 }
@@ -30,10 +27,9 @@ if (action == 0) {
 
 ## 3. Write the code that increments the score if button A is pressed when the global variable called 'action' is equal to 1
 
-<br />
-
-```
-input.onButtonPressed("A", () => {
+```blocks
+input.onButtonPressed(Button.A, () => {
+    let action = Math.random(3)
     if (action == 0) {
         game.addScore(1)
     }
@@ -42,9 +38,8 @@ input.onButtonPressed("A", () => {
 
 ## 4. Write the code that will display the string "LOGO DOWN" if the global variable called 'action' is equal to 1
 
-<br />
-
-```
+```blocks
+let action = Math.random(3)
 if (action == 1) {
     basic.showString("LOGO DOWN", 150)
 }
@@ -52,10 +47,9 @@ if (action == 1) {
 
 ## 5. Write the code that increments the score if the BBC micro:bit logo is tilted down when the global variable called 'action' is equal to 1
 
-<br />
-
-```
+```blocks
 input.onLogoDown(() => {
+    let action = Math.random(3)
     if (action == 1) {
         game.addScore(1)
     }
@@ -64,9 +58,8 @@ input.onLogoDown(() => {
 
 ## 6. Write the code that will display the string "SHAKE" if the global variable called 'action' is equal to 2
 
-<br />
-
-```
+```blocks
+let action = Math.random(3)
 if (action == 2) {
     basic.showString("SHAKE", 150)
 }
@@ -74,13 +67,11 @@ if (action == 2) {
 
 ## 7. Write the code that increments the score if the BBC micro:bit is shaken when the global variable called 'action' is equal to 2
 
-<br/>
-
-```
+```blocks
 input.onLogoDown(() => {
+    let action = Math.random(3)
     if (action == 1) {
         game.addScore(1)
     }
 })
 ```
-

docs/lessons/bop-it/quiz.md

@@ -0,0 +1,38 @@
+# bop it quiz 
+
+a game where you have to keep up with the commands.
+
+## Name
+
+## Directions
+
+Use this activity document to guide your work in the [bop it activity](/lessons/bop-it/activity).
+
+Answer the questions while completing the tutorial. Pay attention to the dialogues!
+
+### 1. Write the code that will store the global variable named 'action' and returns a random number between 0 and 2
+
+<br/>
+
+### 2. Write the code that will display the string, "PUSH A" if the global variable called 'action' is equal to 0
+
+<br />
+
+### 3. Write the code that increments the score if button A is pressed when the global variable called 'action' is equal to 1
+
+<br />
+
+### 4. Write the code that will display the string "LOGO DOWN" if the global variable called 'action' is equal to 1
+
+<br />
+
+### 5. Write the code that increments the score if the BBC micro:bit logo is tilted down when the global variable called 'action' is equal to 1
+
+<br />
+
+### 6. Write the code that will display the string "SHAKE" if the global variable called 'action' is equal to 2
+
+<br />
+
+### 7. Write the code that increments the score if the BBC micro:bit is shaken when the global variable called 'action' is equal to 2
+

docs/lessons/buzzer.md

@@ -1,81 +0,0 @@
-# buzzer lesson 
-
-design a blinking image lesson #docs
-
-## Topic 
-
-Ring
-
-## Quick Links
-
-* [activity](/microbit/lessons/buzzer/activity)
-* [challenges](/microbit/lessons/buzzer/challenges)
-
-## Class
-
-Year 7
-
-## Prior learning / place of lesson in scheme of work
-
-Learn how to **ring** the buzzer to turn on the sound. We will be learning basic comments such as ring and clear screen.
-
-## Documentation
-
-* **ring** : [read more...](/microbit/reference/music/ring)
-* **clear screen** : [read more...](/microbit/reference/basic/clear-screen)
-* **on button pressed** : [read more...](/microbit/reference/input/on-button-pressed)
-
-## Objectives
-
-* learn how to ring the BBC micro:bit
-* learn how to clear the screen
-* learn how to run code when an input button is pressed
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Designs solutions (algorithms) that use repetition and two-way  selection, ie if, then and else.(AL)
-* Uses diagrams to express solutions.(AB)
-*  Uses logical reasoning to predict  outputs, showing an awareness of inputs (AL)
-* Recognises that different algorithms exist for the same problem (AL) (GE)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Understands the difference between data and information(AB)
-
-#### Hardware & Processing
-
-* Understands the difference between hardware and application software, and their roles within a computer system (AB)
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/buzzer/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/buzzer/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/buzzer/challenges)
-

docs/lessons/catch-the-egg-game.md

@@ -0,0 +1,51 @@
+# catch the egg game lesson
+
+A game to catch eggs in a basket.
+
+## Topic
+
+Variables
+
+## Quick Links
+
+* [activity](/lessons/catch-the-egg-game/activity)
+* [tutorial](/lessons/catch-the-egg-game/tutorial)
+* [quiz](/lessons/catch-the-egg-game/quiz)
+* [quiz answers](/lessons/catch-the-egg-game/quiz-answers)
+
+## Prior learning/place of lesson in scheme of work
+
+Learn how to create a catch the egg game game with **plot**, `led->plot` , **unplot**, `led->unplot`, and **acceleration**  `input -> acceleration` to turn on and off LED lights on the LED screen. We will be learning how to create a catch the egg game app using global variables, forever loop, local variable, input acceleration, math min, math max, math random, math mod, if (conditionals), game library as well as simple commands, such as led plot, led unplot, and pause.
+
+## Documentation
+
+```cards
+let x = 2;
+led.unplot(0, 0);
+basic.forever(() => {});
+x += 1;
+led.plot(0, 0);
+basic.pause(300);
+input.acceleration(Dimension.X);
+Math.min(0,0);
+Math.max(0,1);
+Math.random(5);
+game.addScore(1);
+game.score();
+game.removeLife(1);
+```
+
+## Objectives
+
+* learn how to create a variable as a place where you can store data so that you can use it later in your code, accessible across functions and in nested code blocks
+* learn how to repeat code in the background forever
+* learn how to turn off a LED light on the LED screen
+* learn how to turn on a LED light on the LED screen
+* learn how to learn how to conditionally run code depending on whether a condition is true or not
+* learn how to learn how to get the acceleration value (g-force), in one of three specified dimensions
+* learn how to return the smaller of two numbers
+* learn how to return the larger of two numbers
+* learn how to return a random number
+* learn how to return the modulus
+* learn how to show a number of the BBC micro:bit screen
+* learn how to pause your code for the specified number of milliseconds

docs/lessons/catch-the-egg-game/activity.md

@@ -1,16 +1,10 @@
 # catch the egg game challenges
 
-Coding challenges for catch the egg game.
-
 ## Before we get started
 
-Complete the following guided tutorial:
+Your starting code should look like this:
 
-* [tutorial](/microbit/lessons/catch-the-egg-game/tutorial)
-
-At the end of the tutorial, click `keep editing`. Your code should look like this:
-
-```
+```blocks
 let basketX = 2
 let eggX = 2
 let eggY = 0
@@ -20,7 +14,7 @@ basic.forever(() => {
     eggY = eggY + 1
     led.plot(eggX, eggY)
     basic.pause(300)
-    let accX = input.acceleration("x")
+    let accX = input.acceleration(Dimension.X)
     basketX = 2 + Math.min(2, Math.max(-2, accX / 200))
     led.plot(basketX, 4)
     if (eggY > 4) {
@@ -35,21 +29,13 @@ basic.forever(() => {
 
 ### Challenge 1
 
-Let's start by adding the **game** library.
-
-### ~
-
-### ~avatar avatar improvised
-
-### Challenge 2
-
 Let's use an **IF** statement to detect if the egg and the basket are lined up.
 
 Now that we know when an egg is caught, we can keep track of the score! We need to use the `add score` function built into the game library to add `1` point for every egg that is caught. However, let's not forget to `remove life` if an egg falls off the display before it's caught!
 
 ### ~
 
-```
+```blocks
 let basketX1 = 2
 let eggX1 = 2
 let eggY1 = 0
@@ -59,8 +45,8 @@ basic.forever(() => {
     eggY1 = eggY1 + 1
     led.plot(eggX1, eggY1)
     basic.pause(300)
-    let accX1 = input.acceleration("x")
-    basketX1 = 2 + Math.min(2, Math.max(-2, accX1 / 200))
+    let accX = input.acceleration(Dimension.X)
+    basketX1 = 2 + Math.min(2, Math.max(-2, accX / 200))
     led.plot(basketX1, 4)
     if (eggY1 > 4) {
         eggY1 = -1
@@ -68,9 +54,9 @@ basic.forever(() => {
     }
     if (eggY1 == 4) {
         if (basketX1 == eggX1) {
-            game.addScore(1) // ***
+            game.addScore(1) 
         } else {
-            game.removeLife(1) // ***
+            game.removeLife(1)
         }
     }
     basic.pause(300)
@@ -81,13 +67,13 @@ basic.forever(() => {
 
 ### ~avatar avatar encourage
 
-### Challenge 3
+### Challenge 2
 
 Catching eggs gets easier with practice so let's make the eggs fall faster every 5 catches. We can do this by tracking how long the egg pauses in each position while falling with a global variable called **falling pause**. Let's create this variable and set it to `300` initially. Don't forget to also create a condition that will be true every 5 catches.
 
 ### ~
 
-```
+```blocks
 let basketX2 = 2
 let eggX2 = 2
 let eggY2 = 0
@@ -98,7 +84,7 @@ basic.forever(() => {
     eggY2 = eggY2 + 1
     led.plot(eggX2, eggY2)
     basic.pause(300)
-    let accX2 = input.acceleration("x")
+    let accX2 = input.acceleration(Dimension.X)
     basketX2 = 2 + Math.min(2, Math.max(-2, accX2 / 200))
     led.plot(basketX2, 4)
     if (eggY2 > 4) {
@@ -108,7 +94,7 @@ basic.forever(() => {
     if (eggY2 == 4) {
         if (basketX2 == eggX2) {
             game.addScore(1)
-            if (math.mod(game.score(), 5) == 0) {
+            if (game.score() %5 == 0) {
             }
         } else {
             game.removeLife(1)
@@ -120,13 +106,11 @@ basic.forever(() => {
 
 ### ~avatar avatar surprised
 
-### Challenge 4
-
-### @video td/videos/catch-the-egg-game-4
+### Challenge 3
 
 Let's make the egg fall faster by decreasing the amount of time it pauses in each position by decreasing **falling pause** by `25` every 5 catches. Now, instead of pausing for 300 milliseconds we can pause for the value of **falling pause**.
 
-```
+```blocks
 let basketX3 = 2
 let eggX3 = 2
 let eggY3 = 0
@@ -137,7 +121,7 @@ basic.forever(() => {
     eggY3 = eggY3 + 1
     led.plot(eggX3, eggY3)
     basic.pause(300)
-    let accX3 = input.acceleration("x")
+    let accX3 = input.acceleration(Dimension.X)
     basketX3 = 2 + Math.min(2, Math.max(-2, accX3 / 200))
     led.plot(basketX3, 4)
     if (eggY3 > 4) {
@@ -147,15 +131,16 @@ basic.forever(() => {
     if (eggY3 == 4) {
         if (basketX3 == eggX3) {
             game.addScore(1)
-            if (math.mod(game.score(), 5) == 0) {
+            if (game.score()% 5 == 0) {
                 fallingPause1 = fallingPause1 - 25 // ***
             }
         } else {
             game.removeLife(1)
         }
     }
-    basic.pause(fallingPause1) // ***
+    basic.pause(fallingPause1) 
 })
+
 ```
 
 Fantastic! Your game is now ready to show off.

docs/lessons/catch-the-egg-game/quiz-answers.md

@@ -6,7 +6,7 @@ Programming a game of catch the egg using the accelerometer
 
 ## Directions
 
-Use this activity document to guide your work in the [catch the egg tutorial](/microbit/lessons/catch-the-egg-game/tutorial)
+Use this activity document to guide your work in the [catch the egg activity](/lessons/catch-the-egg-game/activity)
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
@@ -22,7 +22,10 @@ Answer the questions while completing the tutorial. Pay attention to the dialogu
 
 <br/>
 
-```
+```blocks
+let basketX = 2
+let eggX = 2
+let eggY = 0
 led.plot(eggX, eggY)
 led.plot(basketX, 4)
 ```
@@ -31,28 +34,22 @@ led.plot(basketX, 4)
 
 <br/>
 
-```
+```blocks
+let basketX = 2
+let eggX = 2
+let eggY = 0
 led.unplot(eggX, eggY)
 eggY = eggY + 1
 led.plot(eggX, eggY)
 ```
 
-## 4. Write the code that calculates 'basket x' given the variable 'acc x'.
+## 4. . Write the code that resets the egg after it has fallen past the bottom of the BBC micro:bit.
 
 <br/>
 
-```
-let accX = input.acceleration("x")
-basketX = 2 + Math.min(2, Math.max(-2, accX / 200))
-```
-
-Note: the first line of code in this answer is optional.
-
-## 5. Write the code that resets the egg after it has fallen past the bottom of the BBC micro:bit.
-
-<br/>
-
-```
+```blocks
+let eggX = 2
+let eggY = 0
 if (eggY > 4) {
     eggY = -1
     eggX = Math.random(5)

docs/lessons/catch-the-egg-game/quiz.md

@@ -6,11 +6,11 @@ Programming a game of catch the egg using the accelerometer.
 
 ## Directions
 
-Use this activity document to guide your work in the [catch the egg tutorial](/microbit/lessons/catch-the-egg-game/tutorial)
+Use this activity document to guide your work in the [catch the egg challenges](/lessons/catch-the-egg-game/activity)
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
-## 1. Write the data type for the global variables 'basket' and 'egg'.
+## 1. Write the data type for the variables 'basket' and 'egg'.
 
 <br/>
 
@@ -24,11 +24,7 @@ Answer the questions while completing the tutorial. Pay attention to the dialogu
 
 <br/>
 
-## 4. Write the code that calculates 'basket x' given the variable 'acc x'.
-
-<br/>
-
-## 5. Write the code that resets the egg after it has fallen past the bottom of the BBC micro:bit.
+## 4. Write the code that resets the egg after it has fallen past the bottom of the BBC micro:bit.
 
 <br/>
 

docs/lessons/catch-the-egg-game/tutorial.md

@@ -0,0 +1,29 @@
+# catch the egg game tutorial
+
+### Rebuild the game!
+
+The blocks have been shuffled! Put them back together so that...
+* an egg LED  falls from the top of the screen, row by row.
+* a basket LED is on the bottom row and can be moved by using the accelerometer `X` data.
+* if the egg LED reaches the last row, reset the egg position to the first row.
+
+```shuffle
+let basketX = 2
+let eggX = 2
+let eggY = 0
+basic.forever(() => {
+    led.unplot(basketX, 4)
+    led.unplot(eggX, eggY)
+    eggY = eggY + 1
+    led.plot(eggX, eggY)
+    basic.pause(300)
+    let accX = input.acceleration(Dimension.X)
+    basketX = 2 + Math.min(2, Math.max(-2, accX / 200))
+    led.plot(basketX, 4)
+    if (eggY > 4) {
+        eggY = -1
+        eggX = Math.random(5)
+    }
+    basic.pause(300)
+})
+```

docs/lessons/challenges.md

@@ -1,6 +1,6 @@
 # blocks - challenges
 
-Extra stuff for the Block Editor - an introduction to GPIO #docs
+Extra stuff for the Block Editor - an introduction to GPIO
 
 ## Before we get started
 
@@ -22,7 +22,7 @@ Create a timer that runs out after a certain amount of time (using the *count* l
 
 ## Graphics Challenges [3]
 
-Using the knowledge you have learnt from the [rendering graphics](/microbit/lessons/graphics) section, try creating an algorithm to draw these shapes. Before you write the code try to figure out how the BBC micro:bit will be thinking to plot these points. For example, with our diagonal line – “count up from 0 to 4 by 1, and plot points x=i and y=i”.
+Using the knowledge you have learnt from the [rendering graphics](/lessons/graphics) section, try creating an algorithm to draw these shapes. Before you write the code try to figure out how the BBC micro:bit will be thinking to plot these points. For example, with our diagonal line – “count up from 0 to 4 by 1, and plot points x=i and y=i”.
 
 * Another diagonal line
 * A square going around the board

docs/lessons/charting.md

@@ -1,18 +1,16 @@
 # charting lesson
 
-measure the acceleration on the micro:bit in the "z" direction #acceleration #var #docs #if #show
+Create a charting app for simulating and measuring the acceleration applied to the micro:bit
 
 ## Topic
 
 Acceleration
 
 ## Quick Links
-
-* [activity](/microbit/lessons/charting/activity)
-
-## Class
-
-Year 7
+* [activity](/lessons/charting/activity) 
+* [challenge](/lessons/charting/challenge) 
+* [quiz](/lessons/charting/quiz) 
+* [answers](/lessons/charting/quiz-answers)
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -20,12 +18,14 @@ Learn the functions of **on data received**, **send number** and **receive numbe
 
 ## Documentation
 
-* **forever** : [read more...](/microbit/reference/basic/forever)
-* **acceleration** : [read more...](/microbit/reference/input/acceleration)
-* **plot bar graph** : [read more...](/microbit/reference/led/plot-bar-graph)
-* **on data received** : [read more...](/microbit/reference/radio/on-data-received)
-* **send number** : [read more...](/microbit/reference/radio/send-number)
-* **receive number** : [read more...](/microbit/reference/radio/receive-number)
+```cards
+input.acceleration(Dimension.X)
+led.plotBarGraph(0, 1023)
+basic.showNumber(0)
+radio.onDataReceived(() => {})
+radio.sendNumber(0)
+radio.receiveNumber()
+```
 
 ## Objectives
 
@@ -35,24 +35,3 @@ Learn the functions of **on data received**, **send number** and **receive numbe
 * learn how to register code to run when a packet is received over radio
 * learn how to broadcast a number data packet to other micro:bits connected via radio
 * learn how to read the next radio packet as a number data packet
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-*  Uses logical reasoning to predict  outputs, showing an awareness of inputs (AL)
-* Represents solutions using a structured notation (AL) (AB)
-*  Can identify similarities and differences in situations and can use these to solve problems (pattern recognition)(GE)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-* Uses a variable and relational operators within a loop to govern termination (AL) (GE)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/charting/activity)
-

docs/lessons/charting/activity.md

@@ -1,53 +1,68 @@
-# charting activity
+# Activity 
 
-Measure the acceleration on the micro:bit in the "z" direction. 
+Measure the acceleration on the micro:bit in the "x" direction. 
 
 ### ~avatar avatar
 
-To create a new script, go to the [Create Code](/microbit/create-code) page and tap `New Project` under `Block Editor`.
+Welcome! This activity will teach how to use the micro:bit to chart the acceleration in the "x" direction. Let's get started!
+
+
+### ~
+Let's measure `acceleration (mg)` in the "x" direction. Get the acceleration value (milli g-force), in one of three specified dimensions.
+
+
+```blocks
+input.acceleration(Dimension.X)
+```
+
+### ~
+Use the plot bar chart to visualize the acceleration on the LED screen of the micro:bit in the specified range. You implement plot Bar Graph to display a vertical bar graph based on the "value" and "high" value. Then you must insert acceleration in the X dimension to measure the acceleration. 
+
+```blocks
+basic.forever(() => {
+    led.plotBarGraph(input.acceleration(Dimension.X), 0)
+})
+
+```
+
+### ~
+Notice that moving the micro:bit in the simulator from left to right (x direction) changes the values beneath the micro:bit in a range from 1023 to -1023 as measured in milli-gravities. By hovering over the micro:bit from left to right, you can observe changing values beneath the micro:bit simulator. Also, the LEDs shown on the Bar Graph fluctates based on the movement of the micro:bit simulator in the x direction. The line underneath the micro:bit simulator reflect the acceleration in the x direction. 
+
+NOTE: The colors of the charts reflect the color of the micro:bit simulator. In this instance, the micro:bit is yellow. So the color of the data line reflects the color of the micro:bit
+
+![](/static/mb/data4.png)
+
+### ~
+ 
+Vigorously move the micro:bit in the micro:bit simulatator by moving the micro:bit image from side to side. Every time the micro:bit moves in the x direction in the simulator,  you are generating data points that can be reviewed in Excel. The more attempts to move the micro:bit from side to side, the more data being saved in Excel. After you have vigarously moved the micro:bit simulator from side to side for a sufficient amount of time, you are ready to graph or chart the accceleration of the micro:bit. We want a printout of our acceleration on Excel that can be graphed in Excel. 
 
 ### ~
 
-Welcome! This activity will teach how to use the 1st micro:bit to chart the second micro:bit's acceleration in the "x" direction. Let's get started!
+We want to chart the data collected by using a tool in Excel. 
 
-Let's measure `acceleration (mg)` and then `send number`. `Acceleration` is measured in **milli-gravities**, so a value of -1000 is equivalent to -1g or -9.81m/s^2. We will be able to get the acceleration value (g-force), in the specified "x" dimension. `Send number` will broadcast a number data packet to other micro:bits connected via radio.
-
-```blocks
-radio.sendNumber(input.acceleration(Dimension.X))
-```
-
-We want to display the acceleration forever. In order to do so, we need a `forever` loop. A forever loop will repeat code in the background forever.
-
-```blocks
-basic.forever(() => {
-    radio.sendNumber(input.acceleration(Dimension.X))
-})
-```
-
-We want to register code to run when a packet is received over radio. We can implement this code by adding `on data received`.
-
-```blocks
-basic.forever(() => {
-    radio.sendNumber(input.acceleration(Dimension.X))
-})
-radio.onDataReceived(() => {
-    
-})
-```
-
-Finally, we want to chart the acceleration. So we must first implement `plot bar graph`. `Plot Bar Graph` will display a vertical bar graph based on the value and high value. In order to transfer the receive the number from the 1st micro:bit, we must implement `receive number` to constantly display a vertical bar graph based on the value. Remember, the value will equal to the micro:bit's acceleration in the "x" direction.
-
-```blocks
-basic.forever(() => {
-    radio.sendNumber(input.acceleration(Dimension.X))
-})
-radio.onDataReceived(() => {
-    led.plotBarGraph(radio.receiveNumber(), 1023)
-})
-
-```
+The final part of this experiment is opening and reviewing the data in the Excel CSV file. Simply click on the line beneath the simulator. A CSV file will be generated to display the data points collected by moving the micro:bit in the X direction. Then click or tap on the data Excel file that was downloaded to your local ``Downloads`` Folder. 
 
 
-* Connect the first micro:bit to your computer using your USB cable and run the charting script on it.
-* Connect the second micro:bit to your computer using your USB cable and run the charting script on it.
-* The first person and second person take turns tilting the micro:bit in the "x" direction while the other player charts the data on the micro:bit!
+### ~
+
+
+First, click or tap on the first two columns (A, B) to  include the time of the data being collected; b) the results of acceleration data on the micro:bit  
+
+![](/static/mb/data7.png)
+
+Use the Recommended Charts command on the Insert tab to quickly create a chart that’s just right for your data.
+
+* Select the data that you want to include in your chart.
+
+* Click Insert > Recommended Charts.
+
+![](/static/mb/lessons/chart1.png)
+
+* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data. Pick the **scatter plot**.
+
+### ~avatar avatar
+
+Excellent, you're ready to continue with the [challenges](/lessons/charting/challenge)
+
+### ~
+

docs/lessons/charting/challenge.md

@@ -0,0 +1,88 @@
+# Challenge 
+
+### ~avatar avatar 
+
+Welcome! The activity will teach you how to use the acceleration of the 1st micro:bit and to visualize the acceleration on the 2nd micro:bit. 
+Let's get started!
+
+### ~
+Let's measure `acceleration (mg)` and then `send number`. `Acceleration` is measured in **milli-gravities**, so a value of -1000 is equivalent to -1g or -9.81m/s^2. We will be able to get the acceleration value (g-force), in the specified "x" dimension. `Send number` will broadcast a number data packet to other micro:bits connected via radio.
+
+```blocks
+radio.sendNumber(input.acceleration(Dimension.X));
+```
+### ~
+We want to display the acceleration forever. In order to do so, we need a `forever` loop. A forever loop will repeat code in the background forever.
+
+```blocks
+basic.forever(() => {
+    radio.sendNumber(input.acceleration(Dimension.X));
+});
+
+
+```
+### ~
+We want to register code to run when a packet is received over radio. We can implement this code by adding `on data received`.
+
+```blocks
+basic.forever(() => {
+    radio.sendNumber(input.acceleration(Dimension.X))
+})
+radio.onDataReceived(() => {
+    
+})
+```
+### ~
+Finally, we want to chart the acceleration. So we must first implement `plot bar graph`. `Plot Bar Graph` will display a vertical bar graph based on the value and high value. In order to transfer the receive the number from the 1st micro:bit, we must implement `receive number` to constantly display a vertical bar graph based on the value. Remember, the value will equal to the micro:bit's acceleration in the "x" direction.
+
+```blocks
+basic.forever(() => {
+    radio.sendNumber(input.acceleration(Dimension.X))
+})
+radio.onDataReceived(() => {
+    led.plotBarGraph(radio.receiveNumber(), 1023)
+})
+
+```
+### ~
+Notice that moving the micro:bit the farthest direction in the x direction will be -1023 on the charting beneath the simulator. The second observation will be that the LEDs will be full brightness on the 2nd micro:bit. There is a single LED turned on with the 1st micro:bit. Additionally, the graphs will reflect 0 acceleation for the 1st micro:bit. In this scenario, if you are adjusting the acceleration in the simualator, you are also changing your chart that will be produced.  
+
+![](/static/mb/acc.png)
+
+### ~
+NOTE: The colors of the charts reflect the color of the micro:bit simulator. In this instance, the micro:bits are blue and green. So the colors of the line graphs reflect the colors of the micro:bit
+ 
+ ### ~
+After running this simulation several seconds by moving the micro:bit side to side in the x direction, you are ready to graph or chart the accceleration of the micro:bit.  We want a printout of our acceleration on Excel. We will graph the fluctuating acceleration of the simulation experiment. 
+
+![](/static/mb/acc2.png)
+
+### ~
+Finally, you must open the Excel CSV file by clicking on the data.xls file that was downloaded to Downloads Folder. 
+
+![](/static/mb/data3.png)
+
+Use the Recommended Charts command on the Insert tab to quickly create a chart that’s just right for your data.
+
+* Select the data that you want to include in your chart.
+
+* Click Insert > Recommended Charts.
+
+![](/static/mb/lessons/chart1.png)
+
+* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data. Pick the **scatter plot**.
+
+![](/static/mb/chart_title.png)
+
+* Use the Chart Elements, Chart Styles, and Chart Filters buttons next to the upper-right corner of the chart to add chart elements like axis titles or data labels, to customize the look of your chart
+
+![](/static/mb/elements_styles_filters.png)
+
+### ~
+Have fun reviewing your simulation and analyze the acceleration by chart the Excel data using Excel.
+
+* Connect the first micro:bit to your computer using your USB cable and run the charting script on it.
+* Connect the second micro:bit to your computer using your USB cable and run the charting script on it.
+* The first person and second person take turns tilting the micro:bit in the "x" direction while the other player charts the data on the micro:bit!
+* Review and analyze the actual micro:bit device acceleration data on Excel
+* Display acceleration with y or z using plot bar graph by changing acceleration from "x" to "y" or "z" 

docs/lessons/charting/quiz-answers.md

@@ -0,0 +1,33 @@
+# charting quiz answers
+
+Measure the acceleration on the micro:bit in the "x" direction. 
+
+
+## Name
+
+## Directions
+
+Use this activity document to guide your work in the [glowing pendulum activity](/lessons/charting/acceleration)
+
+Answer the questions while completing the tutorial. Pay attention to the dialogues!
+
+## 1. Why are you creating a 'forever' loop?
+
+<br/>
+
+We are creating a forever loop to constantly display the appropriate brightness on the LED display.
+
+## 2. Write the line of code to measure the acceleration with respect to the "x" axis and display this value in a bar graph.
+
+<br/>
+
+```blocks
+led.plotBarGraph(input.acceleration(Dimension.X), 0)
+```
+
+## 3. After vigarously moving the micro:bit from side to side along the "x" axis for a sufficient amount of time,insert the Excel graph for displaying a line chart used to display trends over time. 
+
+<br/>
+
+![](/static/mb/line_chart.png)
+

docs/lessons/charting/quiz.md

@@ -0,0 +1,23 @@
+# charting quiz
+
+Measure the acceleration on the micro:bit in the "x" direction. 
+
+## Name
+
+## Directions
+
+Use this activity document to guide your work in the [glowing pendulum tutorial](/lessons/glowing-pendulum/activity)
+
+Answer the questions while completing the tutorial. Pay attention to the dialogues!
+
+## 1. Why are you creating a 'forever' loop?
+
+<br/>
+
+## 2. Write the line of code to measure the acceleration with respect to the "y" axis and store this value in a local variable called 'acceleration'.
+
+<br/>
+
+## 3. After vigarously moving the micro:bit from side to side along the "x" axis for a sufficient amount of time,insert the Excel graph for displaying a line chart used to display trends over time. 
+
+

docs/lessons/classic-beatbox.md

@@ -1,6 +1,6 @@
 # classic beatbox 
 
-display beautiful images on the BBC micro:bit #var #pause #docs
+display beautiful images on the BBC micro:bit.
 
 ## Topic
 
@@ -8,12 +8,10 @@ Music
 
 ## Quick Links
 
-* [activity](/microbit/lessons/classic-beatbox/activity)
-* [challenges](/microbit/lessons/classic-beatbox/challenges)
+* [activity](/lessons/classic-beatbox/activity)
+* [challenges](/lessons/classic-beatbox/challenges)
 
-## Class
 
-Year 7
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -23,40 +21,3 @@ Learn how to make a beatbox music player using pins P1 and P2. We will be learni
 
 * learn how to code music on the BBC micro:bit
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-* Selects the appropriate data types(AL) (AB
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/classic-beatbox/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/classic-beatbox/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/classic-beatbox/challenges)
-

docs/lessons/classic-beatbox/activity.md

@@ -2,8 +2,6 @@
 
 Control images with variables. 
 
-To create a new script, go to the [Create Code](/microbit/create-code) page and tap *New Project* under *Block Editor*.
-
 Have you ever tried to making beat box sounds? Let's try making a beatbox with code!
 
 Let's start by adding a variable where you can store data. Then rename the variable to "sound". Then set the value of the variable to the note block `A` from the Music drawer. Modify your code so that your code looks like this.
@@ -51,6 +49,6 @@ input.onPinPressed(TouchPin.P1, () => {
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/classic-beatbox/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/classic-beatbox/challenges)!
 
 ### ~

docs/lessons/classic-beatbox/challenges.md

@@ -4,7 +4,7 @@ Create sounds with variables.
 
 ## Before we get started
 
-Complete the [beatbox](/microbit/lessons/beatbox/activity) activity and your code will look like this:
+Complete the [beatbox](/lessons/classic-beatbox/activity) activity and your code will look like this:
 
 
 ```blocks
@@ -17,7 +17,7 @@ input.onPinPressed(TouchPin.P1, () => {
 })
 ```
 
-**Challenge 1**
+### Challenge 1
 
 Let's include a second sound `on pin pressed` *P2*. To do this, you need to add the same blocks as the banana keyboard activity. However, you must change alter `on pin pressed` from P1 to P2. Additionally, you must *decrease* the frequency of the variable "sound" by 25. Modify your code so that your code looks like this
 
@@ -42,7 +42,7 @@ input.onPinPressed(TouchPin.P2, () => {
 
 * click *run* to see if the code works as expected.
 
-**Challenge 2**
+### Challenge 2
 
 Finally, we want images to be displayed with sounds `on pin pressed`. Add `show LEDs` blocks under `on pin pressed` P1 and P2.
 

docs/lessons/compass.md

@@ -1,8 +1,6 @@
 # compass lesson
 
-create a die on the BBC micro:bit #button #pressed #math #random #var #string #if #docs
-
-### @video td/videos/compass-0
+create a die on the BBC micro:bit.
 
 ## Topic
 
@@ -10,12 +8,10 @@ If (Conditionals)
 
 ## Quick Links
 
-* [activity](/microbit/lessons/compass/activity)
-* [challenges](/microbit/lessons/compass/challenges)
-
-## Class
-
-Year 7
+* [activity](/lessons/compass/activity)
+* [challenges](/lessons/compass/challenges)
+* [quiz](/lessons/compass/quiz)
+* [quiz answers](/lessons/compass/quiz-answers)
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -23,14 +19,20 @@ Learn how to use an if statements to run code run code depending on whether a co
 
 ## Documentation
 
-* **Compass Heading** : [read more...](/microbit/reference/input/compass-heading)
-* **Forever** : [read more...](/microbit/reference/basic/forever)
-* **Variables** : [read more...](/microbit/reference/variables/var)
-* **Assignment Operator** : [read more...](/microbit/reference/variables/assign)
-* **If** : [read more...](/microbit/reference/logic/if)
-* **Comparison Operator** : [read more...](/microbit/reference/types/number)
-* **Show String** : [read more...](/microbit/reference/basic/show-string)
-* **Show LEDs** : [read more...](/microbit/reference/basic/show-leds)
+```cards
+input.compassHeading()
+basic.forever(() => {})
+let x = 0
+if (true) {}
+basic.showString("Hello!")
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+```
 
 ## Objectives
 
@@ -41,57 +43,3 @@ Learn how to use an if statements to run code run code depending on whether a co
 * learn how to return a random number
 * learn how to conditionally run code depending on whether a condition is true or not
 * learn how to show an image on the LED screen
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Designs solutions (algorithms) that use repetition and two-way  selection, ie if, then and else.(AL)
-* Uses diagrams to express solutions.(AB)
-*  Uses logical reasoning to predict  outputs, showing an awareness of inputs (AL)
-*  Designs solutions  by decomposing a problem and creates a sub-solution for each of these parts. (DE) (AL) (AB)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-*  Declares and assigns variables(AB)
-* Understands the difference between, and appropriately uses if and if, then and else statements(AL)
-* Uses a range of operators and expressions e.g. Boolean, and applies them in the context of program control. (AL)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Understands the difference between data and information(AB)
-* Uses filters or can perform single criteria searches for information.(AL)
-* Performs more complex searches for information e.g. using Boolean and relational operators(AL) (GE) (EV)
-* Defines data types: real numbers and Boolean (AB)
-
-#### Hardware & Processing
-
-* Knows that computers collect data from various input devices, including sensors and application software (AB)
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-* Makes judgements about digital content when evaluating and repurposing it for a given audience (EV) (GE)
-* Recognises ethical issues surrounding the application of information technology beyond school.
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/compass/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/compass/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/compass/challenges)
-

docs/lessons/compass/activity.md

@@ -28,9 +28,8 @@ basic.forever(() => {
 If `degrees` is less than `45`, then the compass heading is mostly pointing toward North. Display `N` on the micro:bit.
 
 ```blocks
- let degrees = 0;
 basic.forever(() => {
-    degrees = input.compassHeading();
+    let degrees = input.compassHeading();
     if (degrees < 45) {
         basic.showString("N");
     }
@@ -41,9 +40,8 @@ If `degrees` is less than 135, the micro:bit is mostly pointing East. Display `E
 
 
 ```blocks
- let degrees = null;
 basic.forever(() => {
-    degrees = input.compassHeading();
+    let degrees = input.compassHeading();
     if (degrees < 45) {
         basic.showString("N");
     }
@@ -57,9 +55,8 @@ If `degrees` is less than 225, the micro:bit is mostly pointing South. Display `
 
 
 ```blocks
- let degrees = null;
 basic.forever(() => {
-    degrees = input.compassHeading();
+    let degrees = input.compassHeading();
     if (degrees < 45) {
         basic.showString("N");
     }
@@ -76,9 +73,8 @@ basic.forever(() => {
 If none of these conditions returned true, then the micro:bit must be pointing West. Display `W` on the micro:bit.
 
 ```blocks
- let degrees = null;
 basic.forever(() => {
-    degrees = input.compassHeading();
+    let degrees = input.compassHeading();
     if (degrees < 45) {
         basic.showString("N");
     }
@@ -96,7 +92,7 @@ basic.forever(() => {
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/compass/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/compass/challenges)!
 
 ### ~
 

docs/lessons/compass/challenges.md

@@ -4,10 +4,10 @@ Display the direction that the micro:bit is facing using the compass
 
 ## Before we get started
 
-Complete the following [guided tutorial](/microbit/lessons/compass/activity), your code should look like this:
+Complete the following [guided tutorial](/lessons/compass/activity), your code should look like this:
 
 ```blocks
- let degrees = null;
+ let degrees = 0;
 basic.forever(() => {
     degrees = input.compassHeading();
     if (degrees < 45) {
@@ -30,7 +30,7 @@ basic.forever(() => {
 Instead of displaying `N` when the BBC micro:bit is pointing North, display a star to indicate the north star.
 
 ```blocks
- let degrees = null;
+ let degrees = 0;
 basic.forever(() => {
     degrees = input.compassHeading();
     if (degrees < 45) {
@@ -61,7 +61,7 @@ basic.forever(() => {
 Instead of displaying just `N`, `W`, `S`, or `E`, display the full word.
 
 ```blocks
- let degrees = null;
+ let degrees = 0;
 basic.forever(() => {
     degrees = input.compassHeading();
     if (degrees < 45) {

docs/lessons/compass/quiz-answers.md

@@ -6,7 +6,7 @@ Create an actual compass to show your direction: North, South, East, or West
 
 ## Directions
 
-Use this activity document to guide your work in the [compass tutorial](/microbit/lessons/compass/activity).
+Use this activity document to guide your work in the [compass tutorial](/lessons/compass/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
@@ -14,41 +14,39 @@ Answer the questions while completing the tutorial. Pay attention to the dialogu
 
 Gets the compass heading of the micro:bit in degrees
 
-<br/>
 
 ## 2. Write the code that stores the compass heading into a local variable called 'degrees'. 
 
-<br/>
 
-```
+```blocks
 let degrees = input.compassHeading()
 ```
 
 ## 3. Write the 'If statement' that will check if the device is mostly pointing North. Display 'N' on the micro:bit 
 
-<br />
 
-```
+```blocks
+let degrees = input.compassHeading()
 if (degrees < 45) {
     basic.showString("N", 150)
 }
 ```
 
-## 3. Write the 'If statement' that will check if the device is mostly pointing East. Display 'E' on the micro:bit 
+## 4. Write the 'If statement' that will check if the device is mostly pointing East. Display 'E' on the micro:bit 
 
-<br />
 
-```
+```blocks
+let degrees = input.compassHeading()
 if (degrees < 135) {
     basic.showString("E", 150)
 }
 ```
 
-## 3. Write the 'If statement' that will check if the device is mostly pointing South. Display 'S' on the micro:bit 
+## 5. Write the 'If statement' that will check if the device is mostly pointing South. Display 'S' on the micro:bit 
 
-<br />
 
-```
+```blocks
+let degrees = input.compassHeading()
 if (degrees < 225) {
     basic.showString("S", 150)
 }

docs/lessons/compass/quiz.md

@@ -6,27 +6,21 @@ Create an actual compass to show your direction: North, South, East, or West
 
 ## Directions
 
-Use this activity document to guide your work in the [compass activity](/microbit/lessons/compass/activity).
+Use this activity document to guide your work in the [compass activity](/lessons/compass/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
 ## 1. What is the purpose of the 'compass heading' block?
 
-<br/>
-
 ## 2. Write the code that stores the compass heading into a local variable called 'degrees'. 
 
-<br/>
 
 ## 3. Write the 'If statement' that will check if the device is mostly pointing North. Display 'N' on the micro:bit 
 
-<br />
 
-## 3. Write the 'If statement' that will check if the device is mostly pointing East. Display 'E' on the micro:bit 
+## 4. Write the 'If statement' that will check if the device is mostly pointing East. Display 'E' on the micro:bit 
 
-<br />
 
-## 3. Write the 'If statement' that will check if the device is mostly pointing South. Display 'S' on the micro:bit 
+## 5. Write the 'If statement' that will check if the device is mostly pointing South. Display 'S' on the micro:bit 
 
-<br />
 

docs/lessons/counter.md

@@ -1,8 +1,6 @@
 # counter lesson
 
-Learn how to create a counter with with on button pressed. #show #number #screen  #number #math #docs
-
-### @video td/videos/counter-0
+Learn how to create a counter with with on button pressed.
 
 ## Topic
 
@@ -10,12 +8,10 @@ Variables
 
 ## Quick Links
 
-* [activity](/microbit/lessons/counter/activity)
-* [challenges](/microbit/lessons/counter/challenges)
-
-## Class
-
-Year 7
+* [activity](/lessons/counter/activity)
+* [challenges](/lessons/counter/challenges)
+* [quiz](/lessons/counter/quiz)
+* [quiz answers](/lessons/counter/quiz-answers)
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -23,10 +19,25 @@ Learn how to creating a **variable** to keep track of the current count. We will
 
 ## Documentation
 
-* **variable**: [read more...](/microbit/reference/variables/var)
-* **arithmetic operators**: [read more...](/microbit/reference/types/number)
-* **on button pressed** : [read more...](/microbit/reference/input/on-button-pressed)
-* **show number** : [read more...](/microbit/reference/basic/show-number)
+```cards
+input.compassHeading()
+basic.forever(() => {})
+let x = 0
+if (true) {}
+basic.showString("Hello!")
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+```
+
+* **variable**: [read more...](/blocks/variables)
+* **arithmetic operators**: [read more...](/reference/types/number)
+* **on button pressed** : [read more...](/reference/input/on-button-pressed)
+* **show number** : [read more...](/reference/basic/show-number)
 
 ## Objectives
 
@@ -35,41 +46,3 @@ Learn how to creating a **variable** to keep track of the current count. We will
 * learn how to run code when an input button is pressed
 * learn how to show a number on the LED screen, one digit at a time (scrolling from left to right)
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Understands that iteration is the repetition of a process such as a loop. (AL)
-* Represents solutions using a structured notation. (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals. (AL)
-* Declares and assigns variables.(AB)
-
-#### Data & Data Representation
-
-* Understands the difference between data and information. (AB)
-* Defines data types: real numbers and Boolean. (AB)
-
-#### Information Technology
-
-*  Collects, organises and presents data and information in digital content. (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution. (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/counter/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/counter/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/counter/challenges)
-

docs/lessons/counter/activity.md

@@ -4,8 +4,6 @@ Display a number with a variable.
 
 ### ~avatar avatar
 
-### @video td/videos/counter-0
-
 Welcome! This tutorial will teach you how to make a counter that increments when button A is pressed. Let's get started!
 
 ### ~
@@ -39,7 +37,7 @@ input.onButtonPressed(Button.A, () => {
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/counter/challenges)
+Excellent, you're ready to continue with the [challenges](/lessons/counter/challenges)
 
 ### ~
 

docs/lessons/counter/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the counter.
 
 ## Before we get started
 
-Complete the following [guided tutorial](/microbit/lessons/counter/activity) At the end of the tutorial, click **keep editing**. Your code should look like this:
+Complete the following [guided tutorial](/lessons/counter/activity) At the end of the tutorial, click **keep editing**. Your code should look like this:
 
 ```blocks
 let count = 0
@@ -16,8 +16,6 @@ input.onButtonPressed(Button.A, () => {
 
 ### Challenge 1
 
-### @video td/videos/counter-1-2
-
 Let's add the code to `count` when `B` is pressed. Add an event handler with `on button pressed(B)` then add the code to `count`.
 
 
@@ -33,7 +31,6 @@ input.onButtonPressed(Button.B, () => {
 })
 ```
 
-
 ### Challenge 3
 
 Now let's try to reset the counter when the micro:bit is shaken. You will need to register an event handler with `on shake`.

docs/lessons/counter/quiz-answers.md

@@ -2,7 +2,7 @@
 
 Learn how to create a counter with the BBC micro:bit button. 
 
-This is the answer key for the [counter quiz](/microbit/lessons/counter/quiz).
+This is the answer key for the [counter quiz](/lessons/counter/quiz).
 
 ## 1. What is a variable?
 
@@ -10,7 +10,7 @@ Answers may vary but a variable is a place where you can store and retrieve data
 
 ## 2. Draw the stored value for the variable called count
 
-```
+```blocks
 let count = 0
 ```
 
@@ -22,11 +22,11 @@ We create a **variable**, `count` to keep track of the current count. The number
 
 ## 3. Draw which LEDs are ON after running this code and pressing button "A" once. Explain you chose to draw that number
 
-```
-let count_ = 0
-input.onButtonPressed("A", () => {
-    count_ = count_ + 1
-    basic.showNumber(count, 150)
+```blocks
+let count = 0
+input.onButtonPressed(Button.A, () => {
+    count = count + 1
+    basic.showNumber(count)
 })
 ```
 
@@ -38,11 +38,11 @@ We are only pressing on button pressed once. So the number to display on the mic
 
 ## 4. Draw which LEDs are ON after running this code and pressing button "A" three times. Explain you chose to draw that number
 
-```
-count_ = 0
-input.onButtonPressed("A", () => {
-    count_ = count_ + 1
-    basic.showNumber(count_, 100)
+```blocks
+let count = 0
+input.onButtonPressed(Button.A, () => {
+    count =  + 1
+    basic.showNumber(count)
 })
 ```
 

docs/lessons/counter/quiz.md

@@ -6,7 +6,7 @@ Learn how to create a counter with the BBC micro:bit button.
 
 ## Directions
 
-Use this activity document to guide your work in the [counter tutorial](/microbit/lessons/counter/activity).
+Use this activity document to guide your work in the [counter tutorial](/lessons/counter/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 
@@ -16,7 +16,7 @@ Answer the questions while completing the tutorial. Pay attention to the dialogu
 
 ## 2. Draw the stored value for the variable called count
 
-```
+```blocks
 let count = 0
 ```
 
@@ -26,11 +26,11 @@ let count = 0
 
 ## 3. Draw which LEDs are ON after running this code and pressing button "A" once. Explain you chose to draw that number
 
-```
-let count_ = 0
-input.onButtonPressed("A", () => {
-    count_ = count_ + 1
-    basic.showNumber(count_, 100)
+```blocks
+let counts = 0
+input.onButtonPressed(Button.A, () => {
+    counts = counts + 1
+    basic.showNumber(counts, 150)
 })
 ```
 
@@ -40,11 +40,11 @@ input.onButtonPressed("A", () => {
 
 ## 4. Draw which LEDs are ON after running this code and pressing button "A" three times. Explain you chose to draw that number
 
-```
-count_ = 0
-input.onButtonPressed("A", () => {
-    count_ = count_ + 1
-    basic.showNumber(count_, 100)
+```blocks
+let counting= 0
+input.onButtonPressed(Button.A, () => {
+    counting = counting + 1
+    basic.showNumber(counting, 100)
 })
 ```
 

docs/lessons/crocodile-clip/activity.md

@@ -1,41 +0,0 @@
-# crocodile clip activity 
-
-Use the crocodile clips 
-
-# micro:bit crocodile clip
-
-![](/static/mb/blocks/lessons/crocodile-clip-0.jpg)
-
-In this project, you will build a circuit with the micro:bit from crocodile clips. Project duration: 15 minutes.
-
-## Materials
-
-* micro:bit, battery holder and 2 AAA batteries
-* Crocodile clips
-
-## Steps
-
-### Step 1
-
-![](/static/mb/lessons/banana-keyboard-1.png)
-
-Using the 1st crocodile clip, connect the end of the crocodile clip onto GND pin on the micro:bit.
-
-### Step 2
-
-![](/static/mb/crocodile-clips-2.jpg)
-
-Using the 1st crocodile clip, connect the unattached end of the crocodile clip onto the 0 pin on the micro:bit.
-
-### Step 3
-
-![](/static/mb/blocks/lessons/crocodile-clip-0.jpg)
-
-Disconnect the end of the crocodile clip from the 0 pin of the micro:bit.
-
-Your circuit is complete!
-
-### Step 10
-
-Connect your micro:bit to your computer using your USB cable and run the [guess the number](/microbit/lhpkbr) script on it.
-

docs/lessons/dice-roll.md

@@ -0,0 +1,44 @@
+# dice roll lesson
+
+Create a  dice on the BBC micro:bit.
+
+## Topic
+
+If (Conditionals)
+
+## Quick Links
+
+* [activity](/lessons/dice-roll/activity)
+* [challenges](/lessons/dice-roll/challenges)
+* [quiz](/lessons/dice-roll/quiz)
+* [quiz answers](/lessons/dice-roll/quiz-answers)
+
+## Prior learning/place of lesson in scheme of work
+
+Learn how to use an if statements to run code run code depending on whether a condition is true or not. We will be learning how to create a die with If statements, On Shake, Variables, Assignment Operator, Pick Random and Show LEDs
+
+## Documentation
+
+```cards
+input.onGesture(Gesture.Shake, () => {})
+let x = 0
+Math.random(3)
+if (true) {}
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+```
+
+## Objectives
+
+* learn how to run code when the BBC micro:bit is shaken, when running code in the web browser, moving the mouse quickly simulates shaking
+* learn how to create a local variable as a place where you can store and retrieve data
+* learn how the assignment operator is used to declare a new local variable
+* learn how to declare a new local variable or update the value of a variable
+* learn how to return a random number
+* learn how to conditionally run code depending on whether a condition is true or not
+* learn how to show an image on the LED screen

docs/lessons/dice-roll/activity.md

@@ -1,12 +1,10 @@
-# die roll activity
+# dice roll activity
 
-Create a die on the micro:bit
+Create a dice on the micro:bit
 
 ### ~avatar avatar
 
-### @video td/videos/die-roll-0
-
-Welcome! This tutorial will help you create a die. Let's get started!
+Welcome! This tutorial will help you create a dice. Let's get started!
 
 ### ~
 
@@ -19,7 +17,7 @@ input.onGesture(Gesture.Shake, () => {
 })
 ```
 
-We need to show a random value from 1 to 6 on our die. So let's make a local variable called **roll**.
+We need to show a random value from 1 to 6 on our dice. So let's make a local variable called **roll**.
 
 ```blocks
 input.onGesture(Gesture.Shake, () => {
@@ -27,7 +25,7 @@ input.onGesture(Gesture.Shake, () => {
 })
 ```
 
-We need a condition for if **roll** is 5. We will show a `6` if **roll** is 5 because **roll** has a range from 0 to 5. We can use `show LEDs` to display the side of a die that shows 6.
+We need a condition for if **roll** is 5. We will show a `6` if **roll** is 5 because **roll** has a range from 0 to 5. We can use `show LEDs` to display the side of a dice that shows 6.
 
 
 ```blocks
@@ -45,7 +43,7 @@ input.onGesture(Gesture.Shake, () => {
 ```
 
 
-Let's use an `else if` condition for if **roll** is 4. If **roll** is 4 we can show 5 dots on the die.
+Let's use an `else if` condition for if **roll** is 4. If **roll** is 4 we can show 5 dots on the dice.
 
 
 ```blocks
@@ -72,7 +70,7 @@ input.onGesture(Gesture.Shake, ()=> {
 ```
 
 
-Now we need to repeat the same steps for if **roll** is 3. If **roll** is 3 we will show `4` on the die.
+Now we need to repeat the same steps for if **roll** is 3. If **roll** is 3 we will show `4` on the dice.
 
 
 ```blocks
@@ -106,7 +104,7 @@ input.onGesture(Gesture.Shake, () => {
 ```
 
 
-Let's also repeat these steps to show the 3, 2, and 1 on the die. We are almost done with our die!
+Let's also repeat these steps to show the 3, 2, and 1 on the dice. We are almost done with our dice!
 
 ```blocks 
 input.onGesture(Gesture.Shake, () => {
@@ -165,7 +163,7 @@ input.onGesture(Gesture.Shake, () => {
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/die-roll/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/dice-roll/challenges)!
 
 ### ~
 

docs/lessons/dice-roll/challenges.md

@@ -1,10 +1,10 @@
-# die roll challenges
+# dice roll challenges
 
-Create a die on the micro:bit. 
+Create a dice on the micro:bit. 
 
 ## Before we get started
 
-Complete the following [guided tutorial](/microbit/lessons/die-roll/activity), your code should look like this:
+Complete the following [guided tutorial](/lessons/dice-roll/activity), your code should look like this:
 
 ```blocks 
 input.onGesture(Gesture.Shake, () => {
@@ -62,7 +62,7 @@ input.onGesture(Gesture.Shake, () => {
 
 ### Challenge 1
 
-Modify the line of code with `pick random` so that only number 1-4 can appear on the die.
+Modify the line of code with `pick random` so that only number 1-4 can appear on the dice.
 
 
 ```blocks 
@@ -121,7 +121,7 @@ input.onGesture(Gesture.Shake, () => {
 
 ### Challenge 2
 
-Let's make a trick die! Modify the line of code with `pick random` so that only numbers 3-6 can appear on the die. Also note that we need to ensure `roll = 0` when only 1 dot is shown on the BBC micro:bit.
+Let's make a trick dice! Modify the line of code with `pick random` so that only numbers 3-6 can appear on the dice. Also note that we need to ensure `roll = 0` when only 1 dot is shown on the BBC micro:bit.
 
 ```blocks 
 input.onGesture(Gesture.Shake, () => {

docs/lessons/dice-roll/quiz-answers.md

@@ -1,14 +1,14 @@
-# die roll quiz answers
+# dice roll quiz answers
 
-Create a die when the BBC micro:bit is shaken 
+Create a dice when the BBC micro:bit is shaken 
 
-These are the answers to the [die roll quiz](/microbit/lessons/die-roll/quiz).
+These are the answers to the [dice roll quiz](/lessons/dice-roll/quiz).
 
 ## 1. Create a variable named 'roll' that will be randomly assigned to a number between 0 and 5.
 
 <br/>
 
-```
+```blocks
 let roll = Math.random(6)
 ```
 
@@ -18,9 +18,10 @@ let roll = Math.random(6)
 
 <br/>
 
-```
+```blocks
+let roll = Math.random(6)
 if (roll == 5) {
-    basic.plotImage(`
+    basic.showLeds(`
 . # . # .
 . . . . .
 . # . # .
@@ -36,9 +37,11 @@ if (roll == 5) {
 
 <br />
 
-```
+```blocks
+
+let roll = Math.random(6)
 if (roll == 5) {
-    basic.plotImage(`
+    basic.showLeds(`
 . # . # .
 . . . . .
 . # . # .
@@ -46,7 +49,7 @@ if (roll == 5) {
 . # . # .
 `)
 } else if (roll == 4) {
-    basic.plotImage(`
+    basic.showLeds(`
 . . . . .
 . # . # .
 . . # . .
@@ -64,9 +67,10 @@ Note: students are only required to write the bottom half of this answer, starti
 
 <br />
 
-```
+```blocks
+let roll = Math.random(6)
 if (roll == 4) {
-    basic.plotImage(`
+    basic.showLeds(`
 . . . . .
 . # . # .
 . . # . .
@@ -74,7 +78,7 @@ if (roll == 4) {
 . . . . .
 `)
 } else if (roll == 3) {
-    basic.plotImage(`
+    basic.showLeds(`
 . . . . .
 . # . # .
 . . . . .
@@ -92,9 +96,10 @@ Note: students are only required to write the bottom half of this answer, starti
 
 <br />
 
-```
+```blocks
+let roll = Math.random(6)
 if (roll == 3) {
-    basic.plotImage(`
+    basic.showLeds(`
 . . . . .
 . # . # .
 . . . . .
@@ -102,7 +107,7 @@ if (roll == 3) {
 . . . . .
 `)
 } else if (roll == 2) {
-    basic.plotImage(`
+    basic.showLeds(`
 # . . . .
 . . . . .
 . . # . .

docs/lessons/dice-roll/quiz.md

@@ -1,12 +1,12 @@
-# die roll quiz
+# dice roll quiz
 
-Create a die when the BBC micro:bit is shaken 
+Create a dice when the BBC micro:bit is shaken 
 
 ## Name
 
 ## Directions
 
-Use this activity document to guide your work in the [die roll tutorial](/microbit/lessons/die-roll/tutorial).
+Use this activity document to guide your work in the [dice roll tutorial](/lessons/dice-roll/activity).
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 

docs/lessons/die-roll.md

@@ -1,95 +0,0 @@
-# die roll lesson
-
-create a die on the BBC micro:bit #button #pressed #math #random #var #string #if #docs
-
-### @video td/videos/die-roll-0
-
-## Topic
-
-If (Conditionals)
-
-## Quick Links
-
-* [activity](/microbit/lessons/die-roll/activity)
-* [challenges](/microbit/lessons/die-roll/challenges)
-
-## Class
-
-Year 7
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to use an if statements to run code run code depending on whether a condition is true or not. We will be learning how to create a die with If statements, On Shake, Variables, Assignment Operator, Pick Random and Show LEDs
-
-## Documentation
-
-* **Variables** : [read more...](/microbit/reference/variables/var)
-* **If** : [read more...](/microbit/blocks/if)
-* **On Shake** : [read more...](/microbit/reference/on-gesture)
-* **Assignment Operator** : [read more...](/microbit/reference/variables/assign)
-* **Pick Random** : [read more...](/microbit/blocks/math)
-* **Show LEDs** : [read more...](/microbit/reference/basic/show-leds)
-
-## Objectives
-
-* learn how to run code when the BBC micro:bit is shaken, when running code in the web browser, moving the mouse quickly simulates shaking
-* learn how to create a local variable as a place where you can store and retrieve data
-* learn how the assignment operator is used to declare a new local variable
-* learn how to declare a new local variable or update the value of a variable
-* learn how to return a random number
-* learn how to conditionally run code depending on whether a condition is true or not
-* learn how to show an image on the LED screen
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Designs solutions (algorithms) that use repetition and two-way  selection, ie if, then and else.(AL)
-* Uses diagrams to express solutions.(AB)
-*  Uses logical reasoning to predict  outputs, showing an awareness of inputs (AL)
-*  Designs solutions  by decomposing a problem and creates a sub-solution for each of these parts. (DE) (AL) (AB)
-* Represents solutions using a structured notation (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-*  Declares and assigns variables(AB)
-* Understands the difference between, and appropriately uses if and if, then and else statements(AL)
-* Uses a range of operators and expressions e.g. Boolean, and applies them in the context of program control. (AL)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Understands the difference between data and information(AB)
-* Uses filters or can perform single criteria searches for information.(AL)
-* Performs more complex searches for information e.g. using Boolean and relational operators(AL) (GE) (EV)
-* Defines data types: real numbers and Boolean (AB)
-
-#### Hardware & Processing
-
-* Knows that computers collect data from various input devices, including sensors and application software (AB)
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-* Makes judgements about digital content when evaluating and repurposing it for a given audience (EV) (GE)
-* Recognises ethical issues surrounding the application of information technology beyond school.
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/die-roll/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/die-roll/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/die-roll/challenges)
-

docs/lessons/digi-yoyo.md

@@ -1,8 +1,6 @@
 # digi yoyo lesson
 
-create a counter with a while loop #while #loop #counter #docs
-
-### @video td/videos/digi-yoyo-0
+Create a counter with a while loop.
 
 ## Topic
 
@@ -10,12 +8,10 @@ While Loop
 
 ## Quick Links
 
-* [activity](/microbit/lessons/digi-yoyo/activity)
-* [challenges](/microbit/lessons/digi-yoyo/challenges)
-
-## Class
-
-Year 7
+* [activity](/lessons/digi-yoyo/activity)
+* [challenges](/lessons/digi-yoyo/challenges)
+* [quiz](/lessons/digi-yoyo/quiz)
+* [quiz answers](/lessons/digi-yoyo/quiz-answers)
 
 ## Prior learning/place of lesson in scheme of work
 
@@ -23,12 +19,12 @@ Learn how to creating a **while loop**, `while condition do` to repeat code whil
 
 ## Documentation
 
-* **variables** : [read more...](/microbit/reference/variables/var)
-* **assignment operator** : [read more...](/microbit/reference/variables/assign)
-* **while loop** : [read more...](/microbit/reference/loops/while)
-* **relational operator ** : [read more...](/microbit/reference/types/number)
-* **pause** : [read more...](/microbit/reference/basic/pause)
-* **show number** : [read more...](/microbit/reference/basic/show-number)
+```cards
+let x = 0
+basic.showNumber(0)
+while (true) {}
+basic.pause(20)
+```
 
 ## Objectives
 
@@ -39,50 +35,3 @@ Learn how to creating a **while loop**, `while condition do` to repeat code whil
 * learn how to pause your code for the specified number of milliseconds
 * learn how to show a number on the LED screen
 
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Uses diagrams to express solutions.(AB)
-* Recognises that different solutions exist for the same problem (AL) (AB)  Understands that iteration is the repetition of a process such as a loop (AL)
-* Recognises that different algorithms exist for the same problem (AL) (GE)
-* Represents solutions using a structured notation (AL) (AB)
-*  Can identify similarities and differences in situations and can use these to solve problems (pattern recognition)(GE)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals (AL)
-*  Declares and assigns variables(AB)
-* Uses a variable and relational operators within a loop to govern termination (AL) (GE)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Uses filters or can perform single criteria searches for information.(AL)
-
-#### Communication Networks
-
-* Demonstrates responsible use of technologies and online services, and knows a range of ways to report concerns Understands how search engines rank search results (AL)
-
-#### Information Technology
-
-* Collects, organizes, and presents data and information in digital content (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution (EV)
-* Recognises ethical issues surrounding the application of information technology beyond school.
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Activity
-
-* time: 20 min.
-* [activity](/microbit/lessons/digi-yoyo/activity)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/digi-yoyo/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/digi-yoyo/challenges)
-

docs/lessons/digi-yoyo/activity.md

@@ -4,8 +4,6 @@ Create a counter with a while loop.
 
 ### ~avatar avatar
 
-### @video td/videos/digi-yoyo-0
-
 Welcome! This tutorial will teach how to create a counter with a while loop. Let's get started!
 
 ### ~
@@ -18,7 +16,6 @@ let count = 0
 
 Add a while loop that will loop over and over until the variable `count` equals 10.
 
-![](/static/mb/blocks/lessons/digi-yoyo-1.jpg)
 
 ```blocks
 let count = 0
@@ -32,7 +29,7 @@ Let's add a pause. Then show the value of the the count.
 
 
 ```blocks
- let count = 0;
+let count = 0;
 while (count < 10) {
     basic.pause(100);
     basic.showNumber(count)
@@ -48,14 +45,14 @@ let count = 0
 while (count < 10) {
     basic.pause(100)
      basic.showNumber(count)
-    count == count + 1
+    count = count + (count - 1)
 }
 ```
 
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/digi-yoyo/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/digi-yoyo/challenges)!
 
 ### ~
 

docs/lessons/digi-yoyo/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the digi yoyo.
 
 ## Before we get started
 
-Complete the following [guided tutorial](/microbit/lessons/digi-yoyo/activity), your code should look like this:
+Complete the following [guided tutorial](/lessons/digi-yoyo/activity), your code should look like this:
 
 
 ```blocks
@@ -40,8 +40,6 @@ while (count > 0) {
 
 ### Challenge 2
 
-### @video td/videos/digi-yoyo-1-2
-
 Inside of the while loop, let's add `pause->(1000)` so that we have a pause between each number as it's counting down. Also, let's show `count`!
 
 
@@ -69,5 +67,7 @@ Now, we need `count` to decrease by one after the micro:bit has displayed the va
 We can do this by adding this line:
 
 ```blocks
-let count = count + (count - 1);
+let count = 0; 
+count = count + (count - 1);
+
 ```

docs/lessons/digi-yoyo/quiz-answers.md

@@ -2,7 +2,7 @@
 
 Answers for digi yoyo quiz. 
 
-This is the answer key for the [digi yoyo quiz](/microbit/lessons/digi-yoyo/quiz).
+This is the answer key for the [digi yoyo quiz](/lessons/digi-yoyo/quiz).
 
 ## 1. Describe what a "while loop" does?
 
@@ -16,7 +16,7 @@ A loop that repeats code while a condition is true.
 
 <br/>
 
-```
+```blocks
 let count = 0
 ```
 
@@ -26,7 +26,8 @@ let count = 0
 
 <br/>
 
-```
+```blocks
+let count = 0
 while (count < 5) {
     count = count + 1
 }

docs/lessons/digi-yoyo/quiz.md

@@ -6,7 +6,7 @@ Create a counter with a while loop
 
 ## Directions
 
-Use this activity document to guide your work in the [digi yoyo tutorial](/microbit/lessons/digi-yoyo/tutorial)
+Use this activity document to guide your work in the [digi yoyo tutorial](/lessons/digi-yoyo/activity)
 
 Answer the questions while completing the tutorial. Pay attention to the dialogues!
 

docs/lessons/flashing-heart.md

@@ -1,8 +1,6 @@
 # flashing heart blocks lesson
 
-Learn how to create LED images with a global variable. #LED #screen  #plot #docs
-
-### @video td/videos/flashing-heart-0
+Learn how to create LED images with a global variable.
 
 ## Topic
 
@@ -10,25 +8,28 @@ Pause
 
 ## Quick links
 
-* [activity](/microbit/lessons/flashing-heart/activity)
-* [quiz](/microbit/lessons/flashing-heart/quiz)
-* [quiz answers](/microbit/lessons/flashing-heart/quiz-answers)
-* [challenges](/microbit/lessons/flashing-heart/challenges)
-
-## Class
-
-Year 7
-
+* [activity](/lessons/flashing-heart/activity)
+* [quiz](/lessons/flashing-heart/quiz)
+* [quiz answers](/lessons/flashing-heart/quiz-answers)
+* [challenges](/lessons/flashing-heart/challenges)
 ## Prior learning/place of lesson in scheme of work
 
 Learn how to `show LEDs` by showing an image on the LED screen. We will be learning how to create a blinking app using a forever loop as well as simple commands, such as show LEDs, pause, and clear screen.
 
 ## Documentation
 
-* **forever**: [read more...](/microbit/reference/basic/forever)
-* **show LEDs** : [read more...](/microbit/reference/basic/show-leds)
-* **pause**: [read more...](/microbit/reference/basic/pause)
-* **clear screen**: [read more...](/microbit/reference/basic/clear-screen)
+```cards
+basic.forever(() => {})
+basic.showLeds(`
+    . . . . .
+    . . . . .
+    . . # . .
+    . . . . .
+    . . . . .
+    `)
+basic.pause(100)
+basic.clearScreen()
+```
 
 ## Objectives
 
@@ -36,43 +37,3 @@ Learn how to `show LEDs` by showing an image on the LED screen. We will be learn
 * learn how to show LEDs on the LED screen
 * learn how to pause your code for the specified number of milliseconds
 * learn how to turn off all the LED lights on the LED screen
-
-## Progression Pathways / Computational Thinking Framework
-
-#### Algorithms
-
-* Understands that iteration is the repetition of a process such as a loop. (AL)
-* Represents solutions using a structured notation. (AL) (AB)
-
-#### Programming & Development
-
-* Creates programs that implement algorithms to achieve given goals. (AL)
-* Declares and assigns variables.(AB)
-
-#### Data & Data Representation
-
-* Understands the difference between data and information. (AB)
-* Defines data types: real numbers and Boolean. (AB)
-
-#### Information Technology
-
-*  Collects, organises and presents data and information in digital content. (AB)
-* Makes appropriate improvements to solutions based on feedback received, and can comment on the success of the solution. (EV)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-
-## Exercise
-
-* time: 20 min.
-* [activity](/microbit/lessons/flashing-heart/activity)
-* [quiz](/microbit/lessons/flashing-heart/quiz)
-
-## Extended Activity
-
-* time: 20 min.
-* [challenges](/microbit/lessons/flashing-heart/challenges)
-
-## Homework
-
-* Extended Activity: [challenges](/microbit/lessons/flashing-heart/challenges)
-

docs/lessons/flashing-heart/activity.md

@@ -4,14 +4,10 @@ Control images with a variable.
 
 ### ~avatar avatar
 
-### @video td/videos/flashing-heart-0
-
 In this activity, you will learn how to blink an image on the LED screen.
 
 ### ~
 
-To create a new script, go to the [Create Code](/microbit/create-code) page and tap *New Project* under *Block Editor*.
-
 Let's start by adding code that plots a heart image on the screen using `show LEDs`. Once you are done coding, don't forget to run your code in the simulator or the micro:bit.
 
 
@@ -69,7 +65,7 @@ basic.forever(() => {
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/microbit/lessons/flashing-heart/challenges)!
+Excellent, you're ready to continue with the [challenges](/lessons/flashing-heart/challenges)!
 
 ### ~
 

docs/lessons/flashing-heart/challenges.md

@@ -4,7 +4,7 @@ Coding challenges for the flashing heart tutorial.
 
 ## Before we get started
 
-Complete the [flashing heart](/microbit/lessons/flashing-heart/activity) activity and your code will look like this:
+Complete the [flashing heart](/lessons/flashing-heart/activity) activity and your code will look like this:
 
 ```blocks
 basic.forever(() => {
@@ -25,8 +25,6 @@ basic.forever(() => {
 
 ### Challenge 1
 
-### @video td/videos/flashing-heart-1
-
 Let's plot a different image. Let's display a broken heart!
 
 To do this, you need to add a block between the last line and the end loop. Add a `show LEDs` block and then add a `pause` of 500 milliseconds.
@@ -60,8 +58,6 @@ basic.forever(() => {
 
 ### Challenge 2
 
-### @video td/videos/flashing-heart-2
-
 Now let's alternate flashing the heart and the broken heart. To do this, we need to add a `clear screen` block and then add a `pause` block of 500 milliseconds under the new code we added in Challenge 1.
 
 

docs/lessons/flashing-heart/quiz-answers.md

@@ -2,7 +2,7 @@
 
 Learn how to create an image with a variable. 
 
-This is the answer key for the [flashing heart quiz](/microbit/lessons/flashing-heart/quiz).
+This is the answer key for the [flashing heart quiz](/lessons/flashing-heart/quiz).
 
 ## 1. Describe what pause does 
 
@@ -10,13 +10,15 @@ Pause program execution for the specified number of milliseconds.
 
 ## 2. Write the code that leaves an image on the screen for 1 second (1000 milliseconds) 
 
-<br/>
 
-![](/static/mb/blocks/lessons/flashing-heart-5.jpg)
+```blocks
+basic.pause(1000)
+```
 
 ## 3. Write the code that leaves an image on the screen for 1.5 seconds (1500 milliseconds) 
 
-![](/static/mb/blocks/lessons/flashing-heart-6.jpg)
+```blocks
+basic.pause(1500)
+```
 
-<br/>
 

docs/lessons/flashing-heart/quiz.md

@@ -6,25 +6,20 @@ Learn how to create a blinking image with a variable.
 
 ## Directions
 
-Use this activity document to guide your work in the [flashing heart activity](/microbit/lessons/flashing-heart/activity).
+Use this activity document to guide your work in the [flashing heart activity](/lessons/flashing-heart/activity).
 
 Answer the questions while completing the activity. Pay attention to the dialogues!
 
 ## 1. Describe what `pause` does?
 
-<br/>
 
-<br/>
 
 ## 2. Write the code that leaves an image on the screen for 1 second (1000 milliseconds) 
 
-<br/>
 
-<br/>
+
 
 ## 3. Write the code that leaves an image on the screen for 1.5 seconds (1500 milliseconds)
 
-<br/>
 
-<br/>