0.2.161

will move select lessons back to "educators" section

.gitignore

@@ -1,9 +1,11 @@
 node_modules
+yotta_modules
+yotta_targets
 built
 typings
 tmp
 temp
-projects
+projects/**
 win10/app/bin
 win10/app/bld
 win10/*.opendb

README.md

@@ -1,26 +1,52 @@
 # micro:bit target for PXT
 
 This target allow to program a [BBC micro:bit](https://www.microbit.co.uk/) using 
-[Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt).
+PXT ([Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt)).
 
 * [Try it live](https://m.pxt.io)
 
 [![Build Status](https://travis-ci.org/Microsoft/pxt-microbit.svg?branch=master)](https://travis-ci.org/Microsoft/pxt-microbit)
 
-# Getting started
+## Local server
 
-Please follow instructions at https://github.com/Microsoft/pxt#running-a-target-from-localhost 
+### 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
+```
+
+### Running
+
+Run this command to open a local web server (add ``sudo`` for Mac/Linux shells)
+```
+pxt 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
+```
+
+To make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
+```
+pxt update
+```
+
+More instructions at https://github.com/Microsoft/pxt#running-a-target-from-localhost 
 
 ## Universal Windows App
 
 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.
-
-### Sideloading
-
-* Open Windows **settings** and search for **Developer options**
-* Enable the developer mode.
-* Find the latest build under ``win10/app/AppPackages/latest`` and run the ``Add-AppDevPackage.ps1`` PowerShell script (mouse right-click, then `run with PowerShell`)
+that wraps ``m.pxt.io`` and provides additional features.
 
 ### Building
 

cmds/cmds.ts

@@ -1,8 +1,8 @@
 /// <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)
@@ -13,10 +13,10 @@ export function deployCoreAsync(res: ts.pxt.CompileResult) {
             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)
                     }))

cmds/tsconfig.json

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

docs/about.md

@@ -26,20 +26,20 @@ input.onButtonPressed(Button.B, () => {
 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).
 
-The micro:bit provides a fun introduction to programming and making – switch on, program it to do something fun – wear it, customize it.
+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. 
 
 ## Blocks or JavaScript
 
-The student can program the BBC micro:bit using [visual blocks](http://www.github.com/Google/blockly) or JavaScript.
+The student can program the BBC micro:bit using Blocks or JavaScript.
 
 ```blocks
-basic.showString("BBC micro:bit!");
+basic.showString("Hi!");
 ```
 
 ## 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.
+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 the ARM thumb machine code happens in the browser.
 
@@ -47,6 +47,7 @@ The student is prompted to save the ARM binary program to a file, which she then
 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.
 
@@ -54,5 +55,10 @@ The simulator has support for the LED screen, buttons, as well as compass, accel
 
 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 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
+
+```namspaces
+for (let i = 0;i<5;++i) {}
+if (true){}
+let x = 0;
+Math.random(5);
+```

docs/device.md

@@ -15,12 +15,14 @@ It flashes yellow when the system wants to tell the user that something has happ
 ### Buttons
 
 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 and un-pressed and be programmed 
-to act on that or send the information to another device.
+The micro:bit can detect either of its two buttons being pressed/released and be programmed 
+to act on these events.
 
 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.**
@@ -43,7 +45,7 @@ This data can be used by the micro:bit in a program or be sent to another device
 
 ### Accelerometer
 
-There is a an accelerometer on your micro:bit which detects changes in the micro:bit’s speed. 
+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.
 
@@ -63,7 +65,7 @@ and about the error messages you might get [here](/device/error-codes).
 
 ### Powering your 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 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. 
@@ -75,7 +77,7 @@ The BBC micro:bit can send an receive data via [serial communication](/device/se
 
 ### Bluetooth Low Energy (BLE) Antenna
 
-You will see the label BLE ANNTENA on the back of your micro:bit. It is for a messaging service, 
+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 

docs/device/contents.md

@@ -1,7 +1,5 @@
 # micro:bit - the device
 
-The micro:bit device #docs
-
 The micro:bit is a very capable device with many components:
 
 * [the USB connector](/device/usb)

docs/device/crocodile-clips.md

@@ -11,12 +11,6 @@ This example displays a random number every time the crocodile clip holds  `GND`
 
 ### Connecting Crocodile Clips
 
-
-
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [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.
 

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?

docs/device/screen.md

@@ -3,40 +3,61 @@
 The micro:bit LED screen 
 
 ```sim
-basic.showString(" ");
+    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](/reference/led/plot) and [unplot](/reference/led/unplot) to turn a LED on or off
 
 ```blocks
-led.plot(0,0)
-led.unplot(0,0)
+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?

docs/device/serial.md

@@ -11,16 +11,35 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
+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
-* Install a terminal emulator; we recommend [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.
+
+#### 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.
 
@@ -32,7 +51,7 @@ You should be good. Feel free to hit `Setup` > `Save Setup` in the menus to eras
 
 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.
 
-### Alternative Windows setup with Putty
+#### Windows > Putty
 
 If you prefer another terminal emulator (such as [PuTTY](http://www.putty.org/)), here are some instructions.
 

docs/docs.md

@@ -1,8 +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(`
+. # . # .
+# . # . #
+# . . . #
+. # . # .
+. . # . .`);
+});
+``` 
 
+* **[getting started](/getting-started)**
+* Get started with [projects](/projects)
 * Browse the [API reference](/reference)
 * Learn more about the [device](/device)
-* Get started with [lessons](/lessons)
-* Learn about [libraries](/libraries) (possibly using C++)
+* 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. Unscramble 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).
+They should 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/banana-keyboard.md

@@ -1,21 +0,0 @@
-# banana keyboard blocks lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/lessons/banana-keyboard/activity)
-
-## 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/hack-your-headphones.md

@@ -1,20 +0,0 @@
-# hack your headphones lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Hack your headphone
-
-## Quick Links
-
-* [activity](/lessons/hack-your-headphones/activity)
-
-## 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, headphones (or speakers), as well as crocodile clips (or spring clips).
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with headphones to play music
-

docs/lessons/light-beatbox.md

@@ -1,21 +0,0 @@
-# light beatbox 
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Music
-
-## Quick Links
-
-* [activity](/lessons/light-beatbox/activity)
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to make a light beatbox music player using the light sensor. We will be learning how to code musical notes using light level, a local variable, conditionals, on button pressed as well as simple commands such as ring tone and rest.
-
-## Objectives
-
-* learn how to control the light sensor on the BBC micro:bit
-* learn how to code music on the BBC micro:bit
-

docs/lessons/rock-paper-scissors.md

@@ -1,64 +0,0 @@
-# rock paper scissors lesson
-
-a game against the BBC micro:bit.
-
-### @video td/videos/rock-paper-scissors-0
-
-## Topic
-
-Local Variables
-
-## Quick Links
-
-* [activity](/lessons/rock-paper-scissors/activity)
-* [challenges](/lessons/rock-paper-scissors/challenges)
-
-## Class
-
-Year 7
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to create a **local variable**, `var t :=time` where you can store data, so that you can use it in your code. We will be learning how to create a classic rock paper scissors game using global variables, input on shake, local variables, math random as well as simple commands such as create image, show image, show string, and show number.
-
-## Documentation
-
-```cards
-input.onGesture(Gesture.Shake, () => {})
-Math.random(3)
-let x = 0
-basic.showLeds(`
-    . . . . .
-    . . . . .
-    . . # . .
-    . . . . .
-    . . . . .
-    `)
-```
-
-## Objectives
-
-* learn how to create a condition so the micro:bit will run code when it is shaken
-* learn how to create a local variable for a place where you can store data
-* learn how to create an image to show on the micro:bit's LED screen
-* learn how to show an image on the micro:bit's LED screen
-
-## 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)
-*  Declares and assigns variables(AB)
-* Selects the appropriate data types(AL) (AB
-
-#### Data & Data Representation
-
-* Defines data types: real numbers and Boolean (AB)
-
-Computational Thinking Concept: AB = Abstraction; DE = Decomposition; AL = Algorithmic Thinking; EV = Evaluation; GE = Generalisation
-

docs/lessons/rock-paper-scissors/activity.md

@@ -1,121 +0,0 @@
-# rock paper scissors activity
-
-A classic game against the micro:bit.
-
-### ~avatar avatar
-
-### @video td/videos/rock-paper-scissors-0
-
-Welcome! This tutorial will help you create a game of rock paper scissors with the micro:bit. Let's get started!
-
-### ~
-
-We want the micro:bit to choose rock, paper, or scissors when it is shaken. Let's begin by creating an on shake condition so the micro:bit will run code when it is shaken.
-
-
-```blocks
-
-input.onGesture(Gesture.Shake, () => {
-    
-})
-
-```
-
-Next, create a variable and store pick random number from 0 to 2.  On shake, a number will be randomly picked from 0-2. We will randomly display an image based on the random number returned.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-})
-
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is equal to 2. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    }
-})
-
-
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is equal to 1. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    }
-})
-```
-
-The micro:bit will look like it's showing 1 frame of the image by displaying the whole image when pick random is not equal to 2 and not equal to 1. We can help the micro:bit randomly decide which image to use by pick random. The micro:bit will randomly pick the image to display with show LEDs and the pick random function.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-
-```
-
-### ~avatar avatar
-
-Excellent, you're ready to continue with the [challenges](/lessons/rock-paper-scissors/challenges)!
-
-### ~
-

docs/lessons/rock-paper-scissors/challenges.md

@@ -1,133 +0,0 @@
-# rock paper scissors challenges
-
-Coding challenges for rock paper scissors. 
-
-## Before we get started
-
-Complete the following [guided activity](/lessons/rock-paper-scissors/activity) , your code should look like this:
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(3)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-
-```
-
-### Challenge 1
-
-When the A button is pressed, increment the score by 1. You can select Game drawer then add change score by 1.
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(2)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-input.onButtonPressed(Button.A, () => {
-    game.addScore(1)
-})
-
-```
-
-* Click *run* to execute your code in the simulator
-
-### Challenge 2
-
-After incrementing the score, display the total number of wins you have.
-
-
-```blocks
-input.onGesture(Gesture.Shake, () => {
-    let img = Math.random(2)
-    if (img == 2) {
-        basic.showLeds(`
-            # # # # #
-            # . . . #
-            # . . . #
-            # . . . #
-            # # # # #
-            `)
-
-    } else if (img == 1) {
-        basic.showLeds(`
-            . . . . .
-            . # # # .
-            . # # # .
-            . # # # .
-            . . . . .
-            `)
-    } else {
-        basic.showLeds(`
-            . . . # #
-            # # . # .
-            . . # . .
-            # # . # .
-            . . . # #
-            `)
-    }
-})
-input.onButtonPressed(Button.A, () => {
-    game.addScore(1)
-    basic.showString("WINS:")
-    basic.showNumber(game.score())
-})
-
-```
-
-* Run and compile the code to see if it works as expected.
-
-### Challenge 3
-
-You have successfully tracked and displayed the number of wins on the micro:bit! However, what about losses? Use the Game drawer to change score by -1 when button `B` is pressed.
-
-* Run and compile the code to see if it works as expected.

docs/lessons/rock-paper-scissors/quiz.md

@@ -1,74 +0,0 @@
-# rock paper scissors quiz
-
-shift an image horizontally across the display with offset.
-
-## Name
-
-## Directions
-
-Use this activity document to guide your work in the [rock paper scissors tutorial](/lessons/rock-paper-scissors/activity).
-
-Answer the questions while completing the tutorial. Pay attention to the dialogues!
-
-## 1. Describe what `offset` does? 
-
-<br/>
-
-## 2. Draw which LEDs are ON after running this code and the random number returned is 0
-
-```blocks
-let img = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-
-<br/>
-
-## 3. Draw which LEDs are ON after running this code with an offset of 5. This would occur if the random number returned is 1.
-
-```blocks
-let img_ = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset_ = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-
-<br/>
-
-## 4. Draw which LEDs are ON after running this code with an offset of 10. This would occur if the random number returned is 2.
-
-```blocks
-let img_1 = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-let offset_1 = Math.random(3) * 5
-img.showImage(offset)
-```
-
-![](/static/mb/lessons/night-light-2.png)
-
-<br/>
-

docs/lessons/seismograph/activity.md

@@ -1,150 +0,0 @@
-# Seismograph Activity 
-
-### ~avatar avatar
-
-In this project, you will build your own seismograph. 
-
-## What you'll need: 
-
-* micro:bit 
-* USB cable
-* Scissors
-* Glue gun
-* String
-* Cup (Plastic or Paper)
-* Magnet
-
-Welcome! This activity will teach how to use the micro:bit to chart the strength of the acceleration. Let's get started!
-
-1. Setup Cup: Use scissors to cut a usable window on the cup, which will be a square sized hole at the lid side of the cup. Use scissors to create a small hole in the center of the base of the cup. 
-
-2. Fasten Magnet: Fasten end of the string to the magnet with glue
-
-3. Secure String: Fasten string to base of the cup and hang the remaining string outside the base of the cup. 
-
-### ~avatar avatar
-
-Seismograph built, let's code! 
-
-### ~
-
-4. Go to Codemicrobit.com
-
-    Click or tap Create Code
-    Click or tap Block Editor
-    
-### ~
-
-5. 
-
-We will measure `acceleration (mg)` in terms of strength. Get the acceleration value (milli g-force), as measured in strength.
-
-```blocks
-input.acceleration(Dimension.Strength);
-```
-
-### ~
-
-6. 
-
-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 based on strength. 
-
-```blocks
-basic.forever(() => {
-    led.plotBarGraph(input.acceleration(Dimension.Strength), 0);
-});
-
-```
-
-### ~
-
-7. 
-
-Finally, we subtract the gravity from acceleration strength. 
-
-```blocks
-basic.forever(() => {
-    led.plotBarGraph(input.acceleration(Dimension.Strength) - 1023, 0);
-});
-
-```
-
-### ~
-
-8. 
-
-Notice that making vibrating the object below the micro:bit changes the values and the line appears as a wave to display the value of the strength as measured in milli-gravities. By making the object below the micro:bit vibrate, you will observe changing values of the micro:bit. Also, the LEDs shown on the Bar Graph fluctates based on the movement of the micro:bit strength. 
-
-NOTE: The black color reflects the micro:bit device. 
-
-![](/static/mb/data4.png)
-
-
-### ~
-
-9. 
- 
-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. 
-
-
-### ~
-
-10. 
-
-We want to chart the data collected by using a tool in Excel. 
-
-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. 
-
-
-### ~
-
-10. 
-
-
-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.
-
-### ~
-
-11. 
-
-
-![](/static/mb/chart1.png)
-
-* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data.
-
-Click any chart type to see how your data will look in that format. 
-
-When you find the chart type that you want, click it, and then click OK. We want to select the chart called Line. A line chart is used to display trends over time. We will use the line chart because there are many data points over time. 
-
-Tip: If you don’t see a chart type that you want, click the All Charts tab to see all of the available chart types.
-
-### ~
-
-12. 
-
-![](/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
-
-### ~
-
-13. 
-
-![](/static/mb/elements_styles_filters.png)
-
-* Connect a micro:bit to your computer using your USB cable; compile; and repeat this experiment by vibrating the micro:bit. Then chart the data on Excel. 
-
-### ~avatar avatar
-
-Excellent, you're ready to continue with the [challenges](/lessons/seismograph/challenge)
-
-### ~
-

docs/lessons/telegraph.md

@@ -1,23 +0,0 @@
-# telegraph lesson
-
-display beautiful images on the BBC micro:bit.
-
-## Topic
-
-Telegraph
-
-## Quick Links
-
-* [activity](/lessons/telegraph/activity)
-* [challenges](/lessons/telegraph/challenges)
-
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to convert your BBC micro:bit into a telegraph using a second BBC micro:bit as well as pin P1, P2, 3V, GND, and crocodile clips (or spring clips). The connect BBC micro:bit uses pins P1, P2, 3V, GND.
-
-## Objectives
-
-* learn how to setup the BBC micro:bit with crocodile clips
-* learn how to telegraph to another BBC micro:bit
-

docs/lessons/the-watch.md

@@ -1,23 +0,0 @@
-# the watch lesson
-
-display beautiful images on the BBC micro:bit.
-
-![](/static/mb/lessons/the-watch-0.png)
-
-## Topic
-
-The Watch
-
-## Quick Links
-
-* [activity](/lessons/the-watch/activity)
-
-
-
-## Prior learning/place of lesson in scheme of work
-
-Learn how to design the BBC micro:bit watch with household supplies.
-
-## Objectives
-
-* learn how to design and make the watch with the BBC micro:bit

docs/libraries.md

@@ -1,14 +0,0 @@
-# Extensions
-
-You can publish libraries (also known as packages or extensions)
-that users can then add to their scripts. These typically
-provide a driver for a particular hardware device you can connect
-to a microbit.
-
-* [Sample C++ extension](https://github.com/Microsoft/pxt-microbit-cppsample)
-* [Sample TypeScript extension](https://github.com/Microsoft/pxt-microbit/tree/master/libs/i2c-fram)
-
-## Finding libraries
-
-## Publishing libraries
-

docs/microbit-reference.md

@@ -1,23 +0,0 @@
-# microbit Reference
-
-```namespaces
-basic.showNumber(0);
-input.onButtonPressed(Button.A, () => {
-    
-});
-led.plot(0, 0);
-music.playTone(0, 0);
-game.addScore(1);
-images.createImage(`
-. . . . .
-. . . . .
-. . # . .
-. . . . .
-. . . . .
-`);
-pins.digitalReadPin(DigitalPin.P0);
-serial.writeValue(x, 0);
-control.inBackground(() => {
-    
-});
-```

docs/open-source.md

@@ -0,0 +1,9 @@
+# Open Source
+
+The editor is open source on GitHub under the MIT license. Contributions are welcome, please check our GitHub repos.
+
+### Repos
+
+* [microsoft/pxt-microbit](https://github.com/Microsoft/pxt-microbit), PXT target for BBC micro:bit, also includes the documentation.
+* [microbit/pxt](https://github.com/Microsoft/pxt), programming experience toolkit (PXT)
+* [microsoft/pxt-microbit-core](https://github.com/Microsoft/pxt-microbit-core), Yotta module used to build the BBC micro:bit runtime

docs/packages.md

@@ -0,0 +1,48 @@
+# Extensions
+
+You can publish libraries (also known as packages or extensions)
+that users can then add to their scripts. These typically
+provide a driver for a particular hardware device you can connect
+to a microbit.
+
+* [Sample C++ extension](https://github.com/Microsoft/pxt-microbit-cppsample)
+* [Sample TypeScript extension](https://github.com/Microsoft/pxt-microbit/tree/master/libs/i2c-fram)
+
+## Finding libraries
+
+From the editor, the user clicks on **More** then **Add Package** and searches for the package. 
+
+To see the list of packages, click on **More** then **Show Files** to see the project file list.
+
+To remove a package, click on the garbage button in the file list next to the package.
+
+## Publishing libraries
+
+Packages can be published from the pxt command line. We are still sorting out the details.
+
+## Localizing libraries
+
+It is possible to package localization strings for the **jsDoc** description associated to the API in the package.
+
+When compiling a package, the PXT compiler generates a `strings.json` file under the `_locales/` folder. 
+This file contains a map from the symbol name to the en
+
+```
+{
+  ...
+  "basic": "Provides access to basic micro:bit functionality.",
+   ...
+}
+```
+
+```
+{
+  "basic.clearScreen": "Eteint toutes les diodes."
+}
+```
+
+```
+_locales/
+_locales/fr/strings.json
+_locales/pt-BR/strings.json
+```

docs/projects.md

@@ -0,0 +1,46 @@
+# Projects
+
+![](/static/mb/projects/all10.png)
+
+## [Flashing Heart](/projects/flashing-heart)
+
+![](/static/mb/projects/a1-display.png)
+
+## [Smiley Buttons](/projects/smiley-buttons)
+
+![](/static/mb/projects/a2-buttons.png)
+
+## [Love Meter](/projects/love-meter)
+
+![](/static/mb/projects/a3-pins.png)
+
+## [Rock Paper Scissors](/projects/rock-paper-scissors)
+
+![](/static/mb/projects/a4-motion.png)
+
+## [Compass](/projects/compass)
+
+![](/static/mb/projects/a5-compass.png)
+
+## [Hack your headphones](/projects/hack-your-headphones)
+
+![](/static/mb/projects/a6-music.png)
+
+## [Banana keyboard](/projects/banana-keyboard)
+
+![](/static/mb/projects/a7-conductive.png)
+
+## [Telegraph](/projects/telegraph)
+
+![](/static/mb/projects/a8-network.png)
+
+## [Radio](/projects/radio)
+
+![](/static/mb/projects/a9-radio.png)
+
+## [Watch](/projects/the-watch)
+
+![](/static/mb/projects/a10-watch.png)
+
+
+

docs/projects/banana-keyboard.md

@@ -95,6 +95,6 @@ Tap your banana instrument to play sound against... the fruit!
 
 ### ~avatar boothing
 
-Excellent, you're ready to continue with the [challenges](/lessons/banana-keyboard/challenges)!
+Excellent, you're ready to continue with the [challenges](/banana-keyboard-challenges)!
 
 ### ~

docs/projects/compass.md

@@ -0,0 +1,112 @@
+# compass
+
+![](/static/mb/projects/a5-compass.png)
+
+Display the direction that the micro:bit is facing using the compass 
+
+### ~avatar avatar
+
+Welcome! This guided tutorial will show you how to program a script that displays the direction the micro:bit is pointing. Let's get started!
+
+### ~
+
+
+## Step 1
+
+Create a loop that will continuously update the reading of the compass.
+
+
+```blocks
+basic.forever(() => {
+    
+})
+```
+
+## Step 2
+
+Store the reading of the micro:bit in a variable called `degrees`.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading()
+})
+```
+
+## Step 3
+
+If `degrees` is less than `45`, then the compass heading is mostly pointing toward North. Display `N` on the micro:bit.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+});
+```
+
+## Step 4
+
+If `degrees` is less than 135, the micro:bit is mostly pointing East. Display `E` on the micro:bit.
+
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+});
+```
+
+## Step 5
+
+If `degrees` is less than 225, the micro:bit is mostly pointing South. Display `S` on the micro:bit.
+
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+    else if (degrees < 225) {
+        basic.showString("S");
+    }
+});
+```
+
+## Step 6
+
+If none of these conditions returned true, then the micro:bit must be pointing West. Display `W` on the micro:bit.
+
+```blocks
+basic.forever(() => {
+    let degrees = input.compassHeading();
+    if (degrees < 45) {
+        basic.showString("N");
+    }
+    else if (degrees < 135) {
+        basic.showString("E");
+    }
+    else if (degrees < 225) {
+        basic.showString("S");
+    }
+    else {
+        basic.showString("W");
+    }
+});
+```
+
+### ~avatar avatar
+
+Excellent, you're ready to continue with the [challenges](/lessons/compass/challenges)!
+
+### ~
+

docs/projects/flashing-heart.md

@@ -0,0 +1,117 @@
+# flashing heart
+
+![](/static/mb/projects/a1-display.png)
+
+### ~avatar avatar
+
+```sim
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```
+
+Use the LEDs to display a flashing heart, and then create
+an animation of a broken heart. :(
+
+## [START PROJECT](/#follow:/projects/flashing-heart)
+
+### ~
+
+## Step 1
+
+Use [show leds](/reference/basic/showLeds) and make your code look like this:
+
+```blocks
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+```
+
+## Step 2
+
+Add a [pause](/reference/basic/pause) to wait and [clear screen](/reference/basic/clearScreen) to turn off the LEDs.
+
+```blocks
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+```
+
+## Step 3
+
+Put a [forever loop](/reference/basic/forever) around it.
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+})
+```
+
+## Step 4
+
+Add a [pause](/reference/basic/pause) to wait after clearing the screen.
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```
+
+## Step 5
+
+Add a second image of a broken heart. 
+
+
+```blocks
+basic.forever(() => {
+basic.showLeds(`
+. # . # .
+# # # # #
+# # # # #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+basic.showLeds(`
+. # . # .
+# . # # #
+# . . . #
+. # # # .
+. . # . .`);
+basic.pause(500);
+basic.clearScreen();
+basic.pause(500);
+})
+```

docs/projects/hack-your-headphones-challenges.md

@@ -1,4 +1,4 @@
-# light beatbox activity
+# hack your headphones challenges
 
 Control sound with the light level. 
 
@@ -71,10 +71,3 @@ input.onButtonPressed(Button.A, () => {
 
 * click *compile* and run your code on the micro:bit.
 
-
-### ~avatar avatar
-
-Excellent, you're ready to continue by connecting your headphones with these [challenges](/lessons/hack-your-headphones/activity)!
-
-### ~
-

docs/projects/hack-your-headphones.md

@@ -1,4 +1,4 @@
-# hack your headphones activity 
+# hack your headphones 
 
 Hack your headphones
 
@@ -52,10 +52,10 @@ You hacked your headphones!
 
 ### Step 6
 
-Connect your micro:bit to your computer using your USB cable and program  [light beatbox](/lessons/light-beatbox/activity) music on it. Press the reset button to restart your music player!
+Connect your micro:bit to your computer using your USB cable and program  [light beatbox](/projects/hack-your-headphones-challenges) music on it. Press the reset button to restart your music player!
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/light-beatbox/activity)!
+Excellent, you're ready to continue with the [challenges](/projects/hack-your-headphones-challenges)!
 
 ### ~

docs/projects/love-meter.md

@@ -0,0 +1,50 @@
+# love meter
+
+![](/static/mb/projects/a3-pins.png)
+
+Use pins P0, P1 and P2 to change the display by creating a circuit with your body.
+
+## Step 1
+
+Use [on pin pressed](/reference/input/on-pin-pressed) to show a random number
+when pin P0 is pressed (hold the GND pin with other hand):
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+```
+## Step 2
+
+Show a string when pin P1 is pressed:
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+input.onPinPressed(TouchPin.P1, () => {
+    basic.showString("LOVE?");
+});
+```
+
+## Step 3
+
+Show a heart when pin P2 is pressed:
+
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(11));
+});
+input.onPinPressed(TouchPin.P1, () => {
+    basic.showString("LOVE?");
+});
+input.onPinPressed(TouchPin.P2, () => {
+    basic.showLeds(`
+        . # # # .
+        # # # # #
+        # # # # #
+        . # # # .
+        . . # . .
+        `);
+});
+```

docs/projects/radio-challenges.md

@@ -2,7 +2,8 @@
 
 ### ~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!
+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.
@@ -52,7 +53,7 @@ Notice that moving the micro:bit the farthest direction in the x direction will
 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 simulatation 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. 
+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)
 
@@ -67,15 +68,9 @@ Use the Recommended Charts command on the Insert tab to quickly create a chart t
 
 * Click Insert > Recommended Charts.
 
-![](/static/mb/chart1.png)
+![](/static/mb/lessons/chart1.png)
 
-* On the Recommended Charts tab, scroll through the list of chart types that Excel recommends for your data.
-
-Click any chart type to see how your data will look in that format. 
-
-When you find the chart type that you want, click it, and then click OK. We want to select the chart called Line. A line chart is used to display trends over time. We will use the line chart because there are many data points over time. 
-
-Tip: If you don’t see a chart type that you want, click the All Charts tab to see all of the available chart types.
+* 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)
 
@@ -91,4 +86,3 @@ Have fun reviewing your simulation and analyze the acceleration by chart the Exc
 * 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/projects/radio.md

@@ -0,0 +1,68 @@
+# radio 
+
+Measure the acceleration on the micro:bit in the "x" direction. 
+
+### ~avatar avatar
+
+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. 
+
+### ~
+
+We want to chart the data collected by using a tool in Excel. 
+
+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. 
+
+
+### ~
+
+
+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](/projects/radio-challenges)
+
+### ~
+

docs/projects/rock-paper-scissors.md

@@ -0,0 +1,239 @@
+# rock paper scissors
+
+![](/static/mb/projects/a4-motion.png)
+
+### ~avatar avatar
+
+```sim
+input.onGesture(Gesture.Shake, () => {
+    let img = Math.random(3)
+    if (img == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (img == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+        basic.showLeds(`
+            # # . . #
+            # # . # .
+            . . # . .
+            # # . # .
+            # # . . #
+            `)
+    }
+})
+```
+In this project, you will 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.
+
+## [START PROJECT](/#follow:/projects/rock-paper-scissors)
+
+### ~
+
+
+## Materials needed
+
+* Your BBC micro:bit -- that's it!
+
+## 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.
+
+```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 `weapon`. (This variable is named `weapon` because 
+rock, paper, and scissors are the weapons you use to battle your friends!)
+
+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 weapon = 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
+`weapon` 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 weapon = Math.random(3)
+    if (weapon == 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 `weapon` is `1`.
+Then add a ``show leds`` block with a picture of a rock.
+
+```blocks
+input.onGesture(Gesture.Shake, () => {
+    let weapon = Math.random(3)
+    if (weapon == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (weapon == 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 weapon = Math.random(3)
+    if (weapon == 0) {
+        basic.showLeds(`
+            # # # # #
+            # . . . #
+            # . . . #
+            # . . . #
+            # # # # #
+            `)
+
+    } else if (weapon == 1) {
+        basic.showLeds(`
+            . . . . .
+            . # # # .
+            . # # # .
+            . # # # .
+            . . . . .
+            `)
+    } else {
+        basic.showLeds(`
+            # # . . #
+            # # . # .
+            . . # . .
+            # # . # .
+            # # . . #
+            `)
+    }
+})
+
+```
+
+### ~hint
+
+You don't need to check if `weapon` 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! 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())
+})
+```
+
+## Step 8: Hacking Rock Paper Scissors
+
+How else can you make your game better?
+Ever hear of [Rock Paper Scissors Spock Lizard](http://www.samkass.com/theories/RPSSL.html)?

docs/projects/smiley-buttons.md

@@ -0,0 +1,69 @@
+# smiley buttons
+
+![](/static/mb/projects/a2-buttons.png)
+
+Use buttons to show a smiley or frowny face. 
+
+## Step 1
+
+Use [show leds](/reference/basic/showLeds) to make a smiley face:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+```
+
+## Step 2
+
+Add an input block for when [button A is pressed](/reference/input/button-is-pressed), and put a
+frowny face inside it:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+input.onButtonPressed(Button.A, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    . # # # .
+    # . . . #`);
+});
+```
+
+## Step 3
+
+Now add blocks so that when [button B is pressed](/reference/input/button-is-pressed), a smiley appears:
+
+```blocks
+basic.showLeds(`
+. # . # .
+. # . # .
+. . . . .
+# . . . #
+. # # # .`);
+input.onButtonPressed(Button.A, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    . # # # .
+    # . . . #`);
+});
+input.onButtonPressed(Button.B, () => { 
+    basic.showLeds(`
+    . # . # .
+    . # . # .
+    . . . . .
+    # . . . #
+    . # # # .`);
+});
+```

docs/projects/telegraph.md

@@ -70,6 +70,6 @@ Using the 4th crocodile clip, connect the unattached end of the crocodile clip o
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/telegraph/challenges)!
+Excellent, you're ready to continue with the [challenges](/projects/telegraph-challenges)!
 
 ### ~

docs/projects/the-watch.md

@@ -1,8 +1,6 @@
-# The watch activity
+![](/static/mb/projects/a10-watch.png)
 
-Control images with variables. 
-
-# micro:bit watch
+# the watch
 
 ![](/static/mb/lessons/the-watch-0.png)
 
@@ -152,7 +150,7 @@ Your watch is ready!
 
 ### ~avatar avatar
 
-Excellent, you're ready to continue with the [challenges](/lessons/rock-paper-scissors/activity)!
+Excellent, you're ready to continue with the [challenges](/projects/rock-paper-scissors)!
 
 ### ~
 

docs/reference.md

@@ -1,16 +1,13 @@
 # Reference
 
 ```namespaces
-for (let i = 0;i<5;++i) {}
-if (true){}
-let x = 0;
-Math.random(5);
 basic.showNumber(0);
 input.onButtonPressed(Button.A, () => {
     
 });
-led.plot(0, 0);
 music.playTone(0, 0);
+led.plot(0, 0);
+radio.sendNumber(0);
 game.addScore(1);
 images.createImage(`
 . . . . .
@@ -20,8 +17,8 @@ images.createImage(`
 . . . . .
 `);
 pins.digitalReadPin(DigitalPin.P0);
-serial.writeValue(x, 0);
+serial.writeNumber(0);
 control.inBackground(() => {
     
 });
-```
+```

docs/reference/String.md

@@ -0,0 +1,5 @@
+# String
+
+```cards
+String.fromCharCode(0);
+```

docs/reference/basic/clear-screen.md

@@ -8,7 +8,7 @@ basic.clearScreen()
 
 ### Example: vanishing heart
 
-The following code displays a heart on the screen and then turns off all the LED lights using `clear screen`:
+The following code shows a heart on the screen and then turns off all the LED lights using `clear screen`:
 
 ```blocks
 basic.showLeds(`
@@ -21,10 +21,6 @@ basic.showLeds(`
 basic.clearScreen()
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [flashing heart](/lessons/flashing-heart), [screen wipe](/lessons/screen-wipe)
-
 ### See also
 
 [set brightness](/reference/led/set-brightness), [unplot](/reference/led/unplot), [plot](/reference/led/plot), [Image](/reference/images/image), [clear](/reference/basic/clear-screen)

docs/reference/basic/forever.md

@@ -1,6 +1,7 @@
 # Forever
 
-Repeat code [in the background](/reference/control/in-background) forever.
+Keep running part of a program 
+[in the background](/reference/control/in-background).
 
 ```sig
 basic.forever(() => {
@@ -9,7 +10,9 @@ basic.forever(() => {
 
 ### Example: compass
 
-The following example constantly checks the [compass heading](/reference/input/compass-heading) and updates the screen with the direction.
+The following example constantly checks the 
+[compass heading](/reference/input/compass-heading) 
+and updates the screen with the direction.
 
 ```blocks
 basic.forever(() => {
@@ -30,7 +33,9 @@ basic.forever(() => {
 
 ### Example: counter
 
-The following example continually shows the current value of a global variable:
+The following example keeps showing the [number](/reference/types/number) stored in a global variable.
+When you press button `A`, the number gets bigger.
+You can use a program like this to count things with your BBC micro:bit.
 
 ```blocks
 let num = 0
@@ -42,9 +47,12 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
-### Contention for the LED display
+### Competing for the LED screen
 
-If you have multiple processes that each show something on the LED screen, you may get unexpected results. Try, for example:
+If different parts of a program are each trying 
+to show something on the LED screen at the same time, 
+you may get unexpected results.
+Try this on your micro:bit:
 
 ```blocks
 basic.forever(() => {
@@ -55,10 +63,6 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [snowflake-fall](/lessons/snowflake-fall), [flashing-heart](/lessons/flashing-heart)
-
 ### See also
 
 [while](/reference/loops/while), [on button pressed](/reference/input/on-button-pressed), [in background](/reference/control/in-background)

docs/reference/basic/pause.md

@@ -1,6 +1,7 @@
 # Pause
 
-Pause program execution for the specified number of milliseconds. This function is helpful when you need to slow down your program's execution.
+Pause the program for the number of milliseconds you say. 
+You can use this function to slow your program down.
 
 ```sig
 basic.pause(400)
@@ -8,11 +9,13 @@ basic.pause(400)
 
 ### Parameters
 
-* ``ms`` - the number of milliseconds that you want to pause (100 = 1/10 second, 1000 milliseconds = 1 second)
+* ``ms`` is the number of milliseconds that you want to pause (100 milliseconds = 1/10 second, and 1000 milliseconds = 1 second).
 
 ### Example: diagonal line
 
-The following example code turns on LED `0, 0` thru `4, 4`, pausing 500 milliseconds after each LED. Without `pause`, the code would run so fast that you wouldn't see each individual LED turning on.
+This example draws a diagonal line by turning on LED `0, 0` (top left) through LED `4, 4` (bottom right). 
+The program pauses 500 milliseconds after turning on each LED. 
+Without `pause`, the program would run so fast that you would not have time to see each LED turning on.
 
 ```blocks
 for (let i = 0; i < 5; i++) {
@@ -21,10 +24,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[blink](/lessons/blink), [lucky 7](/lessons/lucky-7), [smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart)
-
 ### See also
 
 [while](/reference/loops/while), [running time](/reference/input/running-time), [for](/reference/loops/for)

docs/reference/basic/show-animation.md

@@ -1,6 +1,6 @@
 # Show Animation
 
-Show a series of image frames on the [LED screen](/device/screen), pausing the specified time after each frame.
+Show a group of image frames (pictures) one after another on the [LED screen](/device/screen). It pauses the amount of time you tell it after each frame.
 
 ```sig
 basic.showAnimation(`
@@ -14,10 +14,14 @@ basic.showAnimation(`
 
 ### Parameters
 
-* `leds` - [String](/reference/types/string); a series of LED on/off states
-* `interval` - [Number](/reference/types/number); the number of milliseconds to pause after each image frame
+* `leds` is a [String](/reference/types/string) that shows which LEDs are on and off, in groups one after another.
+* `interval` is an optional [Number](/reference/types/number). It means the number of milliseconds to pause after each image frame.
 
-### Show a series of image frames
+### Example: Animating a group of image frames
+
+In this animation, each row is 15 spaces wide because
+there are three frames in the animation, and each frame is
+five spaces wide, just like the screen on the BBC micro:bit.
 
 ```
 basic.showAnimation(`
@@ -31,13 +35,17 @@ basic.showAnimation(`
 
 ### ~hint 
 
-If the series of images appear too fast, increase the value of the *interval* parameter.
+If the animation is too fast, make `interval` bigger.
 
 ### ~
 
-### Example: animating frames
+### Example: animating frames with a pause
 
-The following example creates an image with six frames and then shows each frame o the screen, pausing 500 milliseconds after each frame:
+This example shows six frames on the screen, pausing 500 milliseconds after each frame.
+
+In this animation, each row is 30 spaces wide because
+there are six frames in the animation, and each frame is
+five spaces wide, just like the screen.
 
 ```
 basic.showAnimation(`
@@ -51,11 +59,6 @@ basic.showAnimation(`
 
 ### ~hint 
 
-Use [forever](/reference/basic/forever) to continually repeat an animation
+Use [forever](/reference/basic/forever) to show an animation over and over.
 
 ### ~
-
-### Lessons
-
-[smiley](/lessons/smiley), [snowflake fall](/lessons/snowflake-fall), [rotation animation](/lessons/rotation-animation)
-

docs/reference/basic/show-leds.md

@@ -1,6 +1,6 @@
 # Show LEDs
 
-Display an image on the BBC micro:bit's [LED screen](/device/screen).
+Shows a picture on the [LED screen](/device/screen).
 
 ```sig
 basic.showLeds(`
@@ -15,12 +15,13 @@ basic.showLeds(`
 
 ### Parameters
 
-* ``leds`` - a series of LED on/off states that form an image (see steps below)
-* (optional) ``ms`` - [Number](/reference/types/number) - time to wait after displaying image. In blocks, ``ms`` is 400 by default.
+* `leds` is a [string](/reference/types/string) that controls which LEDs are on and off.
+* `interval` is an optional [number](/reference/types/number) that means how many milliseconds to wait after showing a picture.
+If you are programming with blocks, `interval` is set at 400 milliseconds.
 
-### Example - Block Editor
+### Example
 
-1. Open the `basic` category and select the `show leds` blocks.
+This program shows a picture with the ``show leds`` function.
 
 ```blocks
 basic.showLeds(`
@@ -33,11 +34,12 @@ basic.showLeds(`
 )
 ```
 
-In JavaScript, the led off is represented by a `.` and the led on by a `#` character.
+### ~hint
 
-### Lessons
+If you are programming in JavaScript, `#` means an LED that is turned
+on and `.` means an LED that is turned off.
 
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
+### ~
 
 ### See also
 

docs/reference/basic/show-number.md

@@ -1,6 +1,6 @@
 # Show Number
 
-Show a number on the [LED screen](/device/screen), one digit at a time (scrolling from left to right)
+Show a number on the [LED screen](/device/screen). It will slide left if it has more than one digit.
 
 ~~~~sig
 basic.showNumber(2, 150)
@@ -8,18 +8,18 @@ basic.showNumber(2, 150)
 
 ### Parameters
 
-* value - a [Number](/reference/types/number)
-* (optional) interval (ms) - [Number](/reference/types/number); the time (in milliseconds) before scrolling by one LED; the larger the number, the slower the scroll
+* `value` is a [Number](/reference/types/number).
+* `interval` is an optional [Number](/reference/types/number). It means the number of milliseconds before sliding the `value` left by one LED each time. Bigger intervals make the sliding slower.
 
-### ~
+### Examples:
 
-To display the number 10:
+To show the number 10:
 
 ~~~~blocks
 basic.showNumber(10)
 ~~~~
 
-To display the number stored in the `x` variable:
+To show the number stored in a variable:
 
 ~~~~blocks
 let x = 1
@@ -28,23 +28,19 @@ basic.showNumber(x)
 
 ### Example: count to 5
 
-This example uses a [for](/reference/loops/for) loop to show numbers ``1`` through ``5`` on the screen:
+This example uses a [for](/reference/loops/for) loop to show numbers ``0`` through ``5`` on the screen:
 
 ~~~~blocks
-for (let i = 0; i < 5; i++) {
-    basic.showNumber(i + 1)
+for (let i = 0; i < 6; i++) {
+    basic.showNumber(i)
     basic.pause(200)
 }
 ~~~~
 
 ### Other show functions
 
-* use [show string](/reference/basic/show-string) to show a string on the screen
-* use [show animation](/reference/basic/show-animation) to show a series of images on the screen
-
-### Lessons
-
-* [lucky 7](/lessons/lucky-7)
+* Use [show string](/reference/basic/show-string) to show a [String](/reference/types/string) with letters on the screen.
+* Use [show animation](/reference/basic/show-animation) to show a group of pictures on the screen, one after another.
 
 ### See also
 

docs/reference/basic/show-string.md

@@ -1,6 +1,6 @@
 # Show String
 
-Show a string on the [LED screen](/device/screen) one character at a time (scrolling from left to right).
+Show a number on the [LED screen](/device/screen). It will slide left if it is bigger than the screen.
 
 ```sig
 basic.showString("Hello!")
@@ -8,18 +8,18 @@ basic.showString("Hello!")
 
 ### Parameters
 
-* `text` - a [String](/reference/types/string)
-* (optional) `ms` - [Number](/reference/types/number); the time (in milliseconds) before scrolling left by one LED; the larger the number, the slower the scroll
+* `text` is a [String](/reference/types/string). It can contain letters, numbers, and punctuation.
+* `ms` is an optional [Number](/reference/types/number). It means the number of milliseconds before sliding the [String](/reference/types/string) left by one LED each time. Bigger intervals make the sliding slower.
 
 ### Examples:
 
-To display Hello:
+To show the word **Hello**:
 
 ```blocks
 basic.showString("Hello")
 ```
 
-To display the content of a string variable:
+To show what is stored in a [String](/reference/types/string) variable:
 
 ```blocks
 let s = "Hi"
@@ -28,12 +28,8 @@ basic.showString(s)
 
 ### Other show functions
 
-* use [show number](/reference/basic/show-number) to show a number on the screen
-* use [show animation](/reference/basic/show-animation) to show a series of images on the screen
-
-### Lessons
-
-[answering machine](/lessons/answering-machine), [rock paper scissors](/lessons/rock-paper-scissors), [love meter](/lessons/love-meter)
+* Use [show number](/reference/basic/show-number) to show a number on the [LED screen](/device/screen).
+* Use [show animation](/reference/basic/show-animation) to show a group of pictures on the screen, one after another.
 
 ### See also
 

docs/reference/game/change-score-by.md

@@ -24,8 +24,3 @@ export function addScore(points: number)
 ```
 export function score() : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance), [game counter](/lessons/game-counter)
-

docs/reference/game/change.md

@@ -19,8 +19,3 @@ Sprite will change the y position by this number
 ```
 export function changeYBy(_this: micro_bitSprites.LedSprite, y: number)
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/game-library.md

@@ -1,18 +1,10 @@
 # Game Library
 
-The game library #docs
-
 The game library supports simple single-player time-based games. The player has a **sprite**, number of **lives** and a **score**. The game has a sprite, number of **levels** and a **countdown clock**.  The general goal of a game will be to move the sprite and achieve a top score before time runs out or the number of lives goes to zero.
 
-## Block Editor
-
-![](/static/mb/game-library/pic0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
-```
+```blocks
 input.onButtonPressed(Button.A, () => {
     game.addScore(1)
 })
@@ -154,8 +146,3 @@ You can also end the game by calling the `game -> game over` function:
 ```
 game.gameOver()
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/game-over.md

@@ -18,7 +18,3 @@ You can end the game by calling the `game -> game over` function:
 game.gameOver()
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance)
-

docs/reference/game/move.md

@@ -1,22 +1,7 @@
 # Move
 
-The game library 
-
-### Move
-
-Sprite move by a certain number
-
-## Block Editor
-
-![](/static/mb/game-library/move-0.png)
-
-## KindScript
+Sprite move by a certain number of LEDs
 
 ```
 export function move(_this: micro_bitSprites.LedSprite, leds: number)
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/position.md

@@ -1,19 +1,5 @@
 # Position
 
-The game library 
-
-### Create sprite
-
-Reports the x or y position of a sprite on the LED screen
-
-## Block Editor
-
-Reports the x position of a sprite on the LED screen
-
-![](/static/mb/game-library/position-0.png)
-
-## KindScript
-
 Reports the x position of a sprite on the LED screen
 
 ```
@@ -25,8 +11,3 @@ Reports the y position of a sprite on the LED screen
 ```
 export function y(_this: micro_bitSprites.LedSprite) : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/reports.md

@@ -1,31 +1,7 @@
 # Reports
 
-The game library
-
-### Reports
-
 Reports the x or y position,  the current direction of a sprite, or the brightness of a sprite on the LED screen
 
-## Block Editor
-
-Reports the x position of a sprite on the LED screen
-
-![](/static/mb/game-library/position-0.png)
-
-Reports the y position of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-0.jpg)
-
-Reports the brightness of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-1.jpg)
-
-Reports the direction of a sprite on the LED screen
-
-![](/static/mb/game-library/reports-2.jpg)
-
-## KindScript
-
 Reports the x position of a sprite on the LED screen
 
 ```
@@ -49,8 +25,3 @@ Reports the current direction of a sprite on the LED screen
 ```
 export function direction(_this: micro_bitSprites.LedSprite) : number
 ```
-
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/score.md

@@ -1,20 +1,10 @@
 # Score
 
-The game library #docs
-
 The game library supports simple single-player games. The player has a **score**.
 
-## Block Editor
-
-The code below shows a simple game where the user gets to press the button ``A`` and adds 1 point to score that will be displayed on the BBC micro:bit screen
-
-![](/static/mb/game-library/add-point-to-score-0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
-```
+```blocks
 input.onButtonPressed(Button.A, () => {
     game.addScore(1)
 })
@@ -53,7 +43,3 @@ If your game has a time limit, you can start a countdown in which case `game->cu
 export function startCountdown(ms: number)
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance), [game counter](/lessons/game-counter)
-

docs/reference/game/start-countdown.md

@@ -1,15 +1,5 @@
 # Start Countdown
 
-The game library #docs
-
-The game library supports simple single-player time-based games. The general goal of a game will be to achieve a top score before time runs out of time.
-
-## Block Editor
-
-![](/static/mb/game-library/start-countdown-0.png)
-
-## KindScript
-
 The code below shows a simple game where the user gets to press the button ``A`` as much times as possible in 10 seconds.
 
 ```
@@ -50,8 +40,3 @@ If your game has a time limit, you can start a countdown in which case `game->cu
 ```
 export function startCountdown(ms: number)
 ```
-
-### Lessons
-
-[bop it](/lessons/bop-it) | [game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/touching.md

@@ -1,24 +1,8 @@
 # Touching
 
-The game library 
-
-### Touching
-
-Reports true if sprite is touching specified sprite
-
-## Block Editor
-
-![](/static/mb/game-library/touching-0.png)
-
-## KindScript
-
 Reports true if sprite is touching specified sprite
 
 ```
 export function isTouching(_this: micro_bitSprites.LedSprite, other: micro_bitSprites.LedSprite) : boolean
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/game/turn.md

@@ -1,17 +1,5 @@
 # Turn
 
-The game library 
-
-Rotates a sprite to the right by a certain number of degrees
-
-## Block Editor
-
-Rotates a sprite to the right by a certain number of degrees
-
-![](/static/mb/game-library/turn-0.png)
-
-## KindScript
-
 Rotates a sprite to the right by a certain number of degrees
 
 ```
@@ -24,7 +12,3 @@ Rotates a sprite to the left by a certain number of degrees
 export function turnLeft(_this: micro_bitSprites.LedSprite, degrees: number)
 ```
 
-### Lessons
-
-[game of chance](/lessons/game-of-chance) | [game counter](/lessons/game-counter)
-

docs/reference/images/create-image.md

@@ -29,10 +29,6 @@ input.onGesture(Gesture.Shake, () => {
 })
 ```
 
-### Lessons
-
-[rock paper scissors](/lessons/rock-paper-scissors), [digital pet](/lessons/digital-pet), [offset-image](/lessons/offset-image)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/image/show-image), [scroll image](/reference/image/scroll-image)

docs/reference/images/image.md

@@ -46,10 +46,6 @@ You should see code similar to this:
 * [show image](/reference/images/show-image): show an image on the screen
 * [scroll image](/reference/images/scroll-image): scroll an image on the screen
 
-### Lessons
-
-* [smiley](/lessons/smiley)
-
 ### See also
 
 [Show LEDs](/reference/basic/show-leds), [create image](/reference/images/create-image), [show image](/reference/images/show-image), [LED screen](/device/screen)

docs/reference/images/plot-frame.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.plotFrame(1)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/plot-image.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.plotImage(0)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/show-frame.md

@@ -31,10 +31,6 @@ let img = images.createImage(`
 img.showFrame(1)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [create image](/reference/images/create-image), [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/images/show-image.md

@@ -45,10 +45,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[rock paper scissors](/lessons/rock-paper-scissors), [digital pet](/lessons/digital-pet), [offset-image](/lessons/offset-image)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [create image](/reference/images/create-image), [scroll image](/reference/images/scroll-image)

docs/reference/input/acceleration.md

@@ -2,46 +2,39 @@
 
 Get the acceleration value (milli g-force), in one of three specified dimensions.
 
+Find the acceleration of the micro:bit (how fast it is speeding up or slowing down).
+
 ```sig
 input.acceleration(Dimension.X);
 ```
 
+## ~hint
+
+You measure acceleration with the **milli-g**, which is 1/1000 of a **g**.
+A **g** is as much acceleration as you get from Earth's gravity.
+
+## ~
+
+
+
 ### Parameters
 
-* dimension : [String](/reference/types/string) - one of three values specifying the axis of acceleration: ``x`` (left/right); ``y`` (forward/backwards); ``z`` (up/down)
+* which direction you are checking for acceleration, either `Dimension.X` (left and right), `Dimension.Y` (forward and backward), or `Dimension.Z` (up and down)
 
 ### Returns
 
-* [Number](/reference/types/number) - acceleration, in milli-gravities. When the micro:bit is laying flat with the screen up, x=0, y=0 and z=-1023.
+* a [number](/reference/types/number) that means the amount of acceleration. When the micro:bit is lying flat on a surface with the screen pointing up, `x` is `0`, `y` is `0`, and `z` is `-1023`.
 
 ### Example: bar chart
 
-Use the ``plot bar chart`` to visual the acceleration on the LED screen.
+This example shows the acceleration of the micro:bit with a bar graph.
 
 ```blocks
 basic.forever(() => {
-    led.plotBarGraph(input.acceleration("x"), 1023)
+    led.plotBarGraph(input.acceleration(Dimension.X), 1023)
 })
 ```
 
-### Example: micro:bit leveller
-
-The following example uses the `acceleration` and the `plot` function to help you move the micro:bit until it's level (the centre LED is *on* when the device is level). When running this code in a web browser, move your mouse to simulate the accelerometer.
-
-```blocks
-basic.forever(() => {
-    let ax = input.acceleration(Dimension.X)
-    let x = pins.map(-1023, 1023, 0, 4, ax)
-    let ay = input.acceleration("y")
-    let y = pins.map(-1023, 1023, 0, 4, ay)
-    basic.clearScreen()
-    led.plot(x, y)
-})
-```
-
-### Lessons
-
-[zoomer](/lessons/zoomer)
 
 ### See also
 

docs/reference/input/button-is-pressed.md

@@ -1,6 +1,6 @@
 # Button Is Pressed
 
-Get the state of an input button. The micro:bit has two input buttons: A and B.
+Check whether a button is pressed right now. The micro:bit has two buttons: button `A` and button `B`.
 
 ```sig
 input.buttonIsPressed(Button.A);
@@ -8,33 +8,31 @@ input.buttonIsPressed(Button.A);
 
 ### Parameters
 
-* name - [String](/reference/types/string); input button "A", "B", or "A+B" (both input buttons)
+* ``name`` is a [String](/reference/types/string). You should store `A` in it to check the left button, `B` to check the right button, or `A+B` to check both at the same time.
 
 ### Returns
 
-* [Boolean](/reference/types/boolean) - `true` if pressed, `false` if not pressed
+* [Boolean](/reference/types/boolean) that is `true` if the button you are checking is pressed, `false` if it is not pressed.
 
 ### Example
 
-The following code uses an [if](/reference/logic/if) statement to run code, depending on whether or not the A button is pressed:
+This program uses an [if](/reference/logic/if) to run 
+one part of the program if the `A` button is pressed, and 
+another part if it is not pressed.
 
 ```blocks
 basic.forever(() => {
     let pressed = input.buttonIsPressed(Button.A)
     if (pressed) {
-        // this code runs if the A button is pressed
+        // this part runs if the A button is pressed
         basic.showNumber(1, 150)
     } else {
-        // this code runs if the A button is *not* pressed
+        // this part runs if the A button is *not* pressed
         basic.showNumber(0, 150)
     }
 })
 ```
 
-### Lessons
-
-[zoomer](/lessons/zoomer)
-
 ### See also
 
 [on button pressed](/reference/input/on-button-pressed), [if](/reference/logic/if), [forever](/reference/basic/forever)

docs/reference/input/compass-heading.md

@@ -1,6 +1,10 @@
 # Compass Heading
 
-Get the compass heading of the micro:bit in degrees. Your micro:bit has a built-in **magnetometer** so it can your direction with respect to the North Magnetic Pole.
+Find which direction on a compass the micro:bit is facing.
+
+The micro:bit measures the **compass heading** from `0` to `360`
+degrees with its **magnetometer** chip. Different numbers mean north,
+east, south, and west.
 
 ```sig
 input.compassHeading();
@@ -8,15 +12,12 @@ input.compassHeading();
 
 ### Returns
 
-* [Number](/reference/types/number) - the heading in degrees (0 to 360 degrees). If the compass is calibrating, it returns ``-1003``.
-
-## Simulator
-
-Calibration does not work on the simulator.
+* a [number](/reference/types/number) from `0` to `360` degrees, which means the compass heading. If the compass isn't ready, it returns `-1003`.
 
 ### Example
 
-The following code gets the compass heading and stores it in the `degrees` variable:
+This program finds the compass heading and stores it in the
+`degrees` variable.
 
 ```blocks
 let degrees = input.compassHeading()
@@ -24,13 +25,16 @@ let degrees = input.compassHeading()
 
 ### ~hint 
 
-When running code with this function in a web browser, click and drag the on-screen compass needle to change heading.
+When you run a program that uses this function in a browser, click and drag
+the compass needle on the screen to change the compass heading.
 
 ### ~
 
 ### Example: compass
 
-The following example gets the `compass heading` and then displays a letter depending on the value of `degrees`: N for north, E for East, S for South, and W for West.
+This program finds the compass heading and then shows a letter
+that means whether the micro:bit is facing north (N), south (S),
+east (E), or west (W).
 
 ```blocks
 basic.forever(() => {
@@ -47,17 +51,14 @@ basic.forever(() => {
 
 ### Calibration
 
-On the first use of the compass, the **calibration** procedure will automatically start. The user must draw a circle with the device until it is fully calibrated.
+Every time you start to use the compass (for example, if you have just
+turned the micro:bit on), the micro:bit will start to **calibrate**
+(adjust itself).  It will ask you to draw a circle by tilting the
+micro:bit.
 
-An enclosure made from metal, or using in proximity of metal objects, might affect the accuracy of the reading and calibration.
-
-During calibration, ``compass heading`` returns ``-1003``.
-
-### Lessons
-
-[compass](/lessons/compass)
+If you are calibrating or using the compass near metal, it might
+confuse the micro:bit.
 
 ### See also
 
 [acceleration](/reference/input/acceleration)
-

docs/reference/input/light-level.md

@@ -1,8 +1,14 @@
 # Light Level
 
-Gets the light level from ``0`` (dark) to ``255`` (bright). The light is measured by using various LEDs from the screen.
+Find the light level (how bright or dark it is) where you are.
+The light level ``0`` means darkness and ``255`` means bright light. 
+The BBC micro:bit measures the light around it by using some of the
+LEDs on the [LED screen](/device/screen).
 
-This function will return ``0`` on the first call to this method, a light reading will be available after the display has activated the light sensor for the first time.
+The first time you use it, this function will say ``0``.
+After that, it will say the real light level.
+This is because the light sensor (the part that can find the light level)
+has to be turned on first.
 
 ```sig
 input.lightLevel();
@@ -10,11 +16,26 @@ input.lightLevel();
 
 ### Returns
 
-* [Number](/reference/types/number) -  light level from ``0`` (dark) to ``255`` (bright).
+* a [Number](/reference/types/number) that means a light level from ``0`` (dark) to ``255`` (bright).
+
+### Example: show light level
+
+When you press button `B` on the microbit, this
+program shows the light level
+on the [LED screen](/device/screen).
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    let level = input.lightLevel()
+    basic.showNumber(level)
+})
+```
 
 ### Example: chart light level
 
-Use `plot bar chart` to visual the influence of various light source on the light level.
+This program shows the light level with a [bar chart](/reference/led/plot-bar-graph) on the micro:bit screen.
+If you carry the micro:bit around to different places with different light levels,
+the bar chart will change.
 
 ```blocks
 basic.forever(() => {
@@ -22,8 +43,6 @@ basic.forever(() => {
 })
 ```
 
-### Lessons
-
 ### See also
 
 [acceleration](/reference/input/acceleration), [compass-heading](/reference/input/compass-heading)

docs/reference/input/magnetic-force.md

@@ -1,27 +1,35 @@
 # Magnetic Force
 
-Get the magnetic force (micro Teslas), in one of three specified dimensions.
+Find the amount of magnetic force (the strength of a magnet) in the direction you say.
 
 ```sig
 input.magneticForce(Dimension.X);
 ```
 
+## ~hint
+
+The micro:bit measures magnetic force with **microteslas**.
+
+## ~
+
+
 ### Parameters
 
-* dimension : [String](/reference/types/string) - one of three values specifying the axis of the force: ``x`` (left/right); ``y`` (forward/backwards); ``z`` (up/down); ``strength`` (the length of the vector)
+* a [string](/reference/types/string) that says which direction the micro:bit should measure magnetic force in: either `x` (the left-right direction), `y` (the forward/backward direction), or `z` (the up/down direction)
 
 ### Returns
 
-* [Number](/reference/types/number) - magnetic force, in micro-Teslas.
+* a [number](/reference/types/number) of microteslas that means the strength of the magnet
 
 ### Example: metal detector
 
-The following example uses the `magnetic force` to control the brightness of the screen. When the magnetic force increases, the center LED will appear brighter.
+This program makes the center LED of the micro:bit get brighter when
+the magnetic force is stronger, and dimmer when it is weaker.
 
 ```blocks
 led.plot(2, 2)
 basic.forever(() => {
-    let f = input.magneticForce(Dimension.X)
+    let f = input.magneticForce("x")
     led.setBrightness(f / 2000)
 })
 ```
@@ -29,4 +37,3 @@ basic.forever(() => {
 ### See also
 
 [compass heading](/reference/input/compass-heading)
-

docs/reference/input/on-button-pressed.md

@@ -1,6 +1,9 @@
 # On Button Pressed
 
-Register an [event handler](/reference/event-handler) that will execute whenever an input button (A, B, or A and B together) is pressed during program execution. When [running code](/device/simulator) with this function in a web browser, click an on-screen input button - labelled A or B.
+Start an [event handler](/reference/event-handler) (part of the program that will run when something happens, like when a button is pressed). 
+This handler works when button `A` or `B` is pressed, or `A` and `B` together.
+When you are using this function in a web browser, click the buttons on the screen instead of the ones
+on the BBC micro:bit.
 
 ```sig
 input.onButtonPressed(Button.A, () => {})
@@ -8,7 +11,8 @@ input.onButtonPressed(Button.A, () => {})
 
 ### Example: count button clicks
 
-This example counts how many times the left or right input button is pressed. Each time a button is pressed, the global count variable is increased by 1 and displayed on the screen.
+This example counts how many times you press the `A` button. 
+Each time you press the button, the [LED screen](/device/screen) shows the `count` variable getting bigger.
 
 ```blocks
 let count = 0
@@ -19,22 +23,25 @@ input.onButtonPressed(Button.A, () => {
 })
 ```
 
-### Example: roll a dice
+### Example: roll dice
 
-This example generates a random number when you press the B input button, and then displays a random die image:
+This example shows a number from 1 to 6 when you press the `B` button.
 
 ```blocks
 input.onButtonPressed(Button.B, () => {
-    let dice = Math.random(6)
+    let dice = Math.random(6) + 1
     basic.showNumber(dice)
 })
 ```
 
-### Lessons
+### ~hint
 
-[smiley](/lessons/smiley), [answering machine](/lessons/answering-machine), [screen wipe](/lessons/screen-wipe), [rotation animation](/lessons/rotation-animation)
+This program adds a `1` to `random(6)` so the numbers on the dice will come out right.
+Otherwise, sometimes they would show a `0`.
+
+### ~
 
 ### See also
 
-[button is pressed](/reference/input/button-is-pressed), [forever](/reference/basic/forever)
+[button is pressed](/reference/input/button-is-pressed), [forever](/reference/basic/forever), [random](/reference/math/math)
 

docs/reference/input/on-gesture.md

@@ -1,19 +1,17 @@
 # On Gesture
 
-Register an [event handler](/reference/event-handler) that will execute whenever the user executes a gesture withthe BBC micro:bit.
+Start an [event handler](/reference/event-handler) (part of the
+program that will run when something happens) This handler works when
+you do a **gesture** (like shake, tilt, or drop the micro:bit).
 
 ```sig
 input.onGesture(Gesture.Shake,() => {
 })
 ```
 
-## Gestures
+## Example: random number
 
-
-
-### Example: random number
-
-The following example displays a number from 0-9 on the screen when you shake the BBC micro:bit.
+This program shows a number from `0` to `9` when you shake the micro:bit.
 
 ```blocks
 input.onGesture(Gesture.Shake,() => {
@@ -22,24 +20,3 @@ input.onGesture(Gesture.Shake,() => {
 })
 ```
 
-### Example: rock, paper, scissors
-
-The following example shows one of three images (rock, paper, or scissors) when you shake the BBC micro:bit.
-
-```blocks
-input.onGesture(Gesture.Shake,() => {
-    let img = images.createImage(`
-. . . . . # # # # # . . . . #
-. # # # . # . . . # # # . # .
-. # # # . # . . . # . # # . .
-. # # # . # . . . # # # . # .
-. . . . . # # # # # . . . . #
-`)
-    img.showFrame(Math.random(3))
-})
-```
-
-### Lessons
-
-[bounce image](/lessons/bounce-image), [rock paper scissors](/lessons/rock-paper-scissors)
-

docs/reference/input/on-pin-pressed.md

@@ -1,17 +1,31 @@
 # On Pin Pressed
 
-Register an [event handler](/reference/event-handler) that will execute whenever the user holds the `GND` pin with one hand, and presses pin `0`, `1`, or `2` with the other hand, thus completing a circuit; when you run a script with this function in a web browser, click pins 0 , 1, or 2 on the simulator.
+Start an [event handler](/reference/event-handler) (part of the program 
+that will run when something happens, like when a button is pressed). 
+This handler works when you press pin `0`, `1`, or `2` together with `GND`.
+When you are using this function in a web browser, click the pins on the screen instead of the ones
+on the BBC micro:bit.
 
-*Note* that this function works best when the BBC micro:bit is powered by AAA battery.
+If you hold the `GND` pin with one hand and touch pin `0`, `1`, or `2` with the other,
+a very small (safe) amount of electricity will flow through your body and back into
+the micro:bit. This is called **completing a circuit**. It's like you're a big wire!
 
 ```sig
 input.onPinPressed(TouchPin.P0, () => {
 })
 ```
 
+## ~hint
+
+This function works best when the BBC micro:bit is using batteries for power,
+instead of the USB cable.
+
+## ~
+
 ### Example: pin pressed counter
 
-This example counts how many times the P0 pin is pressed. Each time the pin is pressed, the global count variable is increased by 1 and displayed on the screen.
+This program counts how many times you press the `P0` pin. 
+Every time you press the pin, the program shows the number of times on the screen.
 
 ```blocks
 let count = 0
@@ -22,10 +36,6 @@ input.onPinPressed(TouchPin.P0, () => {
 })
 ```
 
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [BBC 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/reference/input/pin-is-pressed.md

@@ -1,24 +1,33 @@
 # Pin Is Pressed
 
-Gets the pin state (pressed or not pressed), by detecting when the user holds the `GND` pin with one hand, and presses pin `0`, `1`, or `2` with the other hand, thus completing a circuit.
+Find whether the pin you say is pressed or not pressed.
 
-*Note* that this function works best when the BBC micro:bit is powered by AAA battery.
+If you hold the `GND` pin with one hand and touch pin `0`, `1`, or `2` with the other,
+a very small (safe) amount of electricity will flow through your body and back into
+the micro:bit. This is called **completing a circuit**. It's like you're a big wire!
 
 ```sig
 input.pinIsPressed(TouchPin.P0);
 ```
 
+## ~hint
+
+This function works best when the BBC micro:bit is using batteries for power,
+instead of the USB cable.
+
+## ~
+
 ### Parameters
 
-* name - [String](/reference/types/string); the pin name ("P0", "P1", or "P2")
+* a [string](/reference/types/string) that holds the pin name (**P0**, **P1**, or **P2**)
 
 ### returns
 
-* [Boolean](/reference/types/boolean) - `true` if pressed, `false` if not pressed
+* a [boolean](/reference/types/boolean) that means whether the pin you say is pressed (`true` or `false`)
 
 ### Example
 
-This example displays 1 if P0 is pressed, and 0 if P0 is not pressed:
+This program shows `1` if `P0` is pressed, and `0` if `P0` is not pressed:
 
 ```blocks
 basic.forever(() => {

docs/reference/input/rotation.md

@@ -1,45 +1,58 @@
 # Rotation
 
-Get a rotation angle in degrees inferred from the accelerometer readings.
+Find how much the micro:bit is tilted in different directions.
 
 ```sig
 input.rotation(Rotation.Roll);
 ```
 
+## ~hint
+
+The BBC micro:bit has a part called the **accelerometer** that can
+check how the micro:bit is moving.
+
+## ~
+
 ### Parameters
 
-* kind: [String](/reference/types/string) - one of values specifying the kind of rotation: ``pitch`` (up/down around the ``x`` axis); ``roll`` (left/right around the ``y`` axis)
+* which direction you are checking: `Rotation.Pitch` (up and down) or `Rotation.Roll` (left and right)
 
 ### Returns
 
-* [Number](/reference/types/number) - angle, in degrees.
+* a [number](/reference/types/number) that means how much the microbit is tilted in the direction you say, from `0` to `360` degrees
 
-### Example: micro:bit leveller
+### Example: micro:bit leveler
 
-The following example uses the `rotation` and the `plot leds` function to help you move the BBC micro:bit until it's level: when it is level, a smiley shows up on the screen. When running this code in a web browser, move your mouse to simulate the rotation.
+This program helps you move the BBC micro:bit until it is level.  When
+it is level, the micro:bit shows a smiley.
 
-```sig
+If you are running this program in a browser, you can tilt the
+micro:bit with your mouse.
+
+
+```blocks
+let pitch = 0;
 basic.forever(() => {
-    let pitch = input.rotation(Rotation.Pitch)
-    let roll = input.rotation(Rotation.Roll)
+    pitch = input.rotation(Rotation.Pitch);
+    let roll = input.rotation(Rotation.Roll);
     if (Math.abs(pitch) < 10 && Math.abs(roll) < 10) {
-        basic.plotLeds(`
-. . . . .
-. # . # .
-. . . . .
-# . . . #
-. # # # .
-`)
+        basic.showLeds(`
+            . # . # .
+            . . . . .
+            . . . . .
+            # . . . #
+            . # # # .
+            `);
     } else {
-        basic.plotLeds(`
-# . . . #
-. # . # .
-. . # . .
-. # . # .
-# . . . #
-`)
-    }
-})
+        basic.showLeds(`
+            # . . . #
+            . # . # .
+            . . # . .
+            . # . # .
+            # . . . #
+            `);
+        }
+	});
 ```
 
 ### See also

docs/reference/input/running-time.md

@@ -1,6 +1,6 @@
 # Running Time
 
-Get the number of milliseconds elapsed since the script began. 1,000 milliseconds = 1 second.
+Find how long it has been since the program started.
 
 ```sig
 input.runningTime();
@@ -8,20 +8,22 @@ input.runningTime();
 
 ### Returns
 
-* [Number](/reference/types/number)
+* the [Number](/reference/types/number) of milliseconds since the program started.
+(One second is 1000 milliseconds.)
 
 ### Example: elapsed time
 
-This code gets the elapsed time since the start of the program execution and displays it on the screen.
+When you press button `B` on the microbit, this
+program finds the number of milliseconds since the program started
+and shows it on the [LED screen](/device/screen).
 
 ```blocks
-let now = input.runningTime()
-basic.showNumber(now)
+input.onButtonPressed(Button.B, () => {
+    let now = input.runningTime()
+    basic.showNumber(now)
+})
 ```
 
-### Lessons
-
-[speed button](/lessons/speed-button)
 
 ### See also
 

docs/reference/input/temperature.md

@@ -1,6 +1,7 @@
 # Temperature
 
-Get the ambient temperature (degree Celsius °C). The temperature is inferred from the the surface temperature of the various chips on the micro:bit.
+Find the temperature where you are. The temperature is measured in Celsius (metric).
+The micro:bit can find the temperature nearby by checking how hot its computer chips are.
 
 ```sig
 input.temperature();
@@ -8,26 +9,48 @@ input.temperature();
 
 ### Returns
 
-* [Number](/reference/types/number) - temperature in degree Celsius °C.
+* a [Number](/reference/types/number) that means the Celsius temperature.
 
 ### How does it work?
 
-The BBC micro:bit does not have a dedicated temperature sensor. Instead, the temperature provided is actually the temperature of the silicon die on the main CPU. As the processor generally runs cold though (it is a high efficiency ARM core), the temperature is a good approximation of the ambient temperature... you might warm up if you give the processor a lot of work to do though, and don't [sleep](/reference/basic/pause)!
-
-The temperature sensor has a high precision, but isn't trimmed for accuracy. In other words, it can sense changes in temperature very well, but there may be (and probably is) base line offset. i.e. it might return 20 degrees when it's actually 17, but it would return 21 when it is 18 etc.
+The BBC micro:bit checks how hot its CPU (main computer chip) is.
+Because the micro:bit does not usually get very hot, the temperature of the CPU
+is usually close to the temperature of wherever you are.
+The micro:bit might warm up a little if you make it work hard, though!
 
 ### Example: micro:bit thermometer
 
-The following example uses the `temperature` and the `show number` to display the room temperature.
+The following example uses `temperature` and `show number` to show the temperature of the room.
 
-```sig
+```blocks
 basic.forever(() => {
     let temp = input.temperature()
     basic.showNumber(temp)
 })
 ```
+### Example: Fahrenheit thermometer
 
-### Lessons
+This program measures the temperature using Fahrenheit degrees.
+Fahrenheit is a way of measuring temperature that is commonly used in the United States.
+To make a Celsius temperature into a Fahrenheit one, multiply the Celsius temperature by
+1.8 and add 32.
+
+```blocks
+basic.forever(() => {
+    let c = input.temperature()
+    let f = (c * 1.8) + 32
+    basic.showNumber(f)
+})
+```
+
+### ~hint
+
+Try comparing the temperature your micro:bit shows to a real thermometer in the same place.
+You might be able to figure out how much to subtract from the number the micro:bit
+shows to get the real temperature. Then you can change your program so the micro:bit is a 
+better thermometer.
+
+### ~
 
 ### See also
 

docs/reference/led/brightness.md

@@ -1,6 +1,6 @@
 # Brightness
 
-Set the brightness of the [LED screen](/device/screen).
+Find how bright the [LED screen](/device/screen) is _when it is turned on_.
 
 ```sig
 led.brightness();
@@ -8,11 +8,11 @@ led.brightness();
 
 ### Returns
 
-* [Number](/reference/types/number) - returns the LCD screen brightness as a number from 0 to 255. A return value of 255 means the screen brightness is at 100% and 127 is about 50% brightness.
+* a [number](/reference/types/number) that means how bright the screen is when it is turned on, from `0` (darkest) to `255` (brightest). For example, the number `127` means the screen is halfway bright when it is turned on.
 
-### Example: maximum brightness
+### Example: highest brightness
 
-If the screen brightness is < 100%, the following code sets the brightness to 100% (255):
+This program makes the screen completely bright when it is turned on (if it is not that way already):
 
 ```blocks
 if (led.brightness() < 255) {
@@ -20,6 +20,20 @@ if (led.brightness() < 255) {
 }
 ```
 
+
+### Example: change brightness
+
+This program makes the screen brightness 100% (255).  Then it turns on
+the center LED (`2, 2`), waits for one second and then sets the screen
+brightness to 50% (128):
+
+```blocks
+led.setBrightness(255)
+led.plot(2, 2)
+basic.pause(1000)
+led.setBrightness(led.brightness() / 2)
+```
+
 ### See also
 
 [set brightness](/reference/led/set-brightness), [fade in](/reference/led/fade-in), [fade out](/reference/led/fade-out)

docs/reference/led/fade-in.md

@@ -24,10 +24,6 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
-
-[glowing sword](/lessons/glowing-sword)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade out](/reference/led/fade-out), [set brightness](/reference/led/set-brightness)

docs/reference/led/fade-out.md

@@ -20,10 +20,6 @@ basic.showString("A", 1000)
 led.fadeOut(1000)
 ```
 
-### Lessons
-
-[glowing sword](/lessons/glowing-sword)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade in](/reference/led/fade-in), [set brightness](/reference/led/set-brightness)

docs/reference/led/plot-all.md

@@ -6,10 +6,6 @@ Turn on all the 25 LEDs on the [LED screen](/device/screen).
 led.plotAll()
 ```
 
-### Lessons
-
-[night light](/lessons/night-light)
-
 ### See also
 
 [LED screen](/device/screen), [clear screen](/reference/basic/clear-screen)

docs/reference/led/plot-bar-graph.md

@@ -1,6 +1,7 @@
 # Plot Bar Graph
 
-Displays a vertical bar graph based on the value and high value.
+Displays a bar graph of the numbers you say.
+A bar graph is a kind of chart that shows numbers as lines with different lengths.
 
 ```sig
 led.plotBarGraph(2, 20);
@@ -8,10 +9,18 @@ led.plotBarGraph(2, 20);
 
 ### Parameters
 
-* value: [Number](/reference/types/number) , high : [Number](/reference/types/number) displays a vertical bar graph based on the value and high value
+* `value` is a [Number](/reference/types/number) that means what you are measuring or trying to show. For example, if you are measuring the temperature of ice with the BBC micro:bit, `value` might be 0 because the temperature might be 0 degrees centigrade.
+* `high` is a [Number](/reference/types/number) that means the highest possible number that the `value` parameter can be. This number is also the tallest that the lines in the bar chart can be.
 
 ### Example: chart acceleration
 
+This program shows a bar graph of the [acceleration](/reference/input/acceleration) 
+in the `x` direction of the micro:bit.
+The micro:bit's `x` direction is from left to right (or right to left).
+The more you speed up moving the micro:bit in this direction,
+the taller the lines in the bar graph will be, 
+until they are as tall as the parameter `high` says they can be.
+
 ```blocks
 basic.forever(() => {
     let a = input.acceleration(Dimension.X);

docs/reference/led/plot-leds.md

@@ -28,10 +28,6 @@ basic.plotLeds(`
 `)
 ```
 
-### Lessons
-
-[smiley](/lessons/smiley), [flashing heart](/lessons/flashing-heart), [magic logo](/lessons/magic-logo)
-
 ### See also
 
 [show animation](/reference/basic/show-animation), [image](/reference/images/image), [show image](/reference/images/show-image), [scroll image](/reference/images/scroll-image)

docs/reference/led/plot.md

@@ -1,35 +1,47 @@
 # Plot
 
-Turn on a LED light on the [LED screen](/device/screen). Specify which LED using x, y coordinates. Use [unplot](/reference/led/unplot) to turn a LED off.
+Turn on the LED light you say on the [LED screen](/device/screen).
 
 ```sig
 led.plot(0,0);
 ```
 
+## ~hint
+
+Use [unplot](/reference/led/unplot) to turn **off** an LED.
+
+## ~
+
 ### Parameters
 
-* x - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), then this function will do nothing.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), then this function will do nothing.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-This code turns on the centre LED:
+### ~
+
+### Example: One LED
+
+This program turns on the bottom right LED.
 
 ```blocks
-led.plot(2, 2)
+led.plot(4, 4)
 ```
 
-### Get the LED on/off state
 
-Use the [point](/reference/led/point) function to find out if a LED is on or off.
+### Example: Square
 
-### Example: a square
-
-The following example uses a [for loop](/reference/loops/for) and the `plot` function to turn on the LED lights along the edge of the screen, making a square:
+This program uses a [for loop](/reference/loops/for)
+and the `plot` function
+to make a square around the edges of the LED screen.
 
 ```blocks
 for (let i = 0; i < 5; i++) {
@@ -41,11 +53,13 @@ for (let i = 0; i < 5; i++) {
 }
 ```
 
-### Lessons
+### ~hint
 
-[blink](/lessons/blink), [beautiful  image](/lessons/beautiful-image), [strobe light](/lessons/strobe-light)
+Use the [point](/reference/led/point) function to find out if an LED is
+on or off.
+
+### ~
 
 ### See also
 
 [unplot](/reference/led/unplot), [point](/reference/led/point), [LED screen](/device/screen)
-

docs/reference/led/point.md

@@ -1,6 +1,7 @@
 # Point
 
-Get the on/off state of a LED on the [LED screen](/device/screen). Specify the LED using x, y coordinates.
+Find whether the LED you say on the 
+[LED screen](/device/screen) is on or off.
 
 ```sig
 led.point(0,0);
@@ -8,30 +9,36 @@ led.point(0,0);
 
 ### Parameters
 
-* x  - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), then this function will return `false`.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), this function will return `false`.
 
 ### Returns
 
-* [Boolean](/reference/types/boolean) - `true` if the LED is *on* and `false` if the LED is *off*
+* a [boolean](/reference/types/boolean). If it is `true`, that means the LED is on. If it is `false`, that means the LED is off.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-### Example: toggle off
+### ~
 
-If `point(1, 1)` returns `true`, then the following code turns off the LED:
+### Example: Toggle off
+
+This program turns the center LED (2, 2) off if it is already on.  (If
+it is already off, this program leaves it off.)
 
 ```blocks
-if (led.point(1, 1)) {
-    led.unplot(1, 1)
+if (led.point(2, 2)) {
+    led.unplot(2, 2)
 }
 ```
 
 ### See also
 
-[unplot](/reference/led/unplot), [plot](/reference/led/plot), [LED screen](/device/screen), [create image](/reference/images/create-image)
+[unplot](/reference/led/unplot), [plot](/reference/led/plot), [LED screen](/device/screen)
 

docs/reference/led/set-brightness.md

@@ -1,6 +1,7 @@
 # Set Brightness
 
-Sets the brightness of the [LED screen](/device/screen).
+Make the [LED screen](/device/screen) as bright as you say when it is
+turned on.
 
 ```sig
 led.setBrightness(121)
@@ -8,23 +9,21 @@ led.setBrightness(121)
 
 ### Parameters
 
-* value : [Number](/reference/types/number) - the brightness of the LED screen expressed as a number between 0 and 255
+* a [number](/reference/types/number) that means how bright the screen is when it is turned on, from `0` (darkest) to `255` (brightest). For example, the number `127` means the screen is halfway bright when it is turned on.
 
 ### Example: change brightness
 
-The following example sets the screen brightness to 100% (255), turns on LED `2, 2`, waits for a second and then sets the screen brightness to 50% (127):
+This program makes the screen brightness 100% (255).  Then it turns on
+the center LED (`2, 2`), waits for one second, and then sets the screen
+brightness to 50% (128):
 
 ```blocks
 led.setBrightness(255)
 led.plot(2, 2)
 basic.pause(1000)
-led.setBrightness(127)
+led.setBrightness(led.brightness() / 2)
 ```
 
-### Lessons
-
-[night light](/lessons/night-light)
-
 ### See also
 
 [brightness](/reference/led/brightness), [fade in](/reference/led/fade-in), [fade out](/reference/led/fade-out), [LED screen](/device/screen)

docs/reference/led/unplot.md

@@ -1,35 +1,36 @@
 # Unplot
 
-Turn off a LED light on the [LED screen](/device/screen). Specify which LED using x, y coordinates. Use [plot](/reference/led/plot) to turn a LED on.
+Turn off the LED light you say on the [LED screen](/device/screen).
 
 ```sig
 led.unplot(0,0)
 ```
 
+## ~hint
+
+Use [plot](/reference/led/plot) to turn **on** an LED.
+
+## ~
+
 ### Parameters
 
-* x - [Number](/reference/types/number); the *x coordinate* or horizontal position (0, 1, 2, 3, 4)
-* y - [Number](/reference/types/number); the *y coordinate* or vertical position (0, 1, 2, 3, 4)
+* **x** is a [number](/reference/types/number) that means the horizontal spot on the LED screen (from left to right: 0, 1, 2, 3, or 4)
+* **y** is a [number](/reference/types/number) that means the vertical spot on the LED screen (from top to bottom: 0, 1, 2, 3, or 4)
 
-If a parameter is [out of bounds](/reference/out-of-bounds) (a value other than 0-4), this function will do nothing.
+If a parameter is [out of bounds](/reference/out-of-bounds) (a value
+other than 0 to 4), then this function will do nothing.
 
-### x, y coordinates?
+### ~hint
 
-The LED screen is made up of 25 LEDs arranged in a 5x5 grid. To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
+The LED screen is a solid square of LEDs with five LEDs on each side.
+To learn more about how you number the LEDs with ``x`` and ``y``
+coordinates, see [LED screen](/device/screen).
 
-This code turns off centre LED:
+### ~
 
-```blocks
-led.unplot(2, 2)
-```
+### Example: Center off 
 
-### Get the LED on/off state
-
-Use the [point](/reference/led/point) function to find out if a LED is on or off.
-
-### Example: toggle off
-
-This code creates and shows an image on the micro:bit screen, and then clears the centre LED using `unplot`:
+This program shows a picture on the LED screen, and then turns off the center LED with `unplot`.
 
 ```blocks
 basic.showLeds(`
@@ -43,11 +44,14 @@ basic.pause(500)
 led.unplot(2, 2)
 ```
 
-### Lessons
+### ~hint
+
+Use the [point](/reference/led/point) function to find out if an LED is
+on or off.
+
+### ~
 
-[strobe light](/lessons/strobe-light)
 
 ### See also
 
-[plot](/reference/led/plot), [point](/reference/led/point), [LED screen](/device/screen), [create image](/reference/images/create-image)
-
+[plot](/reference/led/plot), [point](/reference/led/point), [LED screen](/device/screen)

docs/reference/logic.md

@@ -1,39 +1,9 @@
 # Logic
 
-[if](/reference/logic/if)
-
-```blocks
-if(true) {
-}
-```
-
-[Boolean](/reference/types/boolean) values: *true*; *false*
-
-```blocks
-true
-false
-```
-
-Boolean binary operators: *and* (conjunction); *or* (disjunction)
-
-```blocks
+```cards
+if(true) {}
+true;
 true && false;
-true || false;
-```
-
-Boolean negation operator
-
-```blocks
-!true
-```
-
-Comparison operators (=, !=, <, >, <=, >=)
-
-```blocks
-0 == 0;
-1 !- 0;
-0 < 1;
-1 > 0;
-0 <= 1;
-1 >= 0;
+!true;
+1 != 0;
 ```

docs/reference/logic/if.md

@@ -1,27 +1,26 @@
 # If
 
-Run code based on a condition.
-
 ### @parent blocks/language
  
 
 Conditionally run code depending on whether a [Boolean](/reference/types/boolean) condition is true or false.
 
-### Block Editor
-
-![](/static/mb/hourofcode-0.png)
+```blocks
+if(true) {
+}
+```
 
 In the Block Editor, click on the dark blue gear icon (see above) to add an *else* or *if* to the current block.
 
 ### Example: adjusting screen brightness
 
-![](/static/mb/blocks/game-library/pic0.png)
+```blocks
+if(input.lightLevel()<100){
+    led.setBrightness(255);
+}
+```
 
-If the screen [brightness](/reference/led/brightness) is `< 100`, this code sets the brightness to `255`:
-
-### Lessons
-
-[love meter](/lessons/love-meter), [zoomer](/lessons/zoomer)
+If the [light level](/input/light-level) is `< 100`, this code sets the brightness to `255`:
 
 ### See also
 

docs/reference/loops.md

@@ -1,26 +1,7 @@
 # Loops
 
-Repeat code.
-
-
-[for](/reference/loops/for)
-
-```blocks
+```cards
 for(let i = 0;i<5;i++) {}
-```
-
-[repeat](/reference/loops/repeat)
-
-![](/static/mb/blocks/contents-0.png)
-
-[while](/reference/loops/while)
-
-```blocks
 while(true) {}
-```
-
-[forever](/reference/basic/forever)
-
-```blocks
 basic.forever(() => {})
 ```

docs/reference/loops/for.md

@@ -1,28 +1,20 @@
 # For
 
-Repeat code a preset number of times.
-
 ### @parent blocks/language
  
+Run part of the program the number of times you say.
 
-Repeat code a fixed number of times.
+### Example: Count to 4
 
-### Block Editor
+This program will show the numbers 0, 1, 2, 3, and 4 one after another on the LED screen.
 
-![](/static/mb/events-0.png)
-
-The Block Editor *for* loop is different than the Touch Develop *for* loop in an important way. The above for loop will iterate *five* times, with the loop variable *i* taking on values 0, 1, 2, 3, and 4. The Touch Develop for loop shown below will iterate four times:
-
-```
-for (let k = 0; k < 4; k++) {
+```blocks
+for(let i = 0; i < 5; ++i) {
+basic.showNumber(i)
 }
 ```
 
-### Lessons
-
-[looper](/lessons/looper)
-
 ### See also
 
-[while](/reference/loops/while), [if](/reference/logic/if)
+[repeat](/reference/loops/repeat), [while](/reference/loops/while), [if](/reference/logic/if), [show number](/reference/basic/show-number)
 

docs/reference/loops/repeat.md

@@ -1,21 +1,12 @@
 # Repeat
 
-Repeat code a preset number of times.
-
-Repeat code a fixed number of times.
+Run part of the program the number of times you say.
 
 ### Block Editor
 
 ![](/static/mb/blocks/contents-0.png)
 
-### Touch Develop
+### See also
 
-Touch Develop has no `repeat` loop. Instead you can used a for loop
-
-```
-for (let i = 0; i < 5; i++) {
-}
-```
-
-The loop above will repeat five (5) times.
+[for](/reference/loops/for), [while](/reference/loops/while), [if](/reference/logic/if), [show number](/reference/basic/show-number)
 

docs/reference/loops/while.md

@@ -1,23 +1,14 @@
 # While
 
-Repeat code in a loop while a condition is true.
-
 ### @parent blocks/language
  
 
 Repeat code while a [Boolean](/reference/types/boolean) `condition` is true.
 
-### ~hide
-
+```blocks
+while(true) {
+}
 ```
-let condition = false
-```
-
-### ~
-
-### Block Editor
-
-![](/static/mb/string-0.png)
 
 The while loop has a *condition* that evaluates to a [Boolean](/reference/types/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`.
 
@@ -27,15 +18,13 @@ The condition is tested before any code runs. Which means that if the condition
 
 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`).
 
-// index is set to 4
-
-![](/static/mb/blocks/var-10.png)
-
-// subtract 1 from `index` each time through loop
-
-### Lessons
-
-[rotation animation](/lessons/rotation-animation)
+```blocks
+let index = 4;
+while(index >= 0) {
+    led.plot(index, index);
+    index--;
+}
+```
 
 ### See also
 

docs/reference/math/math.md

@@ -42,10 +42,6 @@ returns a random [Number](/reference/types/number) between 0 and the parameter *
 
 ![](/static/mb/blocks/math-3.png)
 
-### Lessons
-
-[love meter](/lessons/love-meter)
-
 ### See also
 
 [Block Editor documentation](/blocks/contents), [Number](/reference/types/number)