Merge pull request #20 from kabutz/master

"32 bits" changed to "32-bit"

Author: forax

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

@@ -37,7 +37,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).
 ```java
 record Light(String color, double intensity) {}
 ```

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

@@ -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"]
 }
 ,
 {

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"]
 }
 ,
 {