jsonycode
diff --git a/‎00_intro.md‎
Lines changed: 4 additions & 6 deletions b/‎00_intro.md‎
Lines changed: 4 additions & 6 deletions
diff --git a/‎01_values.md‎
Lines changed: 2 additions & 2 deletions b/‎01_values.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎02_program_structure.md‎
Lines changed: 8 additions & 16 deletions b/‎02_program_structure.md‎
Lines changed: 8 additions & 16 deletions
diff --git a/‎03_functions.md‎
Lines changed: 10 additions & 24 deletions b/‎03_functions.md‎
Lines changed: 10 additions & 24 deletions
@@ -166,7 +166,7 @@ In the
 beginning, at the birth of computing, there were no programming
 languages. Programs looked something like this:
 
-```null
+```{lang: null}
 00110001 00000000 00000000
 00110001 00000001 00000001
 00110011 00000001 00000010
@@ -202,7 +202,7 @@ something in terms of job satisfaction.
 Each line of the previous program contains a
 single instruction. It could be written in English like this:
 
-```text/plain
+```{lang: "text/plain"}
 1. Store the number 0 in memory location 0.
 2. Store the number 1 in memory location 1.
 3. Store the value of memory location 1 in memory location 2.
@@ -222,7 +222,7 @@ more readable than the soup of bits, it is still rather unpleasant. It
 might help to use names instead of numbers for the instructions and
 memory locations.
 
-```text/plain
+```{lang: "text/plain"}
  Set “total” to 0.
  Set “count” to 1.
 [loop]
@@ -291,9 +291,7 @@ operations `range` and `sum` available, which respectively create a
 ((collection)) of numbers within a range and compute the sum of a
 collection of numbers:
 
-{{startCode}}
-
-```
+```{startCode: true}
 console.log(sum(range(1, 10)));
 // → 55
 ```
 
@@ -37,7 +37,7 @@ have only 2, and the weight of each increases by a factor of 2 from
 right to left. Here are the bits that make up the number 13, with the
 weights of the digits shown below them:
 
-```null
+```{lang: null}
    0   0   0   0   1   1   0   1
  128  64  32  16   8   4   2   1
 ```
@@ -287,7 +287,7 @@ backslash means a ((tab character)). Take the following string:
 
 The actual text contained is this:
 
-```null
+```{lang: null}
 This is the first line
 And this is the second
 ```
 
@@ -198,7 +198,7 @@ officially not allowed to be used as variable names, though some
 JavaScript environments do allow them. The full list of keywords and
 reserved words is rather long.
 
-```text/plain
+```{lang: "text/plain"}
 break case catch class const continue debugger
 default delete do else enum export extends false
 finally for function if implements import in
@@ -749,17 +749,13 @@ Especially
 when looping, a program often needs to “update” a variable to hold a
 value based on that variable's previous value.
 
-{{test no}}
-
-```
+```{test: no}
 counter = counter + 1;
 ```
 
 JavaScript provides a shortcut for this:
 
-{{test no}}
-
-```
+```{test: no}
 counter += 1;
 ```
 
@@ -784,9 +780,7 @@ For `counter += 1` and `counter -=
 
 It is common for code to look like this:
 
-{{test no}}
-
-```
+```{test: no}
 if (variable == "value1") action1();
 else if (variable == "value2") action2();
 else if (variable == "value3") action3();
@@ -841,7 +835,7 @@ words to clearly describe what the variable represents. These are
 pretty much your choices for writing a variable name with several
 words in it:
 
-```null
+```{lang: null}
 fuzzylittleturtle
 fuzzy_little_turtle
 FuzzyLittleTurtle
@@ -886,9 +880,7 @@ JavaScript has two ways of writing comments. To write a single-line
 comment, you can use two slash characters (`//`) and then the comment
 text after it.
 
-{{test no}}
-
-```
+```{test: no}
 var accountBalance = calculateBalance(account);
 // It's a green hollow where a river sings
 accountBalance.adjust();
@@ -964,7 +956,7 @@ headache.
 Write a ((loop)) that makes seven calls to
 `console.log` to output the following triangle:
 
-```null
+```{lang: null}
 #
 ##
 ###
@@ -1069,7 +1061,7 @@ should form a chess board.
 
 Passing this string to `console.log` should show something like this:
 
-```null
+```{lang: null}
  # # # #
 # # # # 
  # # # #
 
@@ -275,9 +275,7 @@ function value in a new place, pass it as an argument to a function,
 and so on. Similarly, a variable that holds a function is still just a
 regular variable and can be assigned a new value, like so:
 
-{{test no}}
-
-```
+```{test: no}
 var launchMissiles = function(value) {
   missileSystem.launch("now");
 };
@@ -380,7 +378,7 @@ line 4. The line after that calls `console.log` again.
 
 We could show the flow of control schematically like this:
 
-```null
+```{lang: null}
 top
    greet
         console.log
@@ -414,9 +412,7 @@ back-and-forth between two functions. Rather, it _would_ be infinite,
 if the computer had an infinite stack. As it is, we will run out of
 space, or “blow the stack”.
 
-{{test no}}
-
-```
+```{test: no}
 function chicken() {
   return egg();
 }
@@ -465,9 +461,7 @@ can be called either with two arguments or with a single argument, in
 which case the exponent is assumed to be two, and the function behaves
 like `square`.
 
-{{test wrap}}
-
-```
+```{test: wrap}
 function power(base, exponent) {
   if (exponent == undefined)
     exponent = 2;
@@ -589,9 +583,7 @@ _recursive_. Recursion allows some functions to be written in a
 different style. Take, for example, this alternative implementation of
 `power`:
 
-{{test wrap}}
-
-```
+```{test: wrap}
 function power(base, exponent) {
   if (exponent == 0)
     return 1;
@@ -730,7 +722,7 @@ To better understand how this function produces the
 effect we're looking for, let's look at all the calls to `find` that
 are made when searching for a solution for the number 13.
 
-```null
+```{lang: null}
 find(1, "1")
   find(6, "(1 + 5)")
     find(11, "((1 + 5) + 5)")
@@ -794,7 +786,7 @@ the numbers of cows and chickens on a farm, with the words `Cows` and
 `Chickens` after them, and zeros padded before both numbers so that
 they are always three digits long.
 
-```null
+```{lang: null}
 007 Cows
 011 Chickens
 ```
@@ -993,9 +985,7 @@ takes two arguments and returns their minimum.
 
 {{if interactive
 
-{{test no}}
-
-```
+```{test: no}
 // Your code here.
 
 console.log(min(0, 10));
@@ -1047,9 +1037,7 @@ Why? Can you think of a way to fix this?
 
 {{if interactive
 
-{{test no}}
-
-```
+```{test: no}
 // Your code here.
 
 console.log(isEven(50));
@@ -1108,9 +1096,7 @@ Rewrite `countBs` to make use of this new function.
 
 {{if interactive
 
-{{test no}}
-
-```
+```{test: no}
 // Your code here.
 
 console.log(countBs("BBC"));