Ran the build.java file to update the md and ipynb files. Also, changed "32 bits" to the more common "32-bit" etc.

Author: kabutz

chapter00-genesis.jsh

@@ -31,7 +31,7 @@ System.out.println("the value of colorName is " + colorName);
 
 // ## A record is a user defined type
 // here Light is defined as containing two components: a color (typed as a String) and
-// an intensity (typed as a 64 bits floating number double).
+// an intensity (typed as a 64-bit floating number double).
 record Light(String color, double intensity) {}
 
 // ### Object creation with `new`

chapter01-basic_types.jsh

@@ -5,7 +5,7 @@
 // # Basic Types
 // Java has two kinds of type,
 // - primitive types that are directly mapped to CPU basic types
-// - reference types that address of the object in memory
+// - reference types that have the address of the object in memory
 
 // ## Primitive types 
 // primitive types, written in lower case, have no method
@@ -17,25 +17,25 @@ var anotherResult = false;
 // ### char (character)
 var firstLetter = 'j';
 
-// ### int (signed 32 bits integer)
+// ### int (signed 32-bit integer)
 var numberOfLegs = 2;
 
-// ### double (64 bits floating point)
+// ### double (64-bit floating point)
 var cost = 3.78;
 
 // ### long and float
 // some more exotic types that requires a suffix (`L` or `f`)
-// long (64 bits integers) and float (32 bits floating point numbers)
+// long (64-bit integers) and float (32-bit floating point numbers)
 var longValue = 123L;
 var floatValue = 123.5f;
 
 // ### byte and short
-// you also have byte (a signed 8 bits integer) and short (a signed 16 bits short integer)
-// that are only useful to take less memory when defining an object
+// you also have byte (a signed 8-bit integer) and short (a signed 16-bit short integer)
+// that are only useful to use less memory when defining an object
 record CompactHeader(byte tag, short version) {}
 
-// when used in variables, they are promoted to 32 bits integer
-// in the following code result is a 32 bits integer (so an int)
+// when used in variables, they are promoted to a 32-bit integer.
+// In the following code, `result` is a 32-bit integer (so an int)
 short value = 12;
 var result = value + value;
 

chapter04-numbers.jsh

@@ -4,7 +4,7 @@
 
 // # Numbers
 // This chapter in not specific to Java but more on how integers and floating point numbers
-// works on CPUs like Intel 64 bits or ARM 64 bits.
+// work on CPUs like Intel 64-bit or ARM 64-bit.
 
 
 // ## Integers
@@ -65,7 +65,7 @@ System.out.println(0.1 + 0.2);
 // so you may think the value is fully represented that but that's just an illusion
 System.out.println(1.0 / 3.0);
 
-// On way to see the trick is to ask a float, a 32 bits, to be printed as a double, 64 bits.
+// On way to see the trick is to ask a float (32-bit), to be printed as a double (64-bit).
 System.out.println(1.0f / 3.0f);
 System.out.println(Float.toString(1.0f / 3.0f));
 System.out.println(Double.toString(1.0f / 3.0f));  // damn i'm unmasked

guide/chapter00-genesis.md

@@ -5,7 +5,7 @@ objects like String that have a name that starts with an uppercase letter.
 ## Types
 A primitive type is stored as value while an object is stored as
 a reference (the address of the object in memory).
-In Java, `var` create a new variable
+In Java, `var` creates a new variable
 ```java
 var maxIntensity = 1.0;   // it's a value
 var colorName = "black";  // it's a reference to String somewhere in memory
@@ -37,14 +37,14 @@ System.out.println("the value of colorName is " + colorName);
 
 ## A record is a user defined type
 here Light is defined as containing two components: a color (typed as a String) and
-an intensity (typed as a 64 bits floating number double).
+an intensity (typed as a 64-bit floating number double).
 ```java
 record Light(String color, double intensity) {}
 ```
 
 ### Object creation with `new`
-To create an object in memory, we use the operator `new` followed by the value of each record components
-the following instruction create a Light with "blue" as color and 1.0 as intensity.
+To create an object in memory, we use the operator `new` followed by the value of each record component.
+The following instruction creates a Light with "blue" as color and 1.0 as intensity.
 ```java
 var blueLight = new Light("blue", 1.0);
 System.out.println(blueLight);
@@ -72,7 +72,7 @@ System.out.println(blueLight);
 ```
 
 ### equals()
-In Java, you can ask if two objects are equals, using the method equals(Object).
+In Java, you can ask if two objects are equal, using the method equals(Object).
 The return value is a boolean (a primitive type that is either true or false).
 ```java
 var redLight = new Light("red", 0.5);
@@ -101,4 +101,4 @@ To interact with an object, we are using methods that are functions that you
 call on an object using the operator `.`.
 A Record defines methods to access the value of a component, and also
 `toString()` to get the textual representation of an object and
-`equals()` and `hashCode()` to test if two objects are equals.
+`equals()` and `hashCode()` to test if two objects are equal.

guide/chapter01-basic_types.md

@@ -1,7 +1,7 @@
 # Basic Types
 Java has two kinds of type,
 - primitive types that are directly mapped to CPU basic types
-- reference types that address of the object in memory
+- reference types that have the address of the object in memory
 
 ## Primitive types 
 primitive types, written in lower case, have no method
@@ -17,33 +17,33 @@ var anotherResult = false;
 var firstLetter = 'j';
 ```
 
-### int (signed 32 bits integer)
+### int (signed 32-bit integer)
 ```java
 var numberOfLegs = 2;
 ```
 
-### double (64 bits floating point)
+### double (64-bit floating point)
 ```java
 var cost = 3.78;
 ```
 
 ### long and float
 some more exotic types that requires a suffix (`L` or `f`)
-long (64 bits integers) and float (32 bits floating point numbers)
+long (64-bit integers) and float (32-bit floating point numbers)
 ```java
 var longValue = 123L;
 var floatValue = 123.5f;
 ```
 
 ### byte and short
-you also have byte (a signed 8 bits integer) and short (a signed 16 bits short integer)
-that are only useful to take less memory when defining an object
+you also have byte (a signed 8-bit integer) and short (a signed 16-bit short integer)
+that are only useful to use less memory when defining an object
 ```java
 record CompactHeader(byte tag, short version) {}
 ```
 
-when used in variables, they are promoted to 32 bits integer
-in the following code result is a 32 bits integer (so an int)
+when used in variables, they are promoted to a 32-bit integer.
+In the following code, `result` is a 32-bit integer (so an int)
 ```java
 short value = 12;
 var result = value + value;

guide/chapter04-numbers.md

@@ -1,6 +1,6 @@
 # Numbers
 This chapter in not specific to Java but more on how integers and floating point numbers
-works on CPUs like Intel 64 bits or ARM 64 bits.
+work on CPUs like Intel 64-bit or ARM 64-bit.
 
 
 ## Integers
@@ -81,7 +81,7 @@ so you may think the value is fully represented that but that's just an illusion
 System.out.println(1.0 / 3.0);
 ```
 
-On way to see the trick is to ask a float, a 32 bits, to be printed as a double, 64 bits.
+On way to see the trick is to ask a float (32-bit), to be printed as a double (64-bit).
 ```java
 System.out.println(1.0f / 3.0f);
 System.out.println(Float.toString(1.0f / 3.0f));

jupyter/chapter00-genesis.ipynb

@@ -8,7 +8,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["## Types\n", "A primitive type is stored as value while an object is stored as\n", "a reference (the address of the object in memory).\n", "In Java, `var` create a new variable\n"]
+  "source": ["## Types\n", "A primitive type is stored as value while an object is stored as\n", "a reference (the address of the object in memory).\n", "In Java, `var` creates a new variable\n"]
 }
 ,
 {
@@ -78,7 +78,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["## A record is a user defined type\n", "here Light is defined as containing two components: a color (typed as a String) and\n", "an intensity (typed as a 64 bits floating number double).\n"]
+  "source": ["## A record is a user defined type\n", "here Light is defined as containing two components: a color (typed as a String) and\n", "an intensity (typed as a 64-bit floating number double).\n"]
 }
 ,
 {
@@ -92,7 +92,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### Object creation with `new`\n", "To create an object in memory, we use the operator `new` followed by the value of each record components\n", "the following instruction create a Light with \"blue\" as color and 1.0 as intensity.\n"]
+  "source": ["### Object creation with `new`\n", "To create an object in memory, we use the operator `new` followed by the value of each record component.\n", "The following instruction creates a Light with \"blue\" as color and 1.0 as intensity.\n"]
 }
 ,
 {
@@ -140,7 +140,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### equals()\n", "In Java, you can ask if two objects are equals, using the method equals(Object).\n", "The return value is a boolean (a primitive type that is either true or false).\n"]
+  "source": ["### equals()\n", "In Java, you can ask if two objects are equal, using the method equals(Object).\n", "The return value is a boolean (a primitive type that is either true or false).\n"]
 }
 ,
 {
@@ -168,7 +168,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["## Summary\n", "A `record` has components that are the parameters used to create an object\n", "To create an object we use the operator `new` followed by the arguments of the\n", "record components in the same order.\n", "To interact with an object, we are using methods that are functions that you\n", "call on an object using the operator `.`.\n", "A Record defines methods to access the value of a component, and also\n", "`toString()` to get the textual representation of an object and\n", "`equals()` and `hashCode()` to test if two objects are equals.\n"]
+  "source": ["## Summary\n", "A `record` has components that are the parameters used to create an object\n", "To create an object we use the operator `new` followed by the arguments of the\n", "record components in the same order.\n", "To interact with an object, we are using methods that are functions that you\n", "call on an object using the operator `.`.\n", "A Record defines methods to access the value of a component, and also\n", "`toString()` to get the textual representation of an object and\n", "`equals()` and `hashCode()` to test if two objects are equal.\n"]
 }
 ],
   "metadata": {

jupyter/chapter01-basic_types.ipynb

@@ -2,7 +2,7 @@
   "cells": [{
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["# Basic Types\n", "Java has two kinds of type,\n", "- primitive types that are directly mapped to CPU basic types\n", "- reference types that address of the object in memory\n"]
+  "source": ["# Basic Types\n", "Java has two kinds of type,\n", "- primitive types that are directly mapped to CPU basic types\n", "- reference types that have the address of the object in memory\n"]
 }
 ,
 {
@@ -42,7 +42,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### int (signed 32 bits integer)\n"]
+  "source": ["### int (signed 32-bit integer)\n"]
 }
 ,
 {
@@ -56,7 +56,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### double (64 bits floating point)\n"]
+  "source": ["### double (64-bit floating point)\n"]
 }
 ,
 {
@@ -70,7 +70,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### long and float\n", "some more exotic types that requires a suffix (`L` or `f`)\n", "long (64 bits integers) and float (32 bits floating point numbers)\n"]
+  "source": ["### long and float\n", "some more exotic types that requires a suffix (`L` or `f`)\n", "long (64-bit integers) and float (32-bit floating point numbers)\n"]
 }
 ,
 {
@@ -84,7 +84,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["### byte and short\n", "you also have byte (a signed 8 bits integer) and short (a signed 16 bits short integer)\n", "that are only useful to take less memory when defining an object\n"]
+  "source": ["### byte and short\n", "you also have byte (a signed 8-bit integer) and short (a signed 16-bit short integer)\n", "that are only useful to use less memory when defining an object\n"]
 }
 ,
 {
@@ -98,7 +98,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["when used in variables, they are promoted to 32 bits integer\n", "in the following code result is a 32 bits integer (so an int)\n"]
+  "source": ["when used in variables, they are promoted to a 32-bit integer.\n", "In the following code, `result` is a 32-bit integer (so an int)\n"]
 }
 ,
 {

jupyter/chapter04-numbers.ipynb

@@ -2,7 +2,7 @@
   "cells": [{
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["# Numbers\n", "This chapter in not specific to Java but more on how integers and floating point numbers\n", "works on CPUs like Intel 64 bits or ARM 64 bits.\n"]
+  "source": ["# Numbers\n", "This chapter in not specific to Java but more on how integers and floating point numbers\n", "work on CPUs like Intel 64-bit or ARM 64-bit.\n"]
 }
 ,
 {
@@ -160,7 +160,7 @@
 {
   "cell_type": "markdown",
   "metadata": {},
-  "source": ["On way to see the trick is to ask a float, a 32 bits, to be printed as a double, 64 bits.\n"]
+  "source": ["On way to see the trick is to ask a float (32-bit), to be printed as a double (64-bit).\n"]
 }
 ,
 {