0.3.73

adds MAX6675; adds general SPI & I2C support to sim

.gitignore

@@ -1,16 +1,21 @@
 node_modules
 yotta_modules
 yotta_targets
+pxt_modules
 built
 typings
 tmp
 temp
 projects/**
+clients/win10/app/AppPackages
+clients/win10/app/BundlePackages
+clients/win10/app/BundleArtifacts
 clients/win10/app/bin
 clients/win10/app/bld
 clients/win10/*.opendb
 clients/**/bin/**
 clients/**/obj/**
+clients/electron/projects
 
 *.user
 *.sw?
@@ -18,4 +23,4 @@ clients/**/obj/**
 *.tgz
 *.db
 *.suo
-*.log
+*.log

.travis.yml

@@ -4,8 +4,12 @@ node_js:
 script:
   - "node node_modules/pxt-core/built/pxt.js travis"  
   - "(cd libs/lang-test0; node ../../node_modules/pxt-core/built/pxt.js run)"
+  - "(cd libs/lang-test1; node ../../node_modules/pxt-core/built/pxt.js run)"
+  - "(cd libs/lang-test0; node ../../node_modules/pxt-core/built/pxt.js test)"
+  - "(cd libs/lang-test1; node ../../node_modules/pxt-core/built/pxt.js test)"
+  - "node node_modules/pxt-core/built/pxt.js testdir tests"
   - "node node_modules/pxt-core/built/pxt.js uploaddoc"
-  - "(cd libs/hello; node ../../node_modules/pxt-core/built/pxt.js testconv ../../testconv.json)"
+  - "(cd libs/hello; node ../../node_modules/pxt-core/built/pxt.js testconv https://az851932.vo.msecnd.net/files/td-converter-tests-v0.json)"
 sudo: false
 notifications:
   email:

.vscode/settings.json

@@ -1,5 +1,20 @@
 // Place your settings in this file to overwrite default and user settings.
 {
+    "file.autoSave": "afterDelay",   
+    "files.watcherExclude": {
+        "**/.git/objects/**": true,
+        "**/built/**": true,
+        "**/node_modules/**": true,
+        "**/yotta_modules/**": true,
+        "**/yotta_targets": true,
+        "**/pxt_modules/**": true
+    },    
+    "search.exclude": {
+        "**/node_modules": true,
+        "**/yotta_modules/**": true,
+        "**/yotta_targets": true,
+        "**/pxt_modules/**": true
+    },    
     "tslint.enable": true,
     "tslint.rulesDirectory": "node_modules/tslint-microsoft-contrib"
 }

README.md

@@ -9,12 +9,19 @@ PXT ([Microsoft Programming Experience Toolkit](https://github.com/Microsoft/pxt
 
 ## Local server
 
+The local server allows to run the editor and the documentation from your computer.
+
 ### Setup
 
 The following commands are a 1-time setup after synching the repo on your machine.
 
-* clone this repo to your computer
-* install the PXT command line
+* if not yet installed, install [Node.js 4.4.5 or higher](https://nodejs.org/en/download/)
+* [clone this repo](https://help.github.com/articles/cloning-a-repository/) to your computer and go in the project folder
+```
+git clone https://github.com/microsoft/pxt-microbit
+cd pxt-microbit
+```
+* install the PXT command line (add ``sudo`` for Mac/Linux shells).
 ```
 npm install -g pxt
 ```
@@ -37,7 +44,9 @@ If you need modify the `.cpp` files, turn on yotta compilation with the ``-yt``
 pxt serve -yt
 ```
 
-To make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
+## Updates
+
+To update your PXT version and make sure you're running the latest tools, run (add ``sudo`` for Mac/Linux shells)
 ```
 pxt update
 ```
@@ -54,6 +63,23 @@ that wraps ``codethemicrobit.com`` and provides additional features.
 * Install Visual Studio 2015 Update 2 or higher. Make sure the Windows 10 templates are installed.
 * open the ``win10/app.sln`` solution and launch the ``codethemicrobit`` project.
 
+## Testing
+
+The build automatically runs the following:
+
+* make sure the built-in packages compile
+* `pxt run` in `libs/lang-test*` - this will run the test in command line runner; 
+  there is a number of asserts in both of these
+* `pxt testdir` in `tests` - this makes sure all the files compile and generates .hex files
+* run the TD->TS converter on a number of test scripts from `microbit.co.uk` and make sure the results compile
+
+To test something on the device:
+
+* do a `pxt deploy` in `libs/lang-test*` - they should show `1` or `2` on the screen (and not unhappy face)
+* run `pxt testdir` in `tests` and deploy some of the hex files from `tests/built`
+
+The `lang-test0` source comes from the `pxt-core` package. It's also tested with `pxt run` there. 
+
 ## Code of Conduct
 
 This project has adopted the [Microsoft Open Source Code of Conduct](https://opensource.microsoft.com/codeofconduct/). For more information see the [Code of Conduct FAQ](https://opensource.microsoft.com/codeofconduct/faq/) or contact [opencode@microsoft.com](mailto:opencode@microsoft.com) with any additional questions or comments.

clients/electron/main.js

@@ -0,0 +1,67 @@
+const electron = require('electron')
+// Module to control application life.
+const app = electron.app
+// Module to create native browser window.
+const BrowserWindow = electron.BrowserWindow
+// pxt toolchain
+const pxt = require('pxt-core')
+
+// Keep a global reference of the window object, if you don't, the window will
+// be closed automatically when the JavaScript object is garbage collected.
+let mainWindow
+
+function createWindow() {
+  console.log('starting app...')
+  // Create the browser window.
+  mainWindow = new BrowserWindow({
+    width: 800, height: 600,
+    webPreferences: {
+      nodeIntegration: false,
+    }
+  })
+
+  ts.pxt.Util.debug = true;
+  pxt.mainCli("C:/gh/pxt-microbit/clients/electron/node_modules/pxt-microbit", ["serve", "-just"]);
+  
+  // no menu
+  mainWindow.setMenu(null);
+
+  // and load the index.html of the app.
+  mainWindow.loadURL(`http://localhost:3232/#local_token=08ba9b8f-6ccb-4202-296d-28fac7a553d9`)
+
+  // Open the DevTools.
+  mainWindow.webContents.openDevTools()
+
+  // Emitted when the window is closed.
+  mainWindow.on('closed', function () {
+    // Dereference the window object, usually you would store windows
+    // in an array if your app supports multi windows, this is the time
+    // when you should delete the corresponding element.
+    mainWindow = null
+  })
+}
+
+// This method will be called when Electron has finished
+// initialization and is ready to create browser windows.
+// Some APIs can only be used after this event occurs.
+app.on('ready', createWindow)
+
+// Quit when all windows are closed.
+app.on('window-all-closed', function () {
+  // On OS X it is common for applications and their menu bar
+  // to stay active until the user quits explicitly with Cmd + Q
+  if (process.platform !== 'darwin') {
+    app.quit()
+  }
+})
+
+app.on('activate', function () {
+  // On OS X it's common to re-create a window in the app when the
+  // dock icon is clicked and there are no other windows open.
+  if (mainWindow === null) {
+    createWindow()
+  }
+})
+
+// In this file you can include the rest of your app's specific main process
+// code. You can also put them in separate files and require them here.

clients/electron/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "codethemicrobit",
+  "version": "0.1.0",
+  "description": "A Blocks / JavaScript editor for the micro:bit",
+  "main": "main.js",
+  "scripts": {
+    "start": "electron ."
+  },
+  "author": "Microsoft",
+  "license": "MIT",
+  "devDependencies": {
+    "electron-prebuilt": "^1.2.0"
+  },
+  "dependencies": {
+    "typescript": "1.8.7",
+    "pxt-core": "*",
+    "pxt-microbit": "*"
+  }
+}

clients/win10/app/codethemicrobitapp.jsproj

@@ -20,22 +20,18 @@
     <ProjectConfiguration Include="Release|AnyCPU">
       <Configuration>Release</Configuration>
       <Platform>AnyCPU</Platform>
-      <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|ARM">
       <Configuration>Release</Configuration>
       <Platform>ARM</Platform>
-      <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x64">
       <Configuration>Release</Configuration>
       <Platform>x64</Platform>
-      <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
     </ProjectConfiguration>
     <ProjectConfiguration Include="Release|x86">
       <Configuration>Release</Configuration>
       <Platform>x86</Platform>
-      <UseDotNetNativeToolchain>true</UseDotNetNativeToolchain>
     </ProjectConfiguration>
   </ItemGroup>
   <PropertyGroup Label="Globals">

clients/winuploader/CodeTheMicroBit.sln

@@ -5,8 +5,6 @@ VisualStudioVersion = 14.0.25123.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "CodeTheMicrobit", "Microbit.Uploader\CodeTheMicrobit.csproj", "{7DC6CA45-FD75-44BC-805E-708C812CD4BF}"
 EndProject
-Project("{262852C6-CD72-467D-83FE-5EEB1973A190}") = "codethemicrobitapp", "..\win10\app\codethemicrobitapp.jsproj", "{39122940-AB16-4CD4-A0CE-79A3EB863ECF}"
-EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -35,30 +33,6 @@ Global
 		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x64.Build.0 = Release|Any CPU
 		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x86.ActiveCfg = Release|Any CPU
 		{7DC6CA45-FD75-44BC-805E-708C812CD4BF}.Release|x86.Build.0 = Release|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|Any CPU.Build.0 = Debug|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|ARM.ActiveCfg = Debug|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|ARM.Build.0 = Debug|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|ARM.Deploy.0 = Debug|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x64.ActiveCfg = Debug|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x64.Build.0 = Debug|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x64.Deploy.0 = Debug|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x86.ActiveCfg = Debug|x86
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x86.Build.0 = Debug|x86
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Debug|x86.Deploy.0 = Debug|x86
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|Any CPU.ActiveCfg = Release|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|Any CPU.Build.0 = Release|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|Any CPU.Deploy.0 = Release|Any CPU
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|ARM.ActiveCfg = Release|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|ARM.Build.0 = Release|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|ARM.Deploy.0 = Release|ARM
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x64.ActiveCfg = Release|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x64.Build.0 = Release|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x64.Deploy.0 = Release|x64
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x86.ActiveCfg = Release|x86
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x86.Build.0 = Release|x86
-		{39122940-AB16-4CD4-A0CE-79A3EB863ECF}.Release|x86.Deploy.0 = Release|x86
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE

clients/winuploader/Microbit.Uploader/LicenseDialog.cs

@@ -14,7 +14,7 @@ namespace Microsoft.MicroBit
         public LicenseDialog()
         {
             InitializeComponent();
-            this.textBox.Rtf = Resources.MSR_LA___2576;
+            this.textBox.Text = Resources.MSR_LA___2576;
         }
 
         private void acceptButton_Click(object sender, EventArgs e)

clients/winuploader/Microbit.Uploader/MainForm.cs

@@ -32,7 +32,7 @@ namespace Microsoft.MicroBit
         private void openEditor()
         {
             // lanch editor
-            try { Process.Start("https://codethemicrobit.com"); } catch (Exception) { }
+            try { Process.Start("https://codethemicrobit.com#uploader"); } catch (Exception) { }
         }
 
         private void initializeFileWatch()

clients/winuploader/Microbit.Uploader/Properties/AssemblyInfo.cs

@@ -34,7 +34,7 @@ using System.Runtime.InteropServices;
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("0.9.0.0")]
-[assembly: AssemblyFileVersion("0.9.0.0")]
+[assembly: AssemblyVersion("0.10.0.0")]
+[assembly: AssemblyFileVersion("0.10.0.0")]
 [assembly: CLSCompliant(true)]
 [assembly: NeutralResourcesLanguage("en-US")]

clients/winuploader/Microbit.Uploader/Properties/Resources.Designer.cs

@@ -81,8 +81,7 @@ namespace Microsoft.MicroBit.Properties {
         }
         
         /// <summary>
-        ///   Looks up a localized string similar to {\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff0\deff0\stshfdbch0\stshfloch0\stshfhich0\stshfbi0\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f1\fbidi \fswiss\fcharset0\fprq2{\*\panose 020b0604020202020204}Arial;}
-        ///{\f2\fbidi \fmodern\fcharset0\fprq1{\*\panose 02070309020205020404}Courier New;}{\f3\fbidi \froman\fcharset2\fprq2{\*\panose 05050102010706020507}Symbol;}{\f10\fbidi \fnil\fcharset2\fp [rest of string was truncated]&quot;;.
+        ///   Looks up a localized string similar to TBD.
         /// </summary>
         internal static string MSR_LA___2576 {
             get {

clients/winuploader/Microbit.Uploader/Properties/Resources.resx

@@ -118,13 +118,13 @@
     <value>System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
   </resheader>
   <assembly alias="System.Windows.Forms" name="System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
-  <data name="MSR_LA___2576" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\Resources\MSR-LA - 2576.rtf;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089</value>
+  <data name="microbit_red" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\microbit.red.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
   <data name="MSFT_logo_png" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\MSFT_logo_png.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
   </data>
-  <data name="microbit_red" type="System.Resources.ResXFileRef, System.Windows.Forms">
-    <value>..\microbit.red.png;System.Drawing.Bitmap, System.Drawing, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a</value>
+  <data name="MSR_LA___2576" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\MSR-LA - 2576.rtf;System.String, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
 </root>

cmds/cmds.ts

@@ -9,16 +9,16 @@ let execAsync: (cmd: string, options?: { cwd?: string }) => Promise<Buffer> = Pr
 let readDirAsync = Promise.promisify(fs.readdir)
 
 
-export function deployCoreAsync(res: ts.pxt.CompileResult) {
+export function deployCoreAsync(res: ts.pxtc.CompileResult) {
     return getBitDrivesAsync()
         .then(drives => {
             if (drives.length == 0) {
                 console.log("cannot find any drives to deploy to")
             } else {
-                console.log(`copy ${ts.pxt.BINARY_HEX} to ` + drives.join(", "))
+                console.log(`copy ${ts.pxtc.BINARY_HEX} to ` + drives.join(", "))
             }
             return Promise.map(drives, d =>
-                writeFileAsync(d + ts.pxt.BINARY_HEX, res.outfiles[ts.pxt.BINARY_HEX])
+                writeFileAsync(d + ts.pxtc.BINARY_HEX, res.outfiles[ts.pxtc.BINARY_HEX])
                     .then(() => {
                         console.log("wrote hex file to " + d)
                     }))
@@ -28,11 +28,12 @@ export function deployCoreAsync(res: ts.pxt.CompileResult) {
 
 function getBitDrivesAsync(): Promise<string[]> {
     if (process.platform == "win32") {
+        let rx = new RegExp("^([A-Z]:).* " + pxt.appTarget.compile.deployDrives)
         return execAsync("wmic PATH Win32_LogicalDisk get DeviceID, VolumeName, FileSystem")
             .then(buf => {
                 let res: string[] = []
                 buf.toString("utf8").split(/\n/).forEach(ln => {
-                    let m = /^([A-Z]:).* MICROBIT/.exec(ln)
+                    let m = rx.exec(ln)
                     if (m) {
                         res.push(m[1] + "/")
                     }
@@ -41,8 +42,9 @@ function getBitDrivesAsync(): Promise<string[]> {
             })
     }
     else if (process.platform == "darwin") {
+        let rx = new RegExp(pxt.appTarget.compile.deployDrives)
         return readDirAsync("/Volumes")
-            .then(lst => lst.filter(s => /MICROBIT/.test(s)).map(s => "/Volumes/" + s + "/"))
+            .then(lst => lst.filter(s => rx.test(s)).map(s => "/Volumes/" + s + "/"))
     } else {
         return Promise.resolve([])
     }

docs/about.md

@@ -23,6 +23,8 @@ input.onButtonPressed(Button.B, () => {
 ``` 
 # About
 
+### @description A Blocks / Javascript code editor for the micro:bit, a pocket-size computer with 5x5 display, sensors and Bluetooth.
+
 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).
 
@@ -38,7 +40,9 @@ Learn about the [hardware components](/device) of the micro:bit to make the most
 You can program the micro:bit using [Blocks](/blocks) or [JavaScript](/javascript), via the [micro:bit APIs](/reference):
 
 ```blocks
-basic.showString("Hi!");
+input.onButtonPressed(Button.A, () => {
+    basic.showString("Hi!");
+})
 ```
 
 ## Compile and Flash: Your Program!

docs/blocks.md

@@ -1,8 +1,14 @@
 # Blocks language
 
+### @description Langugage constructs for the Block editor.
+
 ```namespaces
 for (let i = 0;i<5;++i) {}
 if (true){}
 let x = 0;
 Math.random(5);
-```
+```
+
+## See Also
+
+[logic](/blocks/logic), [loops](/blocks/loops), [math](/blocks/math), [variables](/blocks/variables)

docs/blocks/logic/boolean.md

@@ -86,7 +86,7 @@ if (led.point(1,1) && led.point(2,2)) {
 When you compare two Numbers, you get a Boolean value, such as the comparison `x < 5` in the code below:
 
 ```blocks
-let x = math.random(5)
+let x = Math.random(5)
 if(x < 5) {
    basic.showString("low");
 } else { 

docs/blocks/math.md

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

docs/blocks/math/math.md

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

docs/blocks/variables/var.md

@@ -46,7 +46,7 @@ basic.showNumber(counter);
 
 To change the contents of a variable use the assignment operator. The following code sets `counter` to 1 and then increments `counter` by 10:
 
-```blocks 
+```blocks
 let counter = 1;
 counter = counter + 10;
 basic.showNumber(counter);

docs/cli.md

@@ -0,0 +1,17 @@
+# Command Line Interface
+
+```sim
+basic.forever(() => {
+    basic.showString("CLI<3")
+})
+```
+
+It is possible to use the codethemicrobit tools from a command line interface (CLI). The PXT CLI allows to 
+* edit, compile or deploy JavaScript programs
+* can easily be integrated in most IDEs. It comes with built-in support for [Visual Studio Code](/code)!
+* run a local web server for the web editor
+* author packages using JavaScript and/or C++
+
+Using the CLI assumes that you have some experience with programming and will require to install tools on your machine as well.
+
+* **[LET'S GET STARTED](https://pxt.io/cli)**

docs/code.md

@@ -0,0 +1,16 @@
+# Visual Studio Code
+
+[Visual Studio Code](https://code.visualstudio.com) is a Free Open Source code editor that you can use to edit your programs.
+
+Working from Visual Studio code allows you to benefit from all the features
+of a professional IDE while working with PXT: working with files, 
+git integration (or source control of your choice), hundreds of extensions.
+
+* background compilation
+* auto-completion
+* pxt command line integration
+
+**Follow [these instructions](https://pxt.io/cli)** to setup your machine and edit your programs in Visual Studio Code.
+
+![](/static/mb/vscode.png)
+

docs/device/crocodile-clips.md

@@ -7,10 +7,16 @@ Register an event that will execute whenever the user attaches one side of the c
 
 This example displays a random number every time the crocodile clip holds  `GND` then connects and disconnects the `P0` pin. Each time the crocodile clip is firmly connected and disconnected from pin `P0`, the micro:bit will return a random Number between 0 and the parameter limit
 
-![](/static/mb/crocodile-clips-0.png)
+```blocks
+input.onPinPressed(TouchPin.P0, () => {
+    basic.showNumber(Math.random(10))
+})
+```
 
 ### Connecting Crocodile Clips
 
+![](/static/mb/crocodile-clips-2.jpg)
+
 ### 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

@@ -9,7 +9,15 @@ Below is a list of error numbers and what they mean:
 * **10** (`MICROBIT_I2C_LOCKUP`): the micro:bit's I2C bus is not working
 * **20** (`MICROBIT_OOM`): there is no free memory on the micro:bit
 
-![](/static/mb/device/error-codes-0.png)
+```sim
+basic.showLeds(`
+    # . . . #
+    # # . # #
+    . . . . .
+    . # # # .
+    # . . . #
+    `)
+```
 
 ### See also
 

docs/device/reactive.md

@@ -48,41 +48,45 @@ The micro:bit’s *scheduler* provides the capability to concurrently execute di
 
 The first job of the scheduler is to allow multiple *subprograms* to be queued up for later execution . For our purposes, a subprogram is just a statement or sequence of statements in the context of a larger program. Consider the Touch Develop program below for counting button presses.
 
-```
-export function countButtonPresses() {
-    input.onButtonPressed(Button.A, () => {
-        count = count + 1
-    })
-    basic.forever(() => {
-        basic.showNumber(count, 150)
-    })
-    count = 0
-}
-```
-
-The program above contains three statements that execute in order from top to bottom. The first statement
-
-```
+```blocks
+let count = 0
 input.onButtonPressed(Button.A, () => {
-    count = count + 1
+    count++;
 })
-```
-
-informs the scheduler that on each and every event of the A button being pressed, a subprogram (called the event handler) should be queued for execution. The event handler is demarcated by the do/end keywords; it increments the global variable `count` by one.  The second statement
-
-```
 basic.forever(() => {
     basic.showNumber(count, 150)
 })
 ```
 
-queues a `forever` loop for later execution by the scheduler; the body of this loop (between the do/end keywords) displays the current value of global variable `count` on the LED screen. The third statement
+The program above contains three statements that execute in order from top to bottom. 
+The first statement initializes the global variable `count` to zero.
 
-```
-count = 0
+```blocks
+let count = 0
 ```
 
-initializes the global variable `count` to zero.  The function ends after the execution of these three statements, but this is not the end of program execution!  That’s because the function queued the `forever` loop for execution by the scheduler.
+The second statement informs the scheduler that on each and every event of the A button being pressed, a subprogram (called the event handler) should be queued for execution. The event handler is demarcated by the do/end keywords; it increments the global variable `count` by one.  
+
+```blocks
+let count = 0
+// ...
+input.onButtonPressed(Button.A, () => {
+    count++;
+})
+```
+
+The third statement queues a `forever` loop for later execution by the scheduler; the body of this loop (between the do/end keywords) displays the current value of global variable `count` on the LED screen. The third statement
+
+```blocks
+let count = 0
+// ...
+basic.forever(() => {
+    basic.showNumber(count, 150)
+})
+```
+
+
+The function ends after the execution of these three statements, but this is not the end of program execution!  That’s because the function queued the `forever` loop for execution by the scheduler.
 
 The second job of the scheduler is to periodically interrupt execution to read (poll) the various inputs to the micro:bit (the buttons, pins, etc.) and fire off events (such as “button A pressed”). Recall that the firing of an event causes the event handler subprogram associated with that event to be queued for later execution. The scheduler uses a timer built into the micro:bit hardware to interrupt execution every 6 milliseconds and poll the inputs, which is more than fast enough to catch the quickest press of a button.
 
@@ -96,9 +100,18 @@ If you hadn’t guessed already, a footballer represents subprogram and dribblin
 
 We will call this “passing control of execution” rather than “passing the ball”.  However, in the world of the micro:bit, the concurrently executing subprograms are not aware of each other, so they don’t actually pass control directly to one another.  Rather they pass control of execution back to the scheduler and the scheduler determines the subprogram to pass control to next.  The programmer inserts a call to the `pause` function to indicate a point in the subprogram where control of execution passes to the scheduler. Also, when a subprogram ends execution, control passes to the scheduler.
 
-Let’s take a look at the implementation of the `forever` statement to see an example of cooperative scheduling:
+Let’s take a look at the implementation of the `basic.forever` function to see an example of cooperative scheduling:
 
-![](/static/mb/device/reactive-2.png)
+```typescript
+function forever(body: () => void) {
+    control.inBackground(() => {
+        while(true) {
+            body()
+            basic.pause(20)
+        }
+    })
+}
+```
 
 The `forever` loop actually is a function that takes a subprogram (an *Action* in Touch Develop) as a parameter. The function uses the `control -> in background` function of the micro:bit runtime to queue a `while true` loop for execution by the scheduler. The while loop has two statements. The first statement runs the subprogram represented by the `body` parameter. The second statement passes control to the scheduler (requesting to “sleep” for 20 milliseconds).
 
@@ -128,15 +141,15 @@ Through this example, we have seen that the micro:bit scheduler enables you to c
 
 As a result, you can easily add a new capability to the micro:bit by just adding a new subprogram. For example, if you want to add a reset feature to the counter program, all you need to do is add a new event handler for a press of button B that sets the global variable "count" to zero, as shown below:
 
-```
+```typescript
 export function countButtonPressesWithReset() {
+    let count = 0
     input.onButtonPressed(Button.A, () => {
         count = count + 1
     })
     basic.forever(() => {
         basic.showNumber(count, 150)
     })
-    count = 0
     input.onButtonPressed(Button.B, () => {
         count = 0
     })

docs/device/usb.md

@@ -40,7 +40,7 @@ Next, compile your script:
 
 2. Open your script (find the script in **My Scripts** and click `Edit`).
 
-3. Click `compile`. Your script is converted into a hex file that you can transfer and run on your micro:bit.
+3. Click **Download**. Your script is converted into a hex file that you can transfer and run on your micro:bit.
 
 4. When prompted, choose to save the compiled file on your computer (or anywhere other than the micro:bit). Depending on which browser you are using, the download will adopt the download behaviour of that particular browser.
 
@@ -66,13 +66,13 @@ A dialogue box will appear, asking whether you would like to open or save your h
 
 **IE10**
 
-Click on compile. You will see a message “Do you want to save this .hex file.” Select **Save**.
+Click on **Download**. You will see a message “Do you want to save this .hex file.” Select **Save**.
 
 ### Mac
 
 ** Safari**
 
-When you select **compile** in Safari on Mac, your file will be downloaded to your downloads folder. Go to your downloads folder and open the file. In Safari the file will appear as unknown.txt rather than a named .hex file. Drag and drop it onto your MICROBIT drive.
+When you select **Download** in Safari on Mac, your file will be downloaded to your downloads folder. Go to your downloads folder and open the file. In Safari the file will appear as unknown.txt rather than a named .hex file. Drag and drop it onto your MICROBIT drive.
 
 ![](/static/mb/device/usb-4.jpg)
 
@@ -86,7 +86,7 @@ A dialogue box will appear, asking whether you would like to open or save your h
 
 **Chrome**
 
-When you select **compile** in Chrome, the file will be downloaded to the bottom of the browser in .hex format. Click on the small arrow and select **Show in Finder**. This will show the file in your download folder. Drag and drop the file onto your MICROBIT drive.
+When you select **Download** in Chrome, the file will be downloaded to the bottom of the browser in .hex format. Click on the small arrow and select **Show in Finder**. This will show the file in your download folder. Drag and drop the file onto your MICROBIT drive.
 
 ![](/static/mb/device/usb-7.jpg)
 

docs/docs.md

@@ -1,5 +1,7 @@
 # Documentation
 
+### @description Links to the documentation, reference and projects.
+
 ### Things to do
 
 * **[Getting Started](/getting-started)**
@@ -19,8 +21,10 @@
 ### More questions?
 
 * [Frequently Asked Question](/faq)
+* [Help Translate](/translate)
 * [Release notes](/release-notes)
 
 ### Developers
 
+* [Command Line Interface](/cli)
 * Learn about [packages](/packages)

docs/faq.md

@@ -1,9 +1,30 @@
 # Frequently Asked Questions
 
+### @description Frequently asked questions and answers from our users.
+
 ### Where can I get a BBC micro:bit?
 
 More information at [http://uk.farnell.com/bbc-microbit](http://uk.farnell.com/bbc-microbit).
 
+### How do I send feedback?
+
+Find the small bubble icon on the bottom of the editor and
+post your feedback from there!
+
+### How do I save my code?
+
+The web editor automatically saves your code in the browser cache. Simply reopen the browser and navigate to the web editor 
+to reopen your latest project. You can also open previous project stored locally through **More -> Open Project**.
+
+The project source is also stored in each compiled ``.hex`` file. Drag and drop the ``.hex`` file into the web editor to load the project.
+
+To share your project with others, you can use the **Embed** feature. It stores your project in the cloud and creates a URL that you can share with others.
+
+If you are using [Visual Studio Code](/code), all your programs are stored as files on your computer and you can use your favorite source control system as needed.
+
+## Is the web site available in other languages?
+
+You can [help us translate](/translate) the web site, documentation and blocks via our crowd-source translations! 
 
 ## Troubleshooting
 

docs/getting-started.md

@@ -1,5 +1,7 @@
 # Getting started
 
+### @description An activity for beginners to get started with the micro:bit
+
 ## ~avatar
 
 Here are some challenges for you. Arrange the blocks in the editor
@@ -33,7 +35,7 @@ When this program runs, 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! 
+Click **Download** to move your program to the BBC micro:bit! 
 Make sure to follow the instructions.
 
 ### ~button /getting-started/screen

docs/getting-started/buttons.md

@@ -37,7 +37,7 @@ You can find the letter `B` by clicking the letter `A` on the
 
 #### ~
 
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 #### Your turn!
 
@@ -65,7 +65,7 @@ input.onPinPressed(TouchPin.P0, () => {
 . . # . .`);
 });
 ```
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 ## ~hint
 

docs/getting-started/rock-paper-scissors.md

@@ -152,7 +152,7 @@ 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!
+Click **Download** to move your program to the BBC micro:bit!
 
 Have fun!
 
@@ -198,7 +198,7 @@ input.onButtonPressed(Button.B, () => {
     basic.showNumber(game.score())
 })
 ```
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 ### ~button /projects
 NEXT: PROJECTS!

docs/getting-started/screen.md

@@ -32,7 +32,7 @@ basic.forever(() => {
         `)
 });
 ```
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 ### Your turn!
 
@@ -85,7 +85,7 @@ basic.forever(() => {
         `)
 });
 ```
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 #### ~hint
 

docs/getting-started/shake.md

@@ -17,7 +17,7 @@ input.onGesture(Gesture.Shake, () => {
 # . . . #`);
 });
 ```
-Click **Compile** to move your program to the BBC micro:bit!
+Click **Download** to move your program to the BBC micro:bit!
 
 ### ~button /getting-started/coin-flipper
 NEXT: COIN FLIPPER GAME

docs/javascript.md

@@ -1,15 +1,41 @@
 # JavaScript
 
-If you already know some JavaScript, you might be interested in [the JavaScript and TypeScript languages](/js/lang).
-Otherwise, visit the cards below to starting programming JavaScript with the micro:bit:
+Visit the cards below to starting programming JavaScript and TypeScript with the micro:bit:
 
 ```codecard
 [{
-  "name": "Calling Functions",
-  "url":"/js/call"
+  "name": "Calling",
+  "url":  "/js/call"
 },{
-  "name": "Sequencing Commands",
-  "url":"/js/sequence"
+  "name": "Sequencing",
+  "url":  "/js/sequence"
+},{
+  "name": "Variables",
+  "url":  "/js/variables"
+},{
+  "name": "Operators",
+  "url": "/js/operators"
+},{
+  "name": "Statements",
+  "url": "/js/statements"
+},{
+  "name": "Functions",
+  "url": "/js/functions"
+},{
+  "name": "Types",
+  "url": "/js/types"
+},{
+  "name": "Classes",
+  "url": "/js/classes"
+},{
+  "name": "FAQ",
+  "url": "/js/faq"
 }
 ]
-```
+
+```
+
+### See Also
+
+[calling](/js/call), [sequencing](/js/sequence), [variables](/js/variables), [operators](/js/operators), [statements](/js/statements), [functions](/js/functions), 
+[types](/js/types), [classes](/js/classes), [FAQ](/js/faq)

docs/js/call.md

@@ -3,8 +3,8 @@
 The simplest way to get started in JavaScript with your micro:bit is to
 call one of the micro:bit's built-in JavaScript functions. Just like Blocks
 are organized into categories/drawers, the micro:bit functions are organized by
-namespaces, with names corresponding to the drawer names.  
-The `basic` namespace contains a number of very helpful functions:
+namespaces, with names corresponding to the drawer names.  The `basic` namespace 
+contains a number of helpful functions, such as:
 
 ```typescript
 basic.showString("Hello!")
@@ -49,7 +49,7 @@ basic.clearScreen()
 
 It's a syntax error to have a left parenthesis without the "closing" right parenthesis:
 
-```typescript
+```
 basic.clearScreen(
 ```
 

docs/js/classes.md

@@ -0,0 +1,268 @@
+# Classes
+
+Traditional JavaScript focuses on functions and prototype-based inheritance as the basic means of building up reusable components, 
+but this may feel a bit awkward to programmers more comfortable with an object-oriented approach, where classes inherit functionality 
+and objects are built from these classes.
+
+Starting with ECMAScript 2015, also known as ECMAScript 6, JavaScript programmers will be able to build their applications using 
+this object-oriented class-based approach. TypeScript, allows you to use these techniques now, compiling them 
+down to JavaScript that works across all major browsers and platforms, without having to wait for the next version of JavaScript.
+
+Let's take a look at a simple class-based example:
+
+```ts
+class Greeter {
+    greeting: string;
+    constructor(message: string) {
+        this.greeting = message;
+    }
+    greet() {
+        return "Hello, " + this.greeting;
+    }
+}
+
+let greeter = new Greeter("world");
+```
+
+We declare a new class `Greeter`. This class has three members: a property called `greeting`, a constructor, and a method `greet`.
+
+You'll notice that in the class when we refer to one of the members of the class we prepend `this.`.
+This denotes that it's a member access.
+
+In the last line we construct an instance of the `Greeter` class using `new`.
+This calls into the constructor we defined earlier, creating a new object with the `Greeter` shape, and running the constructor to initialize it.
+
+# Inheritance
+
+### ~hint
+### Inheritance is not supported yet for the micro:bit. Coming soon...
+### ~
+
+In TypeScript, we can use common object-oriented patterns.
+Of course, one of the most fundamental patterns in class-based programming is being able to extend existing classes to create new ones using inheritance.
+
+Let's take a look at an example:
+
+```ts-ignore
+class Animal {
+    name: string;
+    constructor(theName: string) { this.name = theName; }
+    move(distanceInMeters: number = 0) {
+        console.log(`${this.name} moved ${distanceInMeters}m.`);
+    }
+}
+
+class Snake extends Animal {
+    constructor(name: string) { super(name); }
+    move(distanceInMeters = 5) {
+        console.log("Slithering...");
+        super.move(distanceInMeters);
+    }
+}
+
+class Horse extends Animal {
+    constructor(name: string) { super(name); }
+    move(distanceInMeters = 45) {
+        console.log("Galloping...");
+        super.move(distanceInMeters);
+    }
+}
+
+let sam = new Snake("Sammy the Python");
+let tom: Animal = new Horse("Tommy the Palomino");
+
+sam.move();
+tom.move(34);
+```
+
+This example covers quite a few of the inheritance features in TypeScript that are common to other languages.
+Here we see the `extends` keywords used to create a subclass. 
+You can see this where `Horse` and `Snake` subclass the base class `Animal` and gain access to its features.
+
+Derived classes that contain constructor functions must call `super()` which will execute the constructor function on the base class.
+
+The example also shows how to override methods in the base class with methods that are specialized for the subclass.
+Here both `Snake` and `Horse` create a `move` method that overrides the `move` from `Animal`, giving it functionality specific to each class.
+Note that even though `tom` is declared as an `Animal`, since its value is a `Horse`, when `tom.move(34)` calls the overriding method in `Horse`:
+
+```Text
+Slithering...
+Sammy the Python moved 5m.
+Galloping...
+Tommy the Palomino moved 34m.
+```
+
+# Public, private, and protected modifiers
+
+## Public by default
+
+In our examples, we've been able to freely access the members that we declared throughout our programs.
+If you're familiar with classes in other languages, you may have noticed in the above examples 
+we haven't had to use the word `public` to accomplish this; for instance, 
+C# requires that each member be explicitly labeled `public` to be visible.
+In TypeScript, each member is `public` by default.
+
+You may still mark a member `public` explicitly.
+We could have written the `Animal` class from the previous section in the following way:
+
+```ts-ignore
+class Animal {
+    public name: string;
+    public constructor(theName: string) { this.name = theName; }
+    public move(distanceInMeters: number) {
+        console.log(`${this.name} moved ${distanceInMeters}m.`);
+    }
+}
+```
+
+## Understanding `private`
+
+When a member is marked `private`, it cannot be accessed from outside of its containing class. For example:
+
+```ts-ignore
+class Animal {
+    private name: string;
+    constructor(theName: string) { this.name = theName; }
+}
+
+new Animal("Cat").name; // Error: 'name' is private;
+```
+
+TypeScript is a structural type system.
+When we compare two different types, regardless of where they came from, if the types of all members are compatible, then we say the types themselves are compatible.
+
+However, when comparing types that have `private` and `protected` members, we treat these types differently.
+For two types to be considered compatible, if one of them has a `private` member, 
+then the other must have a `private` member that originated in the same declaration.
+The same applies to `protected` members.
+
+Let's look at an example to better see how this plays out in practice:
+
+```ts-ignore
+class Animal {
+    private name: string;
+    constructor(theName: string) { this.name = theName; }
+}
+
+class Rhino extends Animal {
+    constructor() { super("Rhino"); }
+}
+
+class Employee {
+    private name: string;
+    constructor(theName: string) { this.name = theName; }
+}
+
+let animal = new Animal("Goat");
+let rhino = new Rhino();
+let employee = new Employee("Bob");
+
+animal = rhino;
+animal = employee; // Error: 'Animal' and 'Employee' are not compatible
+```
+
+In this example, we have an `Animal` and a `Rhino`, with `Rhino` being a subclass of `Animal`.
+We also have a new class `Employee` that looks identical to `Animal` in terms of shape.
+We create some instances of these classes and then try to assign them to each other to see what will happen.
+Because `Animal` and `Rhino` share the `private` side of their shape from the same declaration of 
+`private name: string` in `Animal`, they are compatible. However, this is not the case for `Employee`.
+When we try to assign from an `Employee` to `Animal` we get an error that these types are not compatible.
+Even though `Employee` also has a `private` member called `name`, it's not the one we declared in `Animal`.
+
+## Understanding `protected`
+
+The `protected` modifier acts much like the `private` modifier with the exception that members 
+declared `protected` can also be accessed by instances of deriving classes. For example,
+
+```ts-ignore
+class Person {
+    protected name: string;
+    constructor(name: string) { this.name = name; }
+}
+
+class Employee extends Person {
+    private department: string;
+
+    constructor(name: string, department: string) {
+        super(name);
+        this.department = department;
+    }
+
+    public getElevatorPitch() {
+        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
+    }
+}
+
+let howard = new Employee("Howard", "Sales");
+console.log(howard.getElevatorPitch());
+console.log(howard.name); // error
+```
+
+Notice that while we can't use `name` from outside of `Person`, 
+we can still use it from within an instance method of `Employee` because `Employee` derives from `Person`.
+
+A constructor may also be marked `protected`.
+This means that the class cannot be instantiated outside of its containing class, but can be extended. For example,
+
+```ts-ignore
+class Person {
+    protected name: string;
+    protected constructor(theName: string) { this.name = theName; }
+}
+
+// Employee can extend Person
+class Employee extends Person {
+    private department: string;
+
+    constructor(name: string, department: string) {
+        super(name);
+        this.department = department;
+    }
+
+    public getElevatorPitch() {
+        return `Hello, my name is ${this.name} and I work in ${this.department}.`;
+    }
+}
+
+let howard = new Employee("Howard", "Sales");
+let john = new Person("John"); // Error: The 'Person' constructor is protected
+```
+
+# Readonly modifier
+
+You can make properties readonly by using the `readonly` keyword.
+Readonly properties must be initialized at their declaration or in the constructor.
+
+```ts-ignore
+class Octopus {
+    readonly name: string;
+    readonly numberOfLegs: number = 8;
+    constructor (theName: string) {
+        this.name = theName;
+    }
+}
+let dad = new Octopus("Man with the 8 strong legs");
+dad.name = "Man with the 3-piece suit"; // error! name is readonly.
+```
+
+## Parameter properties
+
+In our last example, we had to declare a readonly member `name` and a constructor parameter `theName` in the `Octopus` class, and we then immediately set `name` to `theName`.
+This turns out to be a very common practice.
+*Parameter properties* let you create and initialize a member in one place.
+Here's a further revision of the previous `Octopus` class using a parameter property:
+
+```ts-ignore
+class Octopus {
+    readonly numberOfLegs: number = 8;
+    constructor(readonly name: string) {
+    }
+}
+```
+
+Notice how we dropped `theName` altogether and just use the shortened `readonly name: string` parameter on the constructor to create and initialize the `name` member.
+We've consolidated the declarations and assignment into one location.
+
+Parameter properties are declared by prefixing a constructor parameter with an accessibility modifier or `readonly`, or both.
+Using `private` for a parameter property declares and initializes a private member; likewise, the same is done for `public`, `protected`, and `readonly`.
+

docs/js/faq.md

@@ -0,0 +1,58 @@
+# Frequently asked questions
+
+# What is the language supported for the micro:bit?
+
+For the micro:bit, we support a "static" subset of TypeScript (itself a superset of JavaScript):
+
+## Supported language features
+
+* variables with `let`, `const`, and `var`
+* functions with lexical scoping and recursion
+* top-level code in the file; hello world really is `console.log("Hello world")`
+* `if ... else if ... else` statements
+* `while` and `do ... while` loops
+* `for(;;)` loops (see below about `for ... in/of`)
+* `break/continue`; also with labeled loops
+* `switch` statement (on numbers only)
+* `debugger` statement for breakpoints
+* conditional operator `? :`; lazy boolean operators
+* namespaces (a form of modules) 
+* all arithmetic operators (including bitwise operators); note that in microcontroller targets
+  all arithmetic is performed on integers, also when simulating in the browser
+* strings (with a few common methods)
+* [string templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) (`` `x is ${x}` ``)
+* arrow functions `() => ...`
+* classes with fields, methods and constructors; `new` keyword
+* array literals `[1, 2, 3]`
+* enums
+
+## Unsupported language features
+
+We generally stay away from the more dynamic parts of JavaScript. 
+Things you may miss and we may implement:
+
+* exceptions (`throw`, `try ... catch`, `try ... finally`)
+* `for ... of` statements
+* object literals `{ foo: 1, bar: "two" }`
+* method-like properties (get/set accessors)
+* class inheritance
+
+For JS-only targets we may implement the following:
+
+* regular expressions
+* classes implementing interfaces
+
+Things that we are not very likely to implement:
+
+* file-based modules (`import * from ...`, `module.exports` etc); we do support namespaces
+* spread operator
+* `yield` expression and ``function*``
+* `await` expression and `async function`
+* `typeof` expression
+* tagged templates ``tag `text ${expression} more text` ``; regular templates are supported
+* binding with arrays or objects: `let [a, b] = ...; let { x, y } = ...`
+* `with` statement
+* `eval`
+* `delete` statement
+* `for ... in` statements
+* JSX (HTML as part of JavaScript)

docs/js/functions.md

@@ -0,0 +1,161 @@
+# Functions
+
+Functions are the fundamental building block of programs. Here is the simplest
+way to make a function that adds two numbers:
+
+```ts
+// Named function
+function add(x : number, y : number) {
+    return x + y;
+}
+
+basic.showNumber(add(1, 2))
+```
+
+### ~ hint
+For the micro:bit, you must specify a [type](/js/types) for each function parameter. 
+### ~ 
+
+Functions can refer to variables outside of the function body.
+When they do so, they're said to `capture` these variables.
+
+```ts
+let z = 100;
+
+function addToZ(x: number, y: number) {
+    return x + y + z;
+}
+
+basic.showNumber(addToZ(1, 2))
+```
+
+## Typing the function
+
+Let's add a return type to our add function:
+
+```ts
+function add(x: number, y: number): number {
+    return x + y;
+}
+```
+
+TypeScript can figure the return type out by looking at the return statements, so you can optionally leave this off in many cases.
+
+# Optional and Default Parameters
+
+In TypeScript, the number of arguments given to a function has to match the number of parameters the function expects.
+
+```ts-ignore
+function buildName(firstName: string, lastName: string) {
+    return firstName + " " + lastName;
+}
+
+let result1 = buildName("Bob");                  // error, too few parameters
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");         // ah, just right
+```
+
+In JavaScript, every parameter is optional, and users may leave them off as they see fit.
+When they do, their value is `undefined`.
+We can get this functionality in TypeScript by adding a `?` to the end of parameters we want to be optional.
+For example, let's say we want the last name parameter from above to be optional:
+
+```ts-ignore
+function buildName(firstName: string, lastName?: string) {
+    if (lastName)
+        return firstName + " " + lastName;
+    else
+        return firstName;
+}
+
+let result1 = buildName("Bob");                  // works correctly now
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");         // ah, just right
+```
+
+Any optional parameters must follow required parameters.
+Had we wanted to make the first name optional rather than the last name, we would need to change the order of parameters in the function, putting the first name last in the list.
+
+In TypeScript, we can also set a value that a parameter will be assigned if the user does not provide one, or if the user passes `undefined` in its place.
+These are called default-initialized parameters.
+Let's take the previous example and default the last name to `"Smith"`.
+
+```ts-ignore
+function buildName(firstName: string, lastName = "Smith") {
+    return firstName + " " + lastName;
+}
+
+let result1 = buildName("Bob");                  // works correctly now, returns "Bob Smith"
+let result2 = buildName("Bob", undefined);       // still works, also returns "Bob Smith"
+let result3 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result4 = buildName("Bob", "Adams");         // ah, just right
+```
+
+Default-initialized parameters that come after all required parameters are treated as optional, and just like optional parameters, can be omitted when calling their respective function.
+This means optional parameters and trailing default parameters will share commonality in their types, so both
+
+```ts
+function buildName(firstName: string, lastName?: string) {
+    // ...
+}
+```
+
+and
+
+```ts
+function buildName(firstName: string, lastName = "Smith") {
+    // ...
+}
+```
+
+share the same type `(firstName: string, lastName?: string) => string`.
+The default value of `lastName` disappears in the type, only leaving behind the fact that the parameter is optional.
+
+Unlike plain optional parameters, default-initialized parameters don't *need* to occur after required parameters.
+If a default-initialized parameter comes before a required parameter, users need to explicitly pass `undefined` to get the default initialized value.
+For example, we could write our last example with only a default initializer on `firstName`:
+
+```ts-ignore
+function buildName(firstName = "Will", lastName: string) {
+    return firstName + " " + lastName;
+}
+
+let result1 = buildName("Bob");                  // error, too few parameters
+let result2 = buildName("Bob", "Adams", "Sr.");  // error, too many parameters
+let result3 = buildName("Bob", "Adams");         // okay and returns "Bob Adams"
+let result4 = buildName(undefined, "Adams");     // okay and returns "Will Adams"
+```
+
+# Rest Parameters
+
+Required, optional, and default parameters all have one thing in common: they talk about one parameter at a time.
+Sometimes, you want to work with multiple parameters as a group, or you may not know how many parameters a function will ultimately take.
+In JavaScript, you can work with the arguments directly using the `arguments` variable that is visible inside every function body.
+
+In TypeScript, you can gather these arguments together into a variable:
+
+```ts-ignore
+function buildName(firstName: string, ...restOfName: string[]) {
+    return firstName + " " + restOfName.join(" ");
+}
+
+let employeeName = buildName("Joseph", "Samuel", "Lucas", "MacKinzie");
+```
+
+*Rest parameters* are treated as a boundless number of optional parameters.
+When passing arguments for a rest parameter, you can use as many as you want; you can even pass none.
+The compiler will build an array of the arguments passed in with the name given after the ellipsis (`...`), allowing you to use it in your function.
+
+The ellipsis is also used in the type of the function with rest parameters:
+
+```ts-ignore
+function buildName(firstName: string, ...restOfName: string[]) {
+    return firstName + " " + restOfName.join(" ");
+}
+
+let buildNameFun: (fname: string, ...rest: string[]) => string = buildName;
+```
+
+### ~button /js/types
+NEXT: Types
+### ~

docs/js/lang.md

@@ -1,75 +0,0 @@
-# JavaScript and TypeScript
-
-You can write micro:bit programs in a subset of [TypeScript](https://www.typescriptlang.org), a superset of JavaScript.
-Many micro:bit programs, especially at the beginner's level, are just plain JavaScript. TypeScript introduces class-based 
-object-oriented programming, such as:
-
-```typescript
-class Greeter {
-    greeting: string;
-    constructor(message: string) {
-        this.greeting = message;
-    }
-    greet() {
-        return "Hello, " + this.greeting;
-    }
-}
-
-let greeter = new Greeter("world");
-basic.showString(greeter.greet())
-```
-
-This site is meant for teaching programming first, and JavaScript second. For this
-reason, we have stayed away from concepts that are specific to JavaScript (for
-example, prototype inheritance), and instead focused on ones common to most
-modern programming languages (for example, loops, lexically scoped variables,
-functions, classes, lambdas).
-
-We leverage TypeScript's [type inference](http://www.typescriptlang.org/docs/handbook/type-inference.html) so that
-students need not specify types when clear from context.
-
-## Supported language features
-
-* top-level code in the file: "Hello world!" really is just `basic.showString("Hello world!")`
-* [basic types](http://www.typescriptlang.org/docs/handbook/basic-types.html)
-* [variable declarations](http://www.typescriptlang.org/docs/handbook/variable-declarations.html): `let`, `const`, and `var`
-* [functions](http://www.typescriptlang.org/docs/handbook/functions.html) with lexical scoping and recursion
-
-### User-defined types and modules
-
-* [classes](http://www.typescriptlang.org/docs/handbook/classes.html) with fields, methods and constructors; `new` keyword
-* [enums](http://www.typescriptlang.org/docs/handbook/enums.html)
-* [namespaces](http://www.typescriptlang.org/docs/handbook/namespaces.html)  (a form of modules) 
-
-### Control-flow constructs
-
-* `if ... else if ... else` statements
-* `while` and `do ... while` loops
-* `for(;;)` loops (see below about `for ... in/of`)
-* `break/continue`; also with labeled loops
-* `switch` statement (on numbers only)
-* `debugger` statement for breakpoints
-
-### Expressions
-
-* conditional operator `? :`; lazy boolean operators
-* all arithmetic operators (including bitwise operators); note that in microcontroller targets
-  all arithmetic is performed on integers, also when simulating in the browser
-* strings (with a few common methods)
-* [string templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) (`` `x is ${x}` ``)
-* arrow functions `() => ...`
-* array literals `[1, 2, 3]`
-
-
-## Unsupported language features
-
-We generally stay away from the more dynamic parts of JavaScript. 
-Things you may miss and we may implement:
-
-* exceptions (`throw`, `try ... catch`, `try ... finally`)
-* `for ... of` statements
-* object literals `{ foo: 1, bar: "two" }`
-* method-like properties (get/set accessors)
-* class inheritance
-
-If there is something you'd like to see, please file an issue at [GitHub](http://github.com/microsoft/pxt/issues).

docs/js/operators.md

@@ -0,0 +1,30 @@
+## Operators
+
+The following JavaScript operators are supported for the micro:bit.
+
+### ~hint
+Note that for the micro:bit all arithmetic is performed on integers, rather than floating point.
+This also is true when simulating in the browser.
+### ~
+
+# Assignment, arithmetic and bitwise
+
+* assignment operators - [read more](http://devdocs.io/javascript/operators/assignment_operators)
+* arithmetic operators - [read more](http://devdocs.io/javascript/operators/arithmetic_operators) 
+* bitwise operators - [read more](http://devdocs.io/javascript/operators/bitwise_operators)
+
+# Comparision and conditional
+
+* comparison operators - [read more](http://devdocs.io/javascript/operators/comparison_operators)
+* conditional operator - [read more](http://devdocs.io/javascript/operators/conditional_operator)
+
+## More
+
+* lambda functions `() => { ... }`
+* array literals `[1, 2, 3]`
+* strings, with a few common methods
+* [string templates](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Template_literals) (`` `x is ${x}` ``)
+
+### ~button /js/statements
+NEXT: Statements
+### ~

docs/js/sequence.md

@@ -1,6 +1,6 @@
-# Sequencing commands
+# Sequencing
 
-By calling one function after another, you can create an animation:
+By calling one function after another, in sequence, you can create an animation:
 
 ```typescript
 basic.showLeds(`
@@ -9,17 +9,55 @@ basic.showLeds(`
     . . # . .
     # . . . #
     . # # # .
-    `)
+    `);
 basic.showLeds(`
     . # . # .
     . . . . .
     . . . . .
     . # # # .
     # . . . #
-    `)
+    `);
 ```
 
-## The Semicolon
+### The semicolon 
 
-Coming soon...
+In JavaScript, the semicolon (;) is used to terminate (or end) a statement. However, in most
+cases, the semicolon is optional and can be omitted. So both code sequences below are 
+legal:
 
+```typescript
+basic.showNumber(1)
+basic.showNumber(2)
+```
+
+```typescript
+basic.showNumber(1); 
+basic.showNumber(2);
+```
+
+### The empty statement
+
+In JavaScript, there is the concept of an *empty statement*, which is whitespace followed by
+a semicolon in the context where a statement is expected.
+So, the following code is an infinite loop
+followed by a call to `showNumber` that will never execute:
+```typescript
+while(true) ;  
+basic.showNumber(1);
+```
+
+
+### ~hint
+For the micro:bit, we don't allow a program to contain an empty statement, such as shown above. 
+If you really want an empty statement, you need to use curly braces to delimit an empty statement block:
+```typescript
+while(true) { } 
+basic.showNumber(1);
+```
+### ~
+
+[Read more](http://inimino.org/~inimino/blog/javascript_semicolons) about semicolons in JavaScript.
+
+### ~button /js/variables
+NEXT: Variable Declarations
+### ~

docs/js/statements.md

@@ -0,0 +1,33 @@
+# Statements
+
+The following JavaScript statements are supported for the micro:bit:
+
+## Variable declarations
+* `const` statement - [read more](http://devdocs.io/javascript/statements/const)
+* `let` statement - [read more](http://devdocs.io/javascript/statements/let)
+* `var` statement - [read more](http://devdocs.io/javascript/statements/var)
+
+## Block-structured statements
+
+* `{ }` block statement - [read more](http://devdocs.io/javascript/statements/block)
+* `if-else` conditional statement - [read more](http://devdocs.io/javascript/statements/if...else)
+* `while` loop - [read more](http://devdocs.io/javascript/statements/do...while)
+* `do-while` loop - [read more](http://devdocs.io/javascript/statements/do...while)
+* `for(;;)` loop - [read more](http://devdocs.io/javascript/statements/for)
+* `switch` statement (on numbers only) - [read more](http://devdocs.io/javascript/statements/switch)
+
+## Control-flow commands
+
+* `break` statement - [read more](http://devdocs.io/javascript/statements/break)
+* `continue` statement - [read more](http://devdocs.io/javascript/statements/continue)
+* `return` statement - [read more](http://devdocs.io/javascript/statements/return)
+* `debugger` statement for breakpoints - [read more](http://devdocs.io/javascript/statements/debugger)
+
+## Labelling statements
+
+* labelled statement - [read more](http://devdocs.io/javascript/statements/label)
+* `default` statement - [read more](http://devdocs.io/javascript/statements/default)
+
+### ~button /js/functions
+NEXT: Functions
+### ~

docs/js/types.md

@@ -0,0 +1,140 @@
+# Types
+
+For programs to be useful, we need to be able to work with some of the simplest units of data: 
+numbers, strings, structures, boolean values, and the like.
+
+# Boolean
+
+The most basic datatype is the simple true/false value, which is called a `boolean` value.
+
+```ts
+let isDone: boolean = false;
+```
+
+# Number
+
+### ~ hint 
+In JavaScript, `numbers` are floating point values.
+However, for the micro:bit, `numbers` are integer values.
+### ~
+
+Integer values can be specified via decimal, hexadecimal and octal notation:
+
+```ts
+let decimal: number = 42;
+let hex: number = 0xf00d;
+let binary: number = 0b1010;
+let octal: number = 0o744;
+```
+
+# String
+
+As in other languages, we use the type `string` to refer to textual data.
+Use double quotes (`"`) or single quotes (`'`) to surround string data.
+
+```ts
+let color: string = "blue";
+color = 'red';
+```
+
+You can also use *template strings*, which can span multiple lines and have embedded expressions.
+These strings are surrounded by the backtick/backquote (`` ` ``) character, and embedded expressions are of the form `${ expr }`.
+
+```ts
+let fullName: string = `Bob Bobbington`;
+let age: number = 37;
+let sentence: string = `Hello, my name is ${ fullName }.
+
+I'll be ${ age + 1 } years old next month.`
+```
+
+This is equivalent to declaring `sentence` like so:
+
+```ts
+let sentence: string = "Hello, my name is " + fullName + ".\n\n" +
+    "I'll be " + (age + 1) + " years old next month."
+```
+
+# Array
+
+Arrays allow you to work with an expandable sequence of values, addressed by an integer-valued index.
+Array types can be written in one of two ways.
+In the first, you use the type of the elements followed by `[]` to denote an array of that element type:
+
+```ts
+let list: number[] = [1, 2, 3];
+```
+
+The second way uses a generic array type, `Array<elemType>`:
+
+```ts
+let list: Array<number> = [1, 2, 3];
+```
+
+### ~hint
+For the micro:bit, all elements of an array must have the same type.
+### ~
+
+
+# Enum
+
+A helpful addition to the standard set of datatypes from JavaScript is the `enum`.
+As in languages like C#, an enum is a way of giving more friendly names to sets of numeric values.
+
+```ts
+enum Color {Red, Green, Blue};
+let c: Color = Color.Green;
+```
+
+By default, enums begin numbering their members starting at `0`.
+You can change this by manually setting the value of one of its members.
+For example, we can start the previous example at `1` instead of `0`:
+
+```ts
+enum Color {Red = 1, Green, Blue};
+let c: Color = Color.Green;
+```
+
+Or, even manually set all the values in the enum:
+
+```ts
+enum Color {Red = 1, Green = 2, Blue = 4};
+let c: Color = Color.Green;
+```
+
+# Any
+
+The TypeScript type `any` is not supported in the micro:bit.
+
+
+# Void
+
+`void` is the absence of having any type at all.
+You may commonly see this as the return type of functions that do not return a value:
+
+```ts
+function warnUser(): void {
+    basic.showString("This is my warning message");
+}
+```
+
+Declaring variables of type `void` is not useful.
+
+# Type Inference
+
+In TypeScript, there are several places where type inference is used to provide type information when there is
+no explicit type annotation. For example, in this code
+
+```ts
+let x = 3;
+let y = x + 3
+```
+
+The type of the `x` variable is inferred to be `number`. Similarly, the type of `y` variable also is inferred to be `number`.
+This kind of inference takes place when initializing variables and members, 
+setting parameter default values, and determining function return types.
+
+
+### ~button /js/classes
+NEXT: Classes
+### ~

docs/js/variables.md

@@ -0,0 +1,121 @@
+# Variable Declarations
+
+Declaring a variable in JavaScript has always traditionally been done with the `var` keyword.
+
+```typescript
+var a = 10;
+```
+
+The `var` construct has some [problems](http://www.typescriptlang.org/docs/handbook/variable-declarations.html), 
+which is why `let` statements were introduced. Apart from the keyword used, `let` statements are written 
+the same way `var` statements are.
+
+```typescript
+let a = 10;
+```
+
+The key difference is not in the syntax, but in the semantics, which we'll now dive into.
+
+## Block-scoping
+
+When a variable is declared using `let`, it uses what some call *lexical-scoping* or *block-scoping*.
+Unlike variables declared with `var` whose scopes leak out to their containing function, 
+block-scoped variables are not visible outside of their nearest containing block or `for`-loop.
+
+```typescript
+function f(input: boolean) {
+    let a = 100;
+
+    if (input) {
+        // Still okay to reference 'a'
+        let b = a + 1;
+        return b;
+    }
+
+    // Error: 'b' doesn't exist here
+    return b;
+}
+```
+
+Here, we have two local variables `a` and `b`.
+`a`'s scope is limited to the body of `f` while `b`'s scope is limited to the containing `if` statement's block.
+
+Another property of block-scoped variables is that they can't be read or written to before they're actually declared.
+While these variables are "present" throughout their scope, all points up until their declaration are part of their *temporal dead zone*.
+This is just a sophisticated way of saying you can't access them before the `let` statement, and luckily TypeScript will let you know that.
+
+```typescript-ignore
+a++; // illegal to use 'a' before it's declared;
+let a;
+```
+
+## Re-declarations
+
+With `var` declarations, it doesn't matter how many times you declare your variables, you just get one:
+
+```typescript
+var x = 10;
+var x = 20; 
+```
+
+In the above example, all declarations of `x` actually refer to the *same* `x`, and this is perfectly valid.
+This often ends up being a source of bugs. Thankfully, `let` declarations are not as forgiving.
+
+```typescript
+let x = 10;
+let x = 20; // error: can't re-declare 'x' in the same scope
+```
+
+## Shadowing
+
+The act of introducing a new name in a more deeply nested scope is called *shadowing*.
+It is a bit of a double-edged sword in that it can introduce certain bugs on its own in the 
+event of accidental shadowing, while also preventing certain bugs.
+For instance, imagine a `sumMatrix` function using `let` variables.
+
+```typescript
+function sumMatrix(matrix: number[][]) {
+    let sum = 0;
+    for (let i = 0; i < matrix.length; i++) {
+        var currentRow = matrix[i];
+        for (let i = 0; i < currentRow.length; i++) {
+            sum += currentRow[i];
+        }
+    }
+
+    return sum;
+}
+```
+
+This version of the loop will actually perform the summation correctly because the inner loop's `i` shadows `i` from the outer loop.
+Shadowing should *usually* be avoided in the interest of write clearer code, such as
+
+```typescript
+function sumMatrix(matrix: number[][]) {
+    let sum = 0;
+    for (let i = 0; i < matrix.length; i++) {
+        var currentRow = matrix[i];
+        for (let j = 0; j < currentRow.length; j++) {
+            sum += currentRow[j];
+        }
+    }
+
+    return sum;
+}
+```
+While there are some scenarios where it may be fitting to take advantage of it, you should use your best judgement.
+
+# `const` declarations
+
+`const` declarations are another way of declaring variables.
+
+```typescript
+const numLivesForCat = 9;
+```
+
+They are like `let` declarations but, as their name implies, their value cannot be changed once they are bound.
+In other words, they have the same scoping rules as `let`, but you can't re-assign to them.
+
+### ~button /js/operators
+NEXT: Operators
+### ~

docs/lessons.md

@@ -1,5 +1,7 @@
 # Lessons 
 
+### @description Lessons to teach computer science and coding.
+
 ### @short Lessons
 
 ### ~column 

docs/lessons/blocks-conditions.md

@@ -4,9 +4,11 @@ An introduction to conditions for the Block Editor.
 
 ## Introduction to conditions
 
-In the introduction to code, we made the BBC micro:bit automatically shows the message ‘hello, world!’:
+In the introduction to code, we made the BBC micro:bit automatically shows the message ‘hello world!’:
 
-![](/static/mb/blocks/lessons/blocks-conditions-0.png)
+```blocks
+basic.showString("hello world!")
+```
 
 This statement, or code, will happen as soon as the BBC micro:bit is activated. This means it is unconditional. We can add a condition to make code function in certain ways:
 
@@ -16,11 +18,13 @@ This statement, or code, will happen as soon as the BBC micro:bit is activated.
 
 In programming we use an ‘if’ statement: if this condition is met, do something. Lets add an if statement to the code we had before; the BBC Micro:bit will wait for the user to press a button before showing the image.
 
-### Write the code
-
-Click the **if** category and drag an `if/do` block. Drag the`show string` block we wrote previously into the `do` section of the block. Next click the **input** tab and drag a `button pressed` block, connect it to the open jigsaw of the `if` block. This is our criteria: `if A button is pressed`. We can change which button (button A or B) by clicking the arrow next to ‘A’ and changing the value. This means our BBC micro:bit is waiting for button A (the left button) to be pressed. Finally go to the **basic** tab and drag a `forever` block, and attach all our code inside. We add this block to ensure the BBC micro:bit is always waiting to show us this message, not just once. Your code should look like this:
-
-![](/static/mb/blocks/lessons/blocks-conditions-1.png)
+```blocks
+basic.forever(() => {
+    if (input.buttonIsPressed(Button.A)) {
+        basic.showString("hello world!")
+    }
+})
+```
 
 Again, test the code in the simulator. Try clicking **Button A** to display the "hello, world!" message every time the `button is pressed`.
 
@@ -40,9 +44,17 @@ For example, we could make it so our BBC Micro:bit tells us to press the A butto
 
 We want the message "Press A!" to scroll across the BBC micro:bit, so right-click the `show string` block and select **Duplicate**. Drag this new block into the `else` section and replace the “hello, world!” with "Press A!". Your code should look like this:
 
-![](/static/mb/blocks/lessons/blocks-conditions-2.png)
+```blocks
+basic.forever(() => {
+    if (input.buttonIsPressed(Button.A)) {
+        basic.showString("hello world!")
+    } else {
+        basic.showString("PRESS A")        
+    }
+})
+```
 
-So, to recap: the `forever` block makes sure our code runs forever. The BBC micro:bit checks if the user is pressing the left button, if the user is not then the “Press the button!” message will scroll across the LEDs. If the user is pressing the button then the “hello, world!” message will scroll across the screen. Check this in the simulator or attach the BBC micro:bit to the computer then click **compile** to send the code onto the BBC micro:bit.
+So, to recap: the `forever` block makes sure our code runs forever. The BBC micro:bit checks if the user is pressing the left button, if the user is not then the “Press the button!” message will scroll across the LEDs. If the user is pressing the button then the “hello, world!” message will scroll across the screen. Check this in the simulator or attach the BBC micro:bit to the computer then click **Download** to send the code onto the BBC micro:bit.
 
 ## What is a condition?
 

docs/lessons/bop-it/activity.md

@@ -62,7 +62,7 @@ export function newAction() {
 
 Now let's implement `PRESS PIN 0` in the main. Create a condition of `input->on pin pressed("P0")` that will add one to the score and calls the method `new action`.
 
-```
+```blocks
 // **. . .**
 input.onButtonPressed(Button.B, () => {
     basic.showNumber(game.score(), 150) // ***

docs/lessons/challenges.md

@@ -1,88 +0,0 @@
-# blocks - challenges
-
-Extra stuff for the Block Editor - an introduction to GPIO
-
-## Before we get started
-
-This section details challenges for the BBC micro:bit. Ensure you have completed all other sections of the Microsoft Block Editor tutorials before attempting these challenges!
-
-## Quiz Challenge [1]
-
-Using if statements, try to add more statements to create a simple quiz. The user will be told if the question is right or not, and will have two options (button A and button B).
-
-Here is some sample code for a simple quiz:
-
-![](/static/mb/blocks/lessons-0.png)
-
-## Timer Challenge [2]
-
-Create a timer that runs out after a certain amount of time (using the *count* loop). For an extra challenge, let the user input the amount of seconds they want the timer to run for using variables and the buttons as input. The solution is below.
-
-![](/static/mb/blocks/lessons-1.png)
-
-## Graphics Challenges [3]
-
-Using the knowledge you have learnt from the [rendering graphics](/lessons/graphics) section, try creating an algorithm to draw these shapes. Before you write the code try to figure out how the BBC micro:bit will be thinking to plot these points. For example, with our diagonal line – “count up from 0 to 4 by 1, and plot points x=i and y=i”.
-
-* Another diagonal line
-* A square going around the board
-* A filled square
-* A square which unplots itself after
-* A filled square which then unplots itself
-
-The solutions are below.
-
-### Square [3.1]
-
-![](/static/mb/blocks/lessons-2.png)
-
-### Filled square [3.2]
-
-![](/static/mb/blocks/lessons-3.png)
-
-### Vanishing square [3.3]
-
-Use the same code and algorithm for the square solution, only use the ‘unplot’ block to make this LED turn off again. You could also reverse the algorithm.
-
-### Vanishing filled square [3.4]
-
-Use the same code and algorithm for the filled square solution, only use the `unplot` block to make this LED turn off again. You could also reverse the algorithm.
-
-## Animation Challenge [4]
-
-Use your new knowledge of animations and algorithms to program your BBC micro:bit to act human: for example, you could make your BBC micro:bit smile and wink. Remember you can display images with the `show image` and `create image` blocks. Sample code is below.
-
-![](/static/mb/blocks/lessons-4.png)
-
-## Electronic Dice Challenge [5]
-
-Using the code in the Random Numbers tutorial in Section 6, or your own algorithm, create an electronic dice that displays the values appropriate for a dice (so 1 shows a single LED on in the center, two shows two LEDs on at each corner, etc.). You may want to declare image variables to do this, then check what it is equal to using an ‘if’ statement. Sample code is below.
-
-![](/static/mb/blocks/lessons-4.png)
-
-## Calculator Challenge [6]
-
-Using your knowledge of loops, counters and math, create a calculator.
-
-The calculator should:
-
-* Count the amount of times the user presses the left button before pressing the right button (this is the first value, or valueOne)
-* Count the amount of times the user presses the left button before the right button again (this is the second value, or valueTwo)
-* Scroll through operations (+,-, x and divide) until the user presses the right button to make a choice
-* Perform the calculation
-* Show the entire calculation, for example: 5 + 10 = 15
-
-Sample code is below.
-
-![](/static/mb/blocks/lessons-5.png)
-
-## Smart watch Challenge [8]
-
-Create a smart watch using the BBC micro:bit. Create a menu where the user presses one button to cycle through options and another button to choose this option. Add applications to this smart watch:
-
-* Calculators
-* Games
-* Random number generators
-
-And any other applications you can think of.
-

docs/lessons/charting/challenge.md

@@ -86,3 +86,7 @@ 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" 
+
+```package
+microbit-radio
+```

docs/lessons/graphics.md

@@ -6,7 +6,9 @@ An introduction to graphics for the Block Editor.
 
 Ensure you have completed the 'Hello, world!' and Loop tutorials and tested them on a simulator or on BBC micro:bit.
 
-![](/static/mb/blocks/lessons/blocks-conditions-0.png)
+```blocks
+basic.showString("HI!");
+```
 
 The BBC micro:bit has a grid of 25 LEDs, so we can use these to display images.
 
@@ -24,9 +26,16 @@ We can also code our bug to plot a point by giving an x (horizontal) and y (vert
 
 We can also unplot a point (turn the LED off again) using the `unplot` block. So we could create a flashing LED program, using the `pause` block to create a delay.
 
-![](/static/mb/blocks/lessons/graphics-1.png)
+```blocks
+basic.forever(() => {
+    led.plot(2,2)
+    basic.pause(100)
+    led.unplot(2,2)
+    basic.pause(100)
+})
+```
 
-We can also use the `clear screen` block to turn off all LEDs.
+We can also use the `basic.clearScreen` block to turn off all LEDs.
 
 ## Tip
 
@@ -34,26 +43,35 @@ The pause block is in milliseconds, so setting it to 1000 will have a pause of a
 
 ### Devising algorithms for shapes
 
-An algorithm is a set of steps to follow to solve a problem. We can begin to draw shapes on the BBC micro:bit using an algorithm. For example, we could draw a straight line with this code:
+An algorithm is a set of steps to follow to solve a problem. We can begin to draw shapes on the BBC micro:bit using an algorithm. 
+For example, we could draw a straight line with this code:
 
-![](/static/mb/blocks/lessons/graphics-2.png)
+```blocks
+for(let i = 0; i <=4; i++) {
+    led.plot(i, 0);
+    basic.pause(200)
+}
+```
 
 Our algorithm is: increase **i** by 1 **from 0** to **4**, and **plot** the point **x=i**, **y=0**. The pause block allows this line to be animated (drawn frame by frame).
 
-Try devising an algorithm for a diagonal line using the code above and the variable **i**. Your code should look like this; as our variable increases, so does the location that the BBC micro:bit is plotting at:
-
-![](/static/mb/blocks/lessons/graphics-3.png)
-
-We can create more complex algorithms for more complex shapes, too. See the [challenges](/lessons/challenges) section for additional graphical challenges and solutions.
+Try devising an algorithm for a diagonal line using the code above and the variable **i**.
+```sim
+basic.forever(() => {
+    for(let i = 0; i <=4; i++) {
+        led.plot(i, i);
+        basic.pause(200)
+    }
+    basic.clearScreen();
+})
+```
 
 ### Animations
 
-Animations are changes happening at a certain rate. For example, we could add the `delay` block from the **Basic** drawer with our square algorithm – this will slowly draw a square (as an animation).
+Animations are changes happening at a certain rate. For example, we could add the `pause` block from the **Basic** drawer with our square algorithm – this will slowly draw a square (as an animation).
 
 We could create more complex animations, for example we could make our BBC micro:bit display an explosion or fireworks.
 
-See the [challenges](/lessons/challenges) section for some animation tasks.
-
 ### Image variables
 
 We can create image variables so we can easily display an image at a later point. For example:

docs/lessons/happy-birthday/challenges.md

@@ -34,8 +34,7 @@ Let's code the third part of Happy Birthday!
 
 To do this, you need to add blocks after the last line of the `play` blocks. We want to continue to adding musical chords with the `play` block. Then insert the appropriate chord blocks `G`, `E`, `C`, `B`, `A` to complete the third part of the song. Modify your code so that your code looks like this.
 
-``` blocks
-
+```blocks
 music.playTone(music.noteFrequency(Note.C), music.beat(BeatFraction.Quater));
 music.playTone(music.noteFrequency(Note.C), music.beat(BeatFraction.Quater));
 music.playTone(music.noteFrequency(Note.D), music.beat(BeatFraction.Quater));
@@ -57,8 +56,7 @@ music.playTone(music.noteFrequency(Note.F), music.beat(BeatFraction.Quater));
 music.playTone(music.noteFrequency(Note.E), music.beat(BeatFraction.Quater));
 music.playTone(music.noteFrequency(Note.D), music.beat(BeatFraction.Quater));
 basic.pause(100);
-
-``` 
+```
 
 * click *run * to see if the code works as expected.
 

docs/lessons/headbands/activity.md

@@ -5,7 +5,7 @@
 Your beginning code should look like this:
 
 ```blocks 
-let coll = (<string[]>[])
+let coll: string[] = []
 coll.push("puppy")
 coll.push("clock")
 coll.push("night")
@@ -27,7 +27,7 @@ game.startCountdown(30000)
 Let's add more words for the player to act out! But first, we need to increase the time in one round to give the player more time get through all the words. Let's change the `game->start countdown` statement.
 
 ```blocks
-let coll = (<string[]>[])
+let coll: string[] = []
 coll.push("puppy")
 coll.push("clock")
 coll.push("night")
@@ -52,7 +52,8 @@ game.startCountdown(60000)
 Now let's add 5 more words to our list of charade words. Right above the the line `word:=coll->at(index)` add 5 lines that say `coll->add("")`. In this example, we will add the words **bicycle, telephone, sun, car, and ant** but you can add whatever words you like.
 
 ```blocks
-let coll.push("puppy")
+let coll: string[] = []
+coll.push("puppy")
 coll.push("clock")
 coll.push("night")
 coll.push("cat")

docs/lessons/headbands/quiz-answers.md

@@ -19,7 +19,7 @@ A 'collection' is a group of variables of the same type stored together. A 'coll
 ## 2. Consider the following lines of code.
 
 ```blocks
-let coll = (<string[]>[])
+let coll: string[] = []
 coll.push("puppy")
 coll.push("clock")
 ```
@@ -35,7 +35,7 @@ basic.showString(coll[0], 150)
 ## 3. Consider the following lines of code.
 
 ```blocks
-let coll = (<string[]>[])
+let coll: string[] = []
 coll.push("puppy")
 coll.push("clock")
 coll.push("cat")
@@ -52,7 +52,7 @@ basic.showString(coll[2], 150)
 ## 4. Consider the following line of code.
 
 ```blocks
-let coll = (<string[]>[])
+let coll: string[] = []
 ```
 
 Write the five (5) lines of code that will add the following five words to `data->coll`: puppy, clock, night, cat, cow.
@@ -60,7 +60,8 @@ Write the five (5) lines of code that will add the following five words to `data
 <br/>
 
 ```blocks
-let coll.push("puppy")
+let coll: string[] = []
+coll.push("puppy")
 coll.push("clock")
 coll.push("night")
 coll.push("cat")
@@ -72,6 +73,7 @@ coll.push("cow")
 <br/>
 
 ```blocks
+let coll: string[] = []
 let index = Math.random(coll.length)
 let word = coll[index]
 ```

docs/lessons/headbands/quiz.md

@@ -39,7 +39,7 @@ coll.push("cat")
 
 ## 4. Write the five (5) lines of code that will add the following five words to `data->coll`: puppy, clock, night, cat, cow.
 
-```
+```ts
 let coll = (<string[]>[])
 ```
 

docs/lessons/hero/activity.md

@@ -211,7 +211,7 @@ Let's setup the logic for the food and the ghost to be in different quadrants. F
 let hero = game.createSprite(2, 2);
 let food = game.createSprite(4, 4);
 let ghost = game.createSprite(0, 0);
-let ghost.change(LedSpriteProperty.Blink, 100);
+ghost.change(LedSpriteProperty.Blink, 100);
 food = led.brightness() == 8;
 while (true) {
     basic.pause(400);
@@ -265,7 +265,7 @@ while (true) {
     }
 
 }
-0.set(LedSpriteProperty.X, 4);
+ghost.set(LedSpriteProperty.X, 4);
 
 
 ```

docs/lessons/loops.md

@@ -1,59 +0,0 @@
-# blocks - loops
-
-An introduction to Loops for the Block Editor.
-
-We may want to handle the user’s input multiple times or remain waiting for their input for a long time. We use loops to make sure that our code runs multiple times. These can be found in the **Loops** drawer.
-
-### Forever loops
-
-In the Variables tutorial we utilised a forever loop to create a counter:
-
-![](/static/mb/blocks/lessons/blocks-conditions-2.png)
-
-This allows our BBC micro:bit to wait for the user to do something forever, for example wait for the user to press the correct button as the example above shows. If you were creating a quiz, you may want to loop forever until the user presses the correct button or answers the question.
-
-### Repeat Loops
-
-Repeat loops allow code to happen a certain amount of times. You may want to create a quiz that only gives the user a few tries to get the correct answer, for example. The number can be changed to facilitate your code.
-
-![](/static/mb/blocks/lessons/loops-0.png)
-
-The code above will scroll the message, “Hello world” three times.
-
-### While & Until loops
-
-The ‘repeat while’ loop allows you to continue looping some code until a condition is met. The empty socket next to the while loop allows you to connect some Logic and construct a statement.
-
-![](/static/mb/blocks/lessons/loops-1.png)
-
-The code above will scroll the message, “Press it!”, while the user hasn’t pressed the button.
-
-* Drag a `set item` block from the **Variables** drawer. Click the **down arrow** and click **New Variable**, and type "pressed". Drag a `0` block from **Maths** to set the variable **pressed** to 0.
-* Drag a `repeat while` block from the **Loops** drawer and attach an `=` block from the **Logic** drawer. Drag `item` from the **Variables** drawer and click the **down arrow**, select ‘pressed’. Drag a `0` block from Maths and connect it to the other side of the equals. This will carry out the code until ‘pressed’ does not equal 0.
-* Add a `show string` block from the **Basic** drawer and change the message to "Press it!"
-* Add an `if` block from the **Logic** drawer, connect a `button pressed` block from the **Input** drawer, and add text from the **Basic** drawer. Change this to A to show we are waiting for button A.
-* Inside the ‘do’ part of the if statement, add a `set` block from the Variables drawer, click the **down arrow** to change it to **pressed** and drag a `1` from the Maths drawer
-* Lastly underneath the while loop, add another `show string` block and fill in the gaps.
-
-Test the code above on actual hardware or on the simulator window.
-
-We can also change the code in subtle ways to have a completely different effect:
-
-![](/static/mb/blocks/lessons/loops-2.png)
-
-This time we have to press the button three times to leave the while loop.
-
-## Tip
-
-You can press the arrow next to a word in a block to change it. For example, you can change Math functions or change a Logic statement.
-
-### Count or for loops
-
-A count loop allows you to loop a certain amount of times and to change a variable as you do so. For example, we can create a simple counting program:
-
-![](/static/mb/blocks/lessons/loops-3.png)
-
-The count loop will repeat a certain amount of times whilst changing a variable. You can click the arrow next to **i** to replace it with any of your own variables. So this program will display numbers 1 to 10.
-
-This loop allows you to repeat code for the amount of times you want to without worrying about manually changing variables. You could use this for a counting program or a timer.
-

docs/lessons/pogo.md

@@ -42,3 +42,7 @@ radio.onDataReceived(() => { })
 * learn how to conditionally run code depending on whether a condition is true or not
 * learn how to run code when an input button is pressed
 * learn how to pause your code for the specified number of milliseconds
+
+```package
+microbit-radio
+```

docs/lessons/pogo/activity.md

@@ -162,3 +162,7 @@ radio.onDataReceived(() => {
 Connect the first micro:bit to your computer using your USB cable and run the pogo script on it.
 Connect the second micro:bit to your computer using your USB cable and run the pogo script on it.
 The first person and second person take turns jumping in the “y” direction while the other player uses the micro:bit to track the results on the micro:bit!
+
+```package
+microbit-radio
+```

docs/lessons/seismograph.md

@@ -33,3 +33,7 @@ radio.receiveNumber();
 * learn how to return the sum of the two numbers
 * learn how to get acceleration value in milli-gravitys 
 * learn how to read the connector value as analog as a value comprised between 0 and 1023
+
+```package
+microbit-radio
+```

docs/lessons/seismograph/activity.md

@@ -92,9 +92,7 @@ Connect a micro:bit to your computer using your USB cable
 
 ![](/static/mb/lessons/seismograph33.png)
 
-Click or tap the compile button for the seismograph program to run the program on the micro:bit. 
-
-![](/static/mb/lessons/seismograph22.png)
+Click or tap the **Download** button for the seismograph program to run the program on the micro:bit. 
 
 ## 9. 
 

docs/lessons/seismograph/challenge.md

@@ -116,7 +116,7 @@ Connect the 2nd micro:bit to your computer using your USB cable. We should have
 
 ## 8.
 
-Click or tap the compile button for the seismograph program to run the program on the 1st micro:bit and 2nd micro:bit.
+Click or tap the **Download** button for the seismograph program to run the program on the 1st micro:bit and 2nd micro:bit.
 
 ## 9. 
 
@@ -195,4 +195,6 @@ Let's select Style 10 as an example.
 * The first person and second person take shaking or moving the micor:bit in any direction while the other player charts the data on the micro:bit!
 * Review and analyze the actual micro:bit device acceleration data on Excel
 
-
+```package
+microbit-radio
+```

docs/offline.md

@@ -0,0 +1,18 @@
+# Offline editing
+
+## Web application
+
+**https://codethemicrobit.com is an HTML5 web application** that automatically gets cached locally by your browser. 
+Once the web app is loaded and you have compiled at least once, you will have all the code needed to work without an internet connection.
+
+## Command line interface
+
+For more experience users, you can download the entire toolchain and use the [command line interface](/cli) (CLI) to compile 
+and deploy your scripts locally. PXT provides a great out-of-the-box experience using [Visual Studio Code](/code), 
+a lightweight cross-platform code editor.
+
+![](/static/mb/vscode.png)
+
+## Native clients
+
+There are no native clients available yet.

docs/open-source.md

@@ -2,8 +2,18 @@
 
 The editor is open source on GitHub under the MIT license. Contributions are welcome, please check our GitHub repos.
 
-### Repos
+## Source Code
 
 * [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
+
+## C++ Runtime
+
+The [C++ 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). 
+
+## Packages
+
+* [microsoft/pxt-neopixel](https://github.com/microsoft/pxt-neopixel), package for neopixel strips
+* [microsoft/pxt-max6675](https://github.com/microsoft/pxt-max6675), package for Temperature Probe (MAX6675)

docs/packages.md

@@ -1,14 +1,19 @@
-# Extensions
+# Packages
 
 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.
 
+* [pxt-max6675](https://github.com/Microsoft/pxt-max6675) -- TypeScript
+* [pxt-neopixel](https://github.com/Microsoft/pxt-neopixel) -- TypeScript + ARM Thumb assembly package
+* [pxt-sonar](https://github.com/microsoft/pxt-sonar) -- TypeScript
+* [pxt-i2c-fram](https://github.com/microsoft/pxt-i2c-fram) -- TypeScript
+
 * [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
+## Finding packages
 
 From the editor, the user clicks on **More** then **Add Package** and searches for the package. 
 
@@ -16,11 +21,11 @@ To see the list of packages, click on **More** then **Show Files** to see the pr
 
 To remove a package, click on the garbage button in the file list next to the package.
 
-## Publishing libraries
+## Publishing packages
 
-Packages can be published from the pxt command line. We are still sorting out the details.
+Packages can be published from the pxt command line. Check out [the docs](https://www.pxt.io/packages).
 
-## Localizing libraries
+## Localizing packages
 
 It is possible to package localization strings for the **jsDoc** description associated to the API in the package.
 

docs/projects.md

@@ -14,7 +14,7 @@ Here are some cool projects that you can build with your micro:bit!
   "imageUrl": "/static/mb/projects/a2-buttons.png"
 },{
   "name": "Love Meter",
-  "url":"/projects/lover-meter",
+  "url":"/projects/love-meter",
   "imageUrl":"/static/mb/projects/a3-pins.png"
 },{
   "name": "Rock Paper Scissors",
@@ -47,5 +47,6 @@ Here are some cool projects that you can build with your micro:bit!
 }]
 ```
 
+### See Also
 
-
+[Flashing Heart](/projects/flashing-heart), [Smiley Buttons](/projects/smiley-buttons), [Love Meter](/projects/love-meter), [Rock Paper Scissors](/projects/rock-paper-scissors), [Compass](/projects/compass), [Hack your headphones](/projects/hack-your-headphones), [Banana keyboard](/projects/banana-keyboard), [Telegraph](/projects/telegraph), [Radio](/projects/radio), [Watch](/projects/the-watch)

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

@@ -69,7 +69,7 @@ input.onButtonPressed(Button.A, () => {
 });
 ```
 
-* click *compile* and run your code on the micro:bit.
+* click **Download** and run your code on the micro:bit.
 
 ### ~button /projects/banana-keyboard
 NEXT: Banana Keyboard

docs/projects/messenger.md

@@ -0,0 +1,65 @@
+# messenger
+
+![](/static/mb/projects/a9-radio.png)
+
+Use the radio to create an app that sends "YO" messages.
+
+## Step 1
+
+Use [on button pressed](/reference/input/on-button-pressed) to send the number "0" over radio.
+
+```blocks
+input.onButtonPressed(Button.A, () => {
+    radio.sendNumber(0);
+});
+```
+
+## Step 2
+
+Use [radio on data received](/reference/radio/on-data-received) display "YO" when the number ``0`` is received
+by radio.
+
+```blocks
+let message = 0;
+radio.onDataReceived(() => {
+    message = radio.receiveNumber();
+    if (message == 0) {
+        basic.showString("YO")
+    }
+})
+```
+
+Download the program and **upload the same .hex file to 2 devices!**
+
+## Step 3
+
+Use [on button pressed](/reference/input/on-button-pressed) to send the number "1" over radio.
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    radio.sendNumber(1);
+});
+```
+
+## Step 4
+
+Add blocks in [radio on data received](/reference/radio/on-data-received) to display "BYE" when the number ``1`` is received
+by radio.
+
+```blocks
+let message = 0;
+radio.onDataReceived(() => {
+    message = radio.receiveNumber();
+    if (message == 0) {
+        basic.showString("YO")
+    }
+    if (message == 1) {
+        basic.showString("BYE")
+    }
+})
+```
+
+
+```package
+microbit-radio
+```

docs/projects/radio-challenges.md

@@ -89,4 +89,8 @@ Have fun reviewing your simulation and analyze the acceleration by chart the Exc
 
 ### ~button /projects/the-watch
 NEXT: The Watch
-### ~
+### ~
+
+```package
+microbit-radio
+```

docs/projects/telegraph-challenges.md

@@ -1,12 +1,12 @@
 # telegraph activity 
 
-Build a telgraph.
+Build a telegraph.
 
 # micro:bit telegraph
 
 Have you ever tried to communicate through a telegraph? Let's try coding a "Telegraph" on two BBC micro:bits !
 
-Complete the following [guided tutorial](/projects/telegraph), your hack should look like this:
+Complete the following [tutorial](/projects/telegraph), your hack should look like this:
 
 ![](/static/mb/lessons/telegraph-0.png)
 

docs/projects/the-watch.md

@@ -148,12 +148,6 @@ Trim any leftover fabric, threads or tape.
 
 Your watch is ready!
 
-### ~avatar avatar
-
-Excellent, you're ready to continue with the [challenges](/projects/rock-paper-scissors)!
-
-### ~
-
 ### Acknowledgements
 
 Artistic design by Melinda Hoeneisen.

docs/reference.md

@@ -1,5 +1,7 @@
 # Reference
 
+### @description List of API categories available in the editors
+
 ```namespaces
 basic.showNumber(0);
 input.onButtonPressed(Button.A, () => {
@@ -22,15 +24,19 @@ control.inBackground(() => {
     
 });
 ```
-
 ## Advanced
-
+  
 ```namespaces
 devices.tellCameraTo(MesCameraEvent.TakePhoto);
 bluetooth.onBluetoothConnected(() => {});
 ```
-
+  
 ```package
+microbit-radio
 microbit-devices
 microbit-bluetooth
-```
+```
+
+### See Also
+
+[basic](/reference/basic), [input](/reference/input), [music](/reference/music), [led](/reference/led), [Math (blocks)](/blocks/math), [String](/reference/types/string), [game](/reference/game), [images](/reference/images), [pins](/reference/pins), [serial](/reference/serial), [control](/reference/control), [radio](/reference/radio), [devices](/reference/devices), [bluetooth](/reference/bluetooth)

docs/reference/String.md

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

docs/reference/basic.md

@@ -32,3 +32,7 @@ basic.showAnimation(`
 . . . . .
 `);
 ```
+
+### See Also
+
+[showNumber](/reference/basic/show-number), [showLeds](/reference/basic/show-leds), [showString](/reference/basic/show-string), [clearScreen](/reference/basic/clear-screen), [forever](/reference/basic/forever), [pause](/reference/basic/pause), [plotLeds](/reference/basic/plot-leds), [showAnimation](/reference/basic/show-animation)

docs/reference/basic/show-animation.md

@@ -23,7 +23,7 @@ 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.
 
-```
+```blocks
 basic.showAnimation(`
 . . # . . . # # # . . # # # .
 . # # . . . . . # . . . . # .
@@ -47,7 +47,7 @@ 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.
 
-```
+```blocks
 basic.showAnimation(`
 . . . . . # . . . . . . . . . . . . . # . . . . . # . . . .
 . . # . . . . . . . . . # . . . . . . . . . # . . . . . . .

docs/reference/bluetooth.md

@@ -21,4 +21,8 @@ bluetooth.onBluetoothDisconnected(() => {
 
 ```package
 microbit-bluetooth
-```
+```
+
+### See Also
+
+[startAccelerometerService](/reference/bluetooth/start-accelerometer-service), [startButtonService](/reference/bluetooth/start-button-service), [startIOPinService](/reference/bluetooth/start-io-pin-service), [startLEDService](/reference/bluetooth/start-led-service), [startMagnetometerService](/reference/bluetooth/start-magnetometer-service), [startTemperatureService](/reference/bluetooth/start-temperature-service), [uartRead](/reference/bluetooth/uart-read), [uartWrite](/reference/bluetooth/uart-write), [onBluetoothConnected](/reference/bluetooth/on-bluetooth-connected), [onBluetoothDisconnected](/reference/bluetooth/on-bluetooth-disconnected)

docs/reference/control.md

@@ -7,4 +7,9 @@ control.inBackground(() => {
     
 });
 control.reset();
+control.waitMicros(4);
 ```
+
+### See Also
+
+[inBackground](/reference/control/in-background), [reset](/reference/control/reset), [wait-micros](/reference/control/wait-micros)

docs/reference/control/wait-micros.md

@@ -0,0 +1,32 @@
+# WaitMicros
+
+Blocks the current fiber for the given amount of micro-seconds.
+
+```sig
+control.waitMicros(4)
+```
+
+### Example
+
+This program sends a 10 micro-second HIGH pulse through pin ``P0``. 
+
+```blocks
+// ensure pin is low to send a clean pulse
+pins.digitalWritePin(DigitalPin.P0, 0)
+control.waitMicros(2)
+// set pin to 1 and wait 10 micros
+pins.digitalWritePin(DigitalPin.P0, 1)
+control.waitMicros(10)
+// finish pulse
+pins.digitalWritePin(DigitalPin.P0, 0)
+```
+
+#### ~hint
+
+This function is not supported in the simulator.
+
+#### ~
+
+### See Also
+
+[pause](/reference/basic/pause)

docs/reference/devices.md

@@ -17,3 +17,11 @@ devices.onSignalStrengthChanged(() => {
     
 });
 ```
+
+```package
+microbit-devices
+```
+
+### See Also
+
+[tellCameraTo](/reference/devices/tell-camera-to), [tellRemoteControlTo](/reference/devices/tell-remote-control-to), [raiseAlertTo](/reference/devices/raise-alert-to), [onNotified](/reference/devices/on-notified), [onGamepadButton](/reference/devices/on-gamepad-button), [signalStrength](/reference/devices/signal-strength), [onSignalStrengthChanged](/reference/devices/on-signal-strength-changed)

docs/reference/devices/on-notified.md

@@ -0,0 +1,38 @@
+# On Signal Strength Changed
+
+Register code to run when the signal strength of the paired device changes.
+
+### ~hint
+
+The functions in the ``devices`` namespace allow the BBC micro:bit to communicate with a separate (remote) device, 
+such as a smartphone, over Bluetooth (Smart).
+The set of supported events will depend on the remote device and the BBC micro:bit apps available for the remote device.
+
+### ~
+
+
+```sig
+devices.onNotified(MesDeviceInfo.IncomingCall, () => {})
+```
+
+### Parameters
+
+* ``body``: code to run when the signal strength changes.
+
+### Examples
+
+Display the signal strength on screen:
+
+```blocks
+devices.onNotified(MesDeviceInfo.IncomingCall, () => {
+    basic.showString("RING RING")
+})
+```
+
+### See Also
+
+[tell remote control to](/reference/devices/tell-remote-control-to), [raise alert to](/reference/devices/raise-alert-to), [signal strength](/reference/devices/signal-strength)
+
+```package
+microbit-devices
+```

docs/reference/devices/on-signal-strength-changed.md

@@ -23,7 +23,7 @@ devices.onSignalStrengthChanged(() => {})
 
 Display the signal strength on screen:
 
-```
+```blocks
 devices.onSignalStrengthChanged(() => {
     basic.showNumber(devices.signalStrength(), 150)
 })

docs/reference/devices/tell-microphone-to.md

@@ -1,47 +0,0 @@
-# tell microphone to
-
-The tell microphone to function.
-
-Access the audio recording capabilities of the device using the ``tell microphone to`` function.
-
-The functions in the antenna namespace allow the BBC micro:bit to communicate with a separate (remote) device, such as a smartphone, over Bluetooth (Smart). The set of supported events will depend on the remote device and the BBC micro:bit apps available for the remote device.
-
-### Block Editor
-
-![](/static/mb/tell-microphone-to-0.png)
-
-### JavaScript
-
-```
-export function tellMicrophoneTo(event: string)
-```
-
-### Parameters
-
-* event - an event identifier
-
-### Event values
-
-* play
-* stop
-* pause
-* forward
-* rewind
-* volume up
-* volume down
-* previous track
-* next track
-
-### Examples
-
-To tell the connected device to start recording audio
-
-```
-devices.tellMicrophoneTo("start capture")
-```
-
-To tell the connected device to stop recording audio
-
-```
-devices.tellMicrophoneTo("stop capture")
-```

docs/reference/game.md

@@ -9,3 +9,7 @@ game.startCountdown(10000);
 game.gameOver();
 game.setScore(0);
 ```
+
+### See Also
+
+[addScore](/reference/game/change-score-by), [score](/reference/game/score), [startCountdown](/reference/game/start-countdown), [gameOver](/reference/game/game-over), [setScore](/reference/game/set-score)

docs/reference/game/clear.md

@@ -6,7 +6,7 @@ Turn off all the pixels in an [Image](/reference/images/image).
 
 ### JavaScript
 
-```
+```sig
 export function clear(img: micro_bit.Image)
 ```
 
@@ -18,7 +18,7 @@ export function clear(img: micro_bit.Image)
 
 The following example turns off the pixels of `img` when the A input button is pressed:
 
-```
+```blocks
 let img = images.createImage(`
 . . . . .
 . # # # .

docs/reference/game/game-library.md

@@ -1,148 +0,0 @@
-# Game Library
-
-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.
-
-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)
-})
-game.startCountdown(10000)
-```
-
-### [Create sprite](/reference/game/create-sprite)
-
-Create sprite with x, y coordinates and returns a LED Sprite. Create a new LED sprite.
-
-![](/static/mb/create-sprite-0.png)
-
-```
-export function createSprite(x: number, y: number) : micro_bitSprites.LedSprite
-```
-
-### [Move](/reference/game/move)
-
-Sprite move by a certain number
-
-![](/static/mb/game-library/move-0.png)
-
-```
-export function move(_this: micro_bitSprites.LedSprite, leds: number)
-```
-
-### [Turn](/reference/game/turn)
-
-Rotates a sprite to the right by a certain number of degrees
-
-![](/static/mb/game-library/turn-0.png)
-
-```
-export function turnRight(_this: micro_bitSprites.LedSprite, degrees: number)
-```
-
-Rotates a sprite to the left by a certain number of degrees
-
-```
-export function turnLeft(_this: micro_bitSprites.LedSprite, degrees: number)
-```
-
-### [Change](/reference/game/change)
-
-Sprite will change the x position by this number
-
-![](/static/mb/change-0.png)
-
-```
-export function changeXBy(_this: micro_bitSprites.LedSprite, x: number)
-```
-
-Sprite will change the y position by this number
-
-```
-export function changeYBy(_this: micro_bitSprites.LedSprite, y: number)
-```
-
-### [Set](/reference/game/set)
-
-Sprite will change the x position by this number
-
-```
-export function setX(_this: micro_bitSprites.LedSprite, x: number)
-```
-
-Sprite will change the y position by this number
-
-![](/static/mb/change-0.png)
-
-```
-export function changeYBy(_this: micro_bitSprites.LedSprite, y: number)
-```
-
-### [If on edge, bounce](/reference/game/if-on-edge-bounce)
-
-Sprite - If the sprite is on the edge, the sprite will bounce
-
-![](/static/mb/game-library/if-on-edge-bounce-0.png)
-
-```
-export function ifOnEdgeBounce(_this: micro_bitSprites.LedSprite)
-```
-
-### [Change score by](/reference/game/change-score-by)
-
-When a player achieves a goal, you can increase the game score
-
-* add score points to the current score
-
-![](/static/mb/game-library/pic1.png)
-
-```
-export function addScore(points: number)
-```
-
-### [Score](/reference/game/score)
-
-* set the current score to a particular value.
-
-```
-export function setScore(value: number)
-```
-
-* get the current score value
-
-![](/static/mb/game-library/pic2.png)
-
-```
-export function score() : number
-```
-
-### [Countdown](/reference/game/start-countdown)
-
-If your game has a time limit, you can start a countdown in which case `game->current time` returns the remaining time.
-
-* start a countdown with the maximum duration of the game in milliseconds.
-
-![](/static/mb/game-library/pic3.png)
-
-```
-export function startCountdown(ms: number)
-```
-
-### [Game over](/reference/game/game-over)
-
-If the `life` reaches zero or the time expires (see countdown), the game enters the **game over** mode. When the game is over, `game->is running` returns false
-
-* check if the game still running.
-
-```
-let running = game.isRunning()
-```
-
-You can also end the game by calling the `game -> game over` function:
-
-![](/static/mb/game-library/pic0.png)
-
-```
-game.gameOver()
-```

docs/reference/game/position.md

@@ -2,12 +2,12 @@
 
 Reports the x position of a sprite on the LED screen
 
-```
+```sig
 export function x(_this: micro_bitSprites.LedSprite) : number
 ```
 
 Reports the y position of a sprite on the LED screen
 
-```
+```sig
 export function y(_this: micro_bitSprites.LedSprite) : number
 ```

docs/reference/game/reports.md

@@ -4,24 +4,24 @@ Reports the x or y position,  the current direction of a sprite, or the brightne
 
 Reports the x position of a sprite on the LED screen
 
-```
+```sig
 export function x(_this: micro_bitSprites.LedSprite) : number
 ```
 
 Reports the y position of a sprite on the LED screen
 
-```
+```sig
 export function y(_this: micro_bitSprites.LedSprite) : number
 ```
 
 Reports the brightness of a sprite on the LED screen
 
-```
+```sig
 export function brightness(_this: micro_bitSprites.LedSprite) : number
 ```
 
 Reports the current direction of a sprite on the LED screen
 
-```
+```sig
 export function direction(_this: micro_bitSprites.LedSprite) : number
 ```

docs/reference/game/set-score.md

@@ -0,0 +1,30 @@
+# Set Score
+
+Sets the current score.
+
+```sig
+game.setScore(1)
+```
+### Parameters
+
+* a [number](/reference/types/number) that represents the new score.
+
+### Examples
+
+This program is a simple game.
+Press button ``A`` as much as possible to increase the score. 
+Press ``B`` to display the score and reset the score.
+
+```blocks
+input.onButtonPressed(Button.B, () => {
+    basic.showNumber(game.score())
+    game.setScore(0)
+})
+input.onButtonPressed(Button.A, () => {
+    game.addScore(1)
+})
+```
+
+### See Also
+
+[score](/reference/game/score), [start countdown](/reference/game/start-countdown)

docs/reference/images.md

@@ -18,3 +18,7 @@ images.createBigImage(`
 . . . . .
 `);
 ```
+
+### See Also
+
+[createImage](/reference/images/create-image), [createBigImage](/reference/images/create-big-image)

docs/reference/images/image.md

@@ -11,11 +11,16 @@ An *Image* is a matrix of pixels to show on the [LED screen](/device/screen)
 To display an image:
 
 * click `Basic` , `Show LEDs`, and tap on the LEDs`
-* when you're done, return to your code
 
-![](/static/mb/show-leds-1.png)
-
-You should see code similar to this:
+```blocks
+basic.showLeds(`
+    . . . . .
+    . # . # .
+    . . . . .
+    # . . . #
+    . # # # .
+    `)
+```
 
 ### Creating an image
 

docs/reference/images/pixel.md

@@ -6,7 +6,7 @@ Get the state of a pixel in an [Image](/reference/images/image).
 
 ### JavaScript
 
-```
+```sig
 export function pixel(_this: micro_bit.Image, x: number, y: number) : boolean
 ```
 
@@ -29,7 +29,7 @@ This example gets the state of pixel `0, 0` in the `img` variable:
 
 ### ~hide
 
-```
+```blocks
 let img = images.createImage(`
 . . # . . . . . . .
 . # . # . . . # . .
@@ -41,7 +41,7 @@ let img = images.createImage(`
 
 ### ~
 
-```
+```typescript-ignore
 let state = img.pixel(0, 0)
 ```
 

docs/reference/images/plot-frame.md

@@ -6,7 +6,7 @@ Display an [Image](/reference/images/image) on the BBC micro:bit's [LED screen](
 
 ### JavaScript
 
-```
+```sig
 export function plotFrame(_this: micro_bit.Image, index: number)
 ```
 
@@ -20,7 +20,7 @@ The `plot frame` function takes the index of the frame (if there are two frames,
 
 ### Example
 
-```
+```blocks
 let img = images.createImage(`
 # . . . # # . . . #
 . # . # . . # # # .

docs/reference/images/plot-image.md

@@ -6,7 +6,7 @@ Display an [Image](/reference/images/image) on the BBC micro:bit's [LED screen](
 
 ### JavaScript
 
-```
+```sig
 export function plotImage(_this: micro_bit.Image, xOffset: number)
 ```
 
@@ -20,7 +20,7 @@ The `show image` function has a built in delay of 400ms after display of the ima
 
 ### Example
 
-```
+```blocks
 let img = images.createImage(`
 # . . . # # . . . #
 . # . # . . # # # .

docs/reference/images/set-pixel.md

@@ -6,7 +6,7 @@ Set the on/off state of pixel in an [Image](/reference/images/image).
 
 ### JavaScript
 
-```
+```sig
 export function setPixel(_this: micro_bit.Image, x: number, y: number, value: boolean)
 ```
 
@@ -24,7 +24,7 @@ To figure out the ``x``, ``y`` coordinates, see [LED screen](/device/screen).
 
 The following example creates an image and stores it in the `img` variable. The `set pixel` function sets the centre pixel off, before `img` is shown using `show image`.
 
-```
+```blocks
 let img = images.createImage(`
 . . # . .
 . # . # .

docs/reference/images/show-frame.md

@@ -6,7 +6,7 @@ Display an [Image](/reference/images/image) on the BBC micro:bit's [LED screen](
 
 ### JavaScript
 
-```
+```sig
 export function showFrame(img: micro_bit.Image, frame: number)
 ```
 
@@ -16,11 +16,11 @@ export function showFrame(img: micro_bit.Image, frame: number)
 
 ### Difference from `plot frame`
 
-The `show frame` function is the same as [plot frame](/reference/image/plot-frame), but contains a built-in delay after the LED screen has been updated (whereas `plot frame` has no built-in delay)
+The `show frame` function is the same as [plot frame](/reference/images/plot-frame), but contains a built-in delay after the LED screen has been updated (whereas `plot frame` has no built-in delay)
 
 ### Example
 
-```
+```blocks
 let img = images.createImage(`
 # . . . # # . . . #
 . # . # . . # # # .

docs/reference/images/width.md

@@ -20,7 +20,7 @@ The following example gets the width of `img` and stores it in the `w` variable:
 
 ### ~hide
 
-```
+```blocks
 let img = images.createImage(`
 . . # . . . . . . .
 . # . # . . . # . .
@@ -32,7 +32,7 @@ let img = images.createImage(`
 
 ### ~
 
-```
+```typescript-ignore
 let w = img.width()
 ```
 
@@ -40,7 +40,7 @@ let w = img.width()
 
 The following example uses the `width` function with a [for](/blocks/loops/for) loop to show each image frame on the screen:
 
-```
+```typescript
 let img2 = images.createImage(`
 . . # . . . # # # # . # # # .
 . # # . . . . . . # . . . # .