diff --git a/appendix_c_ide.asciidoc b/appendix_c_ide.asciidoc
index 7bc650d0..62ebc3b6 100644
--- a/appendix_c_ide.asciidoc
+++ b/appendix_c_ide.asciidoc
@@ -1,14 +1,14 @@
 [[appendix_c]]
 [appendix]
 
-= Appendix C. Running Code Samples and IDE 
+== Appendix C. Running Code Samples and IDE 
 
 The code samples used in this book are available on https://github.com/Farata/EnterpriseWebBook_sources[Github] - they are grouped by chapters.  If a chapter has code samples, look for the directory with the respective name.  
 
 Technically, you don't have to use any Integrated Development Environment (IDE) to run code examples (except the CDB example from Chapter 5) - just open the main file in a Web browser and off you go.  But using an IDE will make you more productive. 
 
 
-== Which IDE to Use
+=== Which IDE to Use
 
 Selecting an IDE that supports JavaScript is a matter of your personal preference. Since there is no compilation stage and most of your debugging will be done using the Web browser tools, picking a text editor that supports syntax highlighting is all that most developers need. For example, there is an excellent text editor http://www.sublimetext.com[Sublime Text 2]. Among many programming languages this editor understands the keywords of HTML, CSS, and JavaScript, and it offers not only syntax highlighting, context sensitive help, and auto-complete too.
 
@@ -22,7 +22,7 @@ Appcelerator offers a free Eclipse-based http://aptana.com[Aptana Studio 3 IDE].
 
 The authors of this book like and recommend using the http://www.jetbrains.com/webstorm[IDE WebStorm] from JetBrains. In addition to smart context sensitive help, auto-complete, and syntax highlighting it offers HTML5 templates, and the code coverage feature that identifies the code fragment that haven't been tested. 
 
-== Running Code Samples in WebStorm IDE
+=== Running Code Samples in WebStorm IDE
 
 WebStorm IDE is pretty intuitive to use. If you've never used it before, refer to its http://www.jetbrains.com/webstorm/quickstart/[Quick Start Guide]. 
 When you first start WebStorm IDE, select the option _Open Directory_ in the Welcome screen. Then select the directory where you downloaded the samples of a specific book chapter. For example, after opening code samples from Chapter 1 the WebStorm IDE may look as follows:
@@ -37,7 +37,7 @@ For example, if the WebStorm's opened directory chapter1 as in Figure <<FIGc-11>
 
 TIP: You can configure in WebStorm the port number of the internal Web Server via  Preferences | Debugger | JavaScript | Built-in server port.
 
-== Using two IDEs: WebStorm and Eclipse 
+=== Using two IDEs: WebStorm and Eclipse 
 
 Although we prefer using WebStorm for JavaScript development, but have to use Eclipse for some Java-related projects. In such cases we create a project in WebStorm pointing at the WebContent directory of your Eclipse project. This way we still enjoy a very smart context sensitive help offered by WebStorm, and all code modifications become immediately visible in the Eclipse project. 
 
diff --git a/ch11_responsive.asciidoc b/ch11_responsive.asciidoc
index 098082a9..426d7a67 100644
--- a/ch11_responsive.asciidoc
+++ b/ch11_responsive.asciidoc
@@ -2,7 +2,7 @@
 :toclevels: 4
 :imagesdir: ./
 
-= Part 3. Responsive Web Design and Mobile
+= Responsive Web Design and Mobile
 
 BYOD stands for Bring Your Own Device. It became a new trend - many enterprises started allowing their employees to access corporate applications from personal tablets or smartphones. CYOD stands for Choose Your Own Device - corporations let their employees to choose a device that belongs to the enterprise. Developers of new Web applications should always think of the users that will try to run this application on a mobile device. This part is about various strategies of developing Web applications that look and perform well not only on the desktop computers but on a smaller screens too.
 
diff --git a/ch1_advancedjs.asciidoc b/ch1_advancedjs.asciidoc
index 342fcfa7..b5377bb1 100644
--- a/ch1_advancedjs.asciidoc
+++ b/ch1_advancedjs.asciidoc
@@ -1,7 +1,7 @@
 [[appendix_a]]
 [appendix]
 
-= Appendix A. Advanced Introduction to JavaScript
+== Appendix A. Advanced Introduction to JavaScript
 
 
 _"Atwood's Law: any application that can be written in JavaScript, will eventually be written in JavaScript._
@@ -13,7 +13,7 @@ NOTE: If you're absolute beginner with Web development and had no previous expos
 Besides the JavaScript coverage this Appendix  includes a section on the tools (IDEs, debuggers, Web inspectors et al.) that will make your development process more productive.  
 
 
-== JavaScript: A Brief History
+=== JavaScript: A Brief History
 
 The JavaScript programming language was designed in 1995 by Brendan Eich, who was working for Netscape Communications Corporation at the time. His goal was to allow developers create more interactive Web pages. Initially the name of this language was Mocha, then LiveScript, and finally Netscape agreed with Sun Microsystems, creator of Java to rename it to JavaScript.
 
@@ -42,7 +42,7 @@ JavaScript became the lowest common denominator available on thousands of differ
 
 JavaScript is an interpreted language that arrives to the Web browser as text. The JavaScript engine optimizes and compiles the code before the execution. The JavaScript engine is a part of the Web browser, which will load and execute the JavaScript code embedded or referenced between the HTML tags `<script>` and `</script>`. JavaScript was originally created for Web browsers, which were supposed to display whatever content has successfully arrived. What if an image has not arrived from the server? You’ll see a broken image icon. What if erroneous JavaScript code with syntax errors has arrived to the browser? Well, the engine will try to execute whatever code has arrived. The end users may appreciate such browser's forgiveness when at least some content is available, but the software developers should be ready to spend more time debugging (in multiple browsers) the errors that could have been caught by compilers in other programming languages.
 
-== JavaScript Variables
+=== JavaScript Variables
 
 JavaScript is a weakly typed language hence the developers don’t have a luxury of strong compiler's help that Java or C# developers enjoy.  For those unfamiliar with weakly typed languages, let us  explain. Imagine that if in Java or C# instead of declaring variables of specific data types everything would be of type `Object`, and you could assign to it any value – a string, a number, or a custom object `Person`. This would substantially complicate the ability of the compiler to weed out all possible errors. You don’t need to declare variables in JavaScript – just assign a value and the JavaScript engine will figure out the proper type during the execution of your code.For example, the variable named `girlfriend` will have a data type of `String`:
 
@@ -59,8 +59,8 @@ Variables declared with the `var` keyword inside functions are have local scope
 function addPersonalInfo(){
    var address ="123 Main Street";      // local String variable
    age=25;                              // global Number variable
-   var isMarried = true;                // local boolean variable
-   isMarried = "don't remember";        // now it's of String type
+   var isMarried == true;                // local boolean variable
+   isMarried == "don't remember";        // now it's of String type
 }
 ----
 
@@ -69,7 +69,7 @@ The variables `address` and `isMarried` are visible only inside the function `ad
 The variable `isMarried` changes its type from `Boolean` to `String` during the execution of the above script, and JavaScript engine won't complain assuming that the programmer knows what she’s doing. So be ready for the run-time surprises and allocate a lot more time for testing than with programs written in  compiled languages.
 
 
-== Getting Familiar with Aptana IDE
+=== Getting Familiar with Aptana IDE
 
 
 Download and install Aptana Studio 3 from http://aptana.com[http://aptana.com]. Start Aptana IDE, then close its initial tab view by clicking on the little X on the tab. Then customize the color theme of this IDE by clicking the rainbow-colored circle on its toolbar. We usually select the theme called Eclipse. After the first start of Aptana you’ll see the message on the left side that reads ``There are no projects in your workspace. To get started, please create or import an existing one.''
@@ -99,7 +99,7 @@ To configure the Web Browser that Aptana should open by default, open its Prefer
 TIP: you can find various HTML5 boilerplate projects on the Web that can be used as a starting point of your project. You don't have to select the Aptana's HTML5 boilerplate if it doesn't fit your needs. For example, you can download a bare minimum boilerplate http://projects.craftedpixelz.co.uk/shibui/[Shibui]
 or more comprehensive http://html5boilerplate.com/[HTML5 Boilerplate]. Just download and unzip such a boilerplate project into your Aptana's workspace and start adding your code, styles, and other resources.
 
-== Adding JavaScript to HTML
+=== Adding JavaScript to HTML
 
 Software developers either directly include the  JavaScript code to the HTML document by placing it between the tags `<script>` and `</script>` or include a reference to the external location of the code (e.g. a local file name or a URL) in the `src` attribute of the `<script>` tag. We usually place the `<script>`tags at the end of HTML file. The reason is simple - your JavaScript code may be manipulating with HTML elements, and you want them to exist by the time the script runs. The other way to ensure that the code will run only after the Web page has loaded is by catching window's `load` event (you'll see such example later in this chapter in the section on browser's events). Some JavaScript frameworks may have their own approach to dealing with HTML content and in Chapter 4  you'll see that the main HTML file of the Web application written with Ext JS framework has `<script>` tags followed by the empty `<body>` tags. But let's keep things simple for now.
 
@@ -129,7 +129,7 @@ In this simple example this doesn't cause any malfunctioning of the code, but if
 TIP: In a real life you won't be deploying your projects under Aptana's internal Web server. When you code is tested you can FTP it to a remote server of your choice, e.g. Apache Web Server or IIS. Right-click on your Aptana project and select the menu option Publish. This will allow you to configure the FTP connection to your remote server and publish your working code there as you wish.
 
 
-== Debugging JavaScript in Web Browsers
+=== Debugging JavaScript in Web Browsers
 
 
 The best way to learn any program is to run it step by step through a debugger. While some people appreciate using debuggers offered by the IDE, we prefer to debug using great tools offered by the major Web browsers:
@@ -177,7 +177,7 @@ TIP: You can also use `console.info()`, `console.debug()`, and `console.error()`
 
 TIP: For more information about debugging JavaScript refer to the code samples illustrated in <<FIG2-8>> and <<FIG2-9>>.
 
-== JavaScript Functions. Gentle Introduction
+=== JavaScript Functions. Gentle Introduction
 
 JavaScript can be called an object-oriented language cause it allows an object to inherit existing  functionality from another object, and you can encapsulate the data and restrict the data access. It's done not as simple as in classical object-oriented languages, but it's possible.  Now comes the chicken or the egg dilemma. What should be explained first - the syntax of functions or creation of objects? Understanding of objects is needed for some of the function code samples and visa versa. We'll start with simple function use cases, but will be switching to objects as needed.
 
@@ -194,7 +194,7 @@ function calcTax (income, dependents){
 
 //Function invocation
 calcTax(50000, 2);    
-var myTax = calcTax(50000,2);
+var myTax == calcTax(50000,2);
 ----
 
 WARNING: Please note that the data types of the function parameters `income` and `dependents` are not specified. We can only guess that they are numbers based on their names. If a software developer won't bother giving meaningful names to function parameters, the code becomes difficult to read. 
@@ -243,7 +243,7 @@ If you'll take away the outermost parentheses and the closing semicolon, you'll
 
 TIP: The topic "Function declaration vs. function expressions" is one of those fuzzy JavaScript areas that can cause unexpected behavior of your code. Angus Croll published http://javascriptweblog.wordpress.com/2010/07/06/function-declarations-vs-function-expressions/[a well-written article] on this subject.    
 
-== JavaScript Objects. Gentle Introduction
+=== JavaScript Objects. Gentle Introduction
 
 JavaScript objects are simply unordered collections of properties. You can assign new or delete existing properties from the objects during the runtime whenever you please. In classical object oriented languages there are _classes_ and there are _objects_. However JavaScript doesn't have classes.  
 
@@ -269,20 +269,20 @@ NOTE: In JavaScript everything is an +Object+. Think of +Object+ as of a root of
 
 ****
 
-=== Object Literals
+==== Object Literals
 
 The easiest way to create a JavaScript object is by using the object literal notation. The code sample below starts with a creation of an empty object. 
 
 [source,javascript]
 ----
-var t = {}             // create an instance of an empty object
+var t == {}             // create an instance of an empty object
 ----
 
 The following line of code creates an object with one property `salary` and assigns the value of 50000 to it. 
 
 [source,javascript]
 ----
-var a = {salary: 50000}; // an instance with one property
+var a == {salary: 50000}; // an instance with one property
 ----
 
 Below, the instance of one more object is created and the variable `person` points at it.  
@@ -290,7 +290,7 @@ Below, the instance of one more object is created and the variable `person` poin
 [source,javascript]
 ----
 // Store the data about Julia Roberts
-var person = { lastName: ”Roberts”,
+var person == { lastName: ”Roberts”,
                firstName: ”Julia”, 
                      age: 42
              };
@@ -300,7 +300,7 @@ This object has three properties: `lastName`, `firstName`, and `age`. Note that
 
 [source, javascript]
 ----
- var person = {
+ var person == {
        "last name": "Roberts",   
        firstName: "Julia",
              age: 42};
@@ -324,13 +324,13 @@ console.log("Hello "+ person.salutation + person["last name"]); // <4>
 
 TIP: It's a good idea to keep handy a style guide of any programming language, and we know two of such documents for JavaScript. Google has published their version of JavaScript Style Guide at http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml[http://google-styleguide.googlecode.com/svn/trunk/javascriptguide.xml]. A more detailed Airbnb JavaScript Style Guide is available as a github project at https://github.com/airbnb/javascript[https://github.com/airbnb/javascript]. And the github version of the JavaScript style guide is located at https://github.com/styleguide/javascript[https://github.com/styleguide/javascript].
 
-==== Nesting Object Literals
+===== Nesting Object Literals
 
 Objects can contain other objects. If a property of an object literal is also an object, you just need to specify the value of this property in an extra pair of curly braces. For example, you can represent the telephone of a person as an object having two properties: the type and the number. The following code snippet adds a nested object to store a work phone as a _nested object_ inside the person's object. Run this code in the Firebug's console and it'll print "Call Julia at work 212-555-1212". 
 
 [source, javascript]
 ----
-var p = { lastName: "Roberts",
+var p == { lastName: "Roberts",
                 firstName: "Julia", 
                 age: 42,
                 phone:{
@@ -345,7 +345,7 @@ What if a person has more then one phone? We can change the name of the property
 
 [source, javascript]
 ----
-var p = { lastName: "Roberts",
+var p == { lastName: "Roberts",
                 firstName: "Julia", 
                 age: 42,
                 phones:[{
@@ -361,14 +361,14 @@ var p = { lastName: "Roberts",
 console.log("Call " + p.firstName + " at " + p.phones[1].type + " " + p.phones[1].numb );
 ----
 
-==== Methods in Object Literals
+===== Methods in Object Literals
 
 Functions defined inside objects are called _methods_. Defining methods in object literals is similar to defining properties - provide a method name followed by a colon and the function declaration. The code snippet below declares a method `makeAppoyntment()` to our object literal. Finally, the line `p.makeAppointment();` invokes this new method, which will print the message on the console that Steven wants to see Julia and will call at so-and-so number.
 
 
 [source, javascript]
 ----
-var p = { lastName: "Roberts",
+var p == { lastName: "Roberts",
                 firstName: "Julia", 
                 age: 42,
                 phones:[{
@@ -409,7 +409,7 @@ console.log(greetArray.join(","));
 We've briefly covered object literals, and you to start using them. In Chapter 2 you'll be learning about JSON - a popular data format used as replacement for XML in the JavaScript world. Then you'll see how similar are the syntax of JSON and JavaScript object literals. Now we'll spend a little bit of time delving into JavaScript functions, and then - back to objects again. 
   
 
-=== Constructor Functions
+==== Constructor Functions
 
 JavaScript functions are more then just some named pieces of code that implements certain behavior. They also can become objects themselves by a magic of the `new` operator. To make things even more intriguing, the function calls can have memories, which will be explained in the section about closures.
 
@@ -425,9 +425,9 @@ function Person(lname, fname, age){
 };
            
 // Creating 2 instances of Person
-var p1 = new Person(“Roberts”,“Julia”, 42);
+var p1 == new Person(“Roberts”,“Julia”, 42);
 
-var p2 = new Person(“Smith”, “Steven”, 34); 
+var p2 == new Person(“Smith”, “Steven”, 34); 
 
 ----
 
@@ -437,7 +437,7 @@ According to common naming conventions the names of the constructor functions ar
 
 NOTE: The JavaScript language doesn't support classes, and a constructor function is the closest concept to the classes of the languages like Java or C#. Chapter 4 is about the Ext JS framework that extends JavaScript and introduces constructs similar to classes and classical inheritance.
 
-==== Adding Methods and Properties to Functions
+===== Adding Methods and Properties to Functions
 
 Objects can have methods and properties, right? On the other hand, functions are objects. Hence functions can have methods and properties too. If you declare a function `marryMe()` inside the constructor function `Person`, `marryMe()` becomes a method of `Person`. This is exactly what we'll do next. But this time we'll create an HTML file that includes the `<script>` section referring to the JavaScript code sample located in a separate file.
 
@@ -457,8 +457,8 @@ function Person(lname, fname, age){
          	
 };
  
-var p1= new Person("Smith", "Steven");
-var p2= new Person("Roberts", "Julia");
+var p1== new Person("Smith", "Steven");
+var p2== new Person("Roberts", "Julia");
 
 p1.marryMe(p2);
 
@@ -486,7 +486,7 @@ In Aptana, create a new File | New | File, enter marryme.html as the file name a
 </html>
 ----
 
-== Debugging JavaScript in Firebug
+=== Debugging JavaScript in Firebug
 
 In Aptana, right-click on the file marryme.html and select the option Run As | JavaScript Web Application. We continue using Firefox as Aptana's default browser, and you'll see it open a new Web page that reads "Making Proposals". Open the Firebug using the View menu of Firefox, refresh the page and switch to the Firebug's tab Script. You'll see the split panel with the JavaScript code from marryme.js on the left.    
 
@@ -533,9 +533,9 @@ var myArray=[];
 // prints undefined John    
 console.log(myArray[1] + " " + myArray[2]);     
 
-var states1 = ["NJ", "NY", "CT", "FL"];
+var states1 == ["NJ", "NY", "CT", "FL"];
 
-var states = new Array(4);  // size is optional
+var states == new Array(4);  // size is optional
 
 states[0]="NJ";
 
@@ -577,7 +577,7 @@ var mixedArray=[
 
 ****
 
-== Prototypal Inheritance
+=== Prototypal Inheritance
 
 JavaScript doesn't support classes, at least till the ECMAScript 6 will become a reality. But JavaScript allows you to create objects that inherit properties and methods of other objects. By default, all JavaScript objects are inherited from `Object`. Each JavaScript construction function has a special property called `prototype`, which points at this object's ancestor. If you want to create an inheritance chain where an instances of constructor function `ObjectB` _extends_ `ObjectA` (as in classical object-oriented languages) just write one line of code: `ObjectB.prototype=ObjectA;`.   
 
@@ -602,9 +602,9 @@ function Employee(name, title){
 }
 
 // All instances of Employee will extend Person
-Employee.prototype = new Person();            // <1>
+Employee.prototype == new Person();            // <1>
 
-var emp = new Employee("Mary", "Specialist"); // <2> 
+var emp == new Employee("Mary", "Specialist"); // <2> 
 
 console.log(emp);      // <3>
 ----
@@ -650,7 +650,7 @@ image::images/fig_02_13.jpg[]
 Please note the difference in the content of the variables `__proto__` of the instances represented by `emp` and `emp2`. These two employees are inherited from two __different__ objects `Person`. Isn't it scary? Not really.
 
 
-=== Avoiding Declaration Redundancy
+==== Avoiding Declaration Redundancy
 
 Prototypical inheritance allows you to inherit one object from another, but it can lead to issues of redundancy and code duplication. If you take a closer look at the screenshot from <<FIG2-13>> you'll see that the `Person` and `Employee` objects have redundant properties `name` and `title`. We'll deal with this redundancy in the section titled "Call and Apply". But first let's introduce and cure the redundancy in method declarations when the prototypal inheritance is used.
 
@@ -679,11 +679,11 @@ function Employee(name, title){
 }
 
 // Changing the inheritance of Employee
-Employee.prototype = new Person();       
+Employee.prototype == new Person();       
 
-var mgr =  new Person("Alex", "Director");
-var emp1 = new Employee("Mary", "Specialist");
-var emp2 = new Employee("Joe", "VP");
+var mgr ==  new Person("Alex", "Director");
+var emp1 == new Employee("Mary", "Specialist");
+var emp2 == new Employee("Joe", "VP");
 
 mgr.addSubordinate(emp1);
 mgr.addSubordinate(emp2);
@@ -729,11 +729,11 @@ function Employee(name, title){
 }
 
 // Changing the inheritance of Employee
-Employee.prototype = new Person();       
+Employee.prototype == new Person();       
 
-var mgr =  new Person("Alex", "Director");
-var emp1 = new Employee("Mary", "Specialist");
-var emp2 = new Employee("Joe", "VP");
+var mgr ==  new Person("Alex", "Director");
+var emp1 == new Employee("Mary", "Specialist");
+var emp2 == new Employee("Joe", "VP");
 
 mgr.addSubordinate(emp1);
 mgr.addSubordinate(emp2);
@@ -760,14 +760,14 @@ NOTE: All modern Web browsers support the function `Object.create()`, which crea
 
 [source, javascript]
 ----
-if (typeof Object.create !== 'function') {
-    Object.create = function (o) {
+if (typeof Object.create !=== 'function') {
+    Object.create == function (o) {
         function F() {}
-        F.prototype = o;
+        F.prototype == o;
         return new F();
     };
 }
-newObject = Object.create(oldObject);
+newObject == Object.create(oldObject);
 ----
 
 Such approach of custom implementation of missing pieces according to the latest ECMAScript specifications or W3C drafts is known as _polyfills_. People who can't wait till the browser vendors will implement the newest functionality create cross-browser polyfills and some of them submit their source code to the public domain. You can find a number of polyfills in the git repository of the https://github.com/Modernizr/Modernizr/wiki/HTML5-Cross-Browser-Polyfills[Modernizr project]. The Web site http://caniuse.com[http://caniuse.com/] contains the current information about browser's support of the latest HTML5, JavaScript, and CSS features.
@@ -776,7 +776,7 @@ Such approach of custom implementation of missing pieces according to the latest
 
 TIP: In the Ext JS chapter you'll see how this frameworks offers its own class system that supports inheritance.
 
-=== Method overriding
+==== Method overriding
 
 Method overriding allows a subclass to replace (_override_) the functionality of a method defined in a superclass. Since JavaScript allows declaring methods on an object as well as on its prototype, overriding a method becomes really simple. The following code sample declares the method `addSubordinate()` on the prototype of the `Person` object, but then the object `p1` overrides this method.
 
@@ -803,7 +803,7 @@ var p1=new Person("Joe", "President");
     console.log("I'm in addSubordinate in object " + this);
   }
 
-var p2 = new Person("Mary", "Manager")
+var p2 == new Person("Mary", "Manager")
 
     p1.addSubordinate(p2); 
 
@@ -820,7 +820,7 @@ Person.prototype.toString=function(){
 
 Now the code prints "I'm in addSubordinate in object name:Joe, title:President". Overriding the method `toString()` on objects is a common practice as it gives a textual representation of your objects.
 
-== Scope or who's this?
+=== Scope or who's this?
 
 You are about to read one of the most confusing sections in this book. The confusion is caused by some inconsistencies in JavaScript design and implementations by various browsers. Do you know what will happen if you'll remove the keywords `this` from the `toString()` method  from previous section? You'll get an error - the variable `title` is not defined. Without the keyword `this` the JavaScript engine tries to find the variable `title` in the global namespace. Declaring and initializing the variable `title` outside of the `Person` declaration get rid of this error, but this is not what we want to do. Misunderstanding of the current scope can lead to difficult to debug errors.
 
@@ -832,14 +832,14 @@ Let's consider several examples that will illustrate the meaning of `this` varia
 ----
 var taxDeduction=300;      // global variable
 
-var myTaxObject = {
+var myTaxObject == {
 
     taxDeduction: 400,    // object property   
 
     doTaxes: function() {
-         this.taxDeduction += 100;
+         this.taxDeduction +== 100;
     
-         var mafiaSpecial= function(){
+         var mafiaSpecial== function(){
            console.log( "Will deduct " + this.taxDeduction);
          }
          
@@ -865,15 +865,15 @@ Let's make a slight change to this example and take to control what `this` repre
 ----
 var taxDeduction=300;      // global variable
 
-var myTaxObject = {
+var myTaxObject == {
 
     taxDeduction: 400,    // object property   
 
     doTaxes: function() {
     var thisOfMyTaxObject=this;
-         this.taxDeduction += 100;
+         this.taxDeduction +== 100;
     
-         var mafiaSpecial= function(){
+         var mafiaSpecial== function(){
            console.log( "Will deduct " + thisOfMyTaxObject.taxDeduction);
          }
          
@@ -890,14 +890,14 @@ You'll see a different way of running a function in the context of the specified
 ----
 var taxDeduction=300;      // global variable
 
-var myTaxObject = {
+var myTaxObject == {
 
     taxDeduction: 400,    // object property   
 
     doTaxes: function() {
-         this.taxDeduction += 100;
+         this.taxDeduction +== 100;
     
-         var mafiaSpecial= function(){
+         var mafiaSpecial== function(){
            console.log( "Will deduct " + this.taxDeduction);
          }
          
@@ -912,7 +912,7 @@ Run the above code and it'll give you the error "TypeError: this.mafiaSpecial is
 
 After learning how to hide a a function inside an object, let's see how to do something quite opposite -  allowing an external method to run inside the context of an object.
 
-=== Call and Apply
+==== Call and Apply
 
 Visualize the International Space Station, and add to the picture an image of a approaching space shuttle. After attaching to the docking bay of the station the shuttle's crew performs some functions on the station (a.k.a. object) and then flies to another object or back to Earth. What it has to do with JavaScript? It can serve as an analogy for creating a JavaScript function that can operate in the scope of any arbitrary object. For this purpose JavaScript offers two special functions: `call()` or `apply()`. Both `call()` and `apply()` can invoke any function on any object. The only difference between them is that `apply()` passes  parameters to a function as an array, while `call()` uses a comma-separated list.
 
@@ -933,14 +933,14 @@ In the above example the instance of `myTaxObject` can be referred as `this` fro
 ----
 var taxDeduction=300;      // global variable
 
-var myTaxObject = {
+var myTaxObject == {
 
     taxDeduction: 400,      
 
     doTaxes: function() {
-         this.taxDeduction += 100;
+         this.taxDeduction +== 100;
     
-         var mafiaSpecial= function(){
+         var mafiaSpecial== function(){
            console.log( "Will deduct " + this.taxDeduction);
          }
          
@@ -951,7 +951,7 @@ var myTaxObject = {
 myTaxObject.doTaxes();   
 ---- 
 
-=== Callbacks
+==== Callbacks
 
 Can you live without using `call()` and `apply()`?  Sure you can, but JavaScript allows you to easily create callbacks. The callback mechanism lets you pass the code of one function as a parameter to another function for execution in the latter function's context. This is a very useful feature of the language. Imagine an object with a method `processData()`. Depending on the business logic you can pass to this method (as an argument) different functions that will do actual data processing - these are callbacks.
 
@@ -969,14 +969,14 @@ Let's consider an example when you need to write a function that will take two a
 
 [source, javascript]
 ----
-var myTaxObject = {
+var myTaxObject == {
 
     taxDeduction: 400, // state-specific  deduction     
 
     // this function takes an array and callback as parameters
     applyDeduction: function(someArray, someCallBackFunction){
     
-        for (var i = 0; i < someArray.length; i++){
+        for (var i == 0; i < someArray.length; i++){
      
             // Invoke the callback
            someCallBackFunction.call(this, someArray[i]); 
@@ -1009,11 +1009,11 @@ Hello from callback. Your final tax is 2600
 
 You may be wondering, why passing the function to another object if we could take an array, subtract 400 from each of its elements and be done with it? The solution with callbacks gives you an ability to make the decision on what function to call during the runtime and call it only when a certain event happens. Callbacks allow you to do _asynchronous processing_. For example, you make an asynchronous  request to a server and register the callback to be invoked if a result comes back. The code is not blocked and doesn't wait until the server response is ready. Here's an example from AJAX: `request.onreadystatechange=myHandler`. You register `myHandler` callback but not immediately call it. JavaScript functions are objects, so get used to the fact that you can pass them around as you'd be passing any objects.
 
-=== Hoisting
+==== Hoisting
 
 A variable scope depends on where it was declared.  You already had a chance to see that a variable declared inside a function with the keyword `var` is visible only inside this function and any function declared within it. Some programming languages allow to narrow down the scope even further. For example, in Java declaring a variable inside any block of code surrounded with curly braces makes it visible only inside such a block. In JavaScript it works differently. No matter where in the function you declared the variable its declaration will be _hoisted_ to the top of the function, and you can use this variable anywhere inside the function. 
 
-==== Hoisting Variables
+===== Hoisting Variables
 
 The following code snippet will print 5 even though the variable b has been declared inside the if-statement. It's declaration has been hoisted to the top:
 
@@ -1023,7 +1023,7 @@ function test () {
     var a=1;
 
     if(a>0) {
-        var b = 5;
+        var b == 5;
     }
     console.log(b);
 
@@ -1055,7 +1055,7 @@ test();
 
 Due to hoisting, JavaScript doesn't complain when the first `console.log(b)` is invoked. It knows about the variable `b`, but its value is `undefined` just yet. By the time the second `console.log(b)` is called, the variable b was initialized with the value of 5. Just remember that hoisting just applies to variable declaration and doesn't interferes with your code when it comes to initialization.
 
-==== Hoisting Functions
+===== Hoisting Functions
 
 JavaScript function declarations are hoisted too, and this is illustrated in the following code sample.
 
@@ -1095,7 +1095,7 @@ function test () {
     
     printB();
     
-    var printB = function(){
+    var printB == function(){
         console.log(b);
     }   
     
@@ -1109,7 +1109,7 @@ Notice that it the error doesn't complain about `printB` being undefined cause t
 TIP: Function expressions are not being hoisted, but the variables they are assigned to (if any) are being hoisted.
 
 
-=== Function properties
+==== Function properties
 
 Functions as any other objects can have properties. You can attach any properties to a `Function` object and their values can be used by all instances of this object. Static variables in programming languages with the classical inheritance is the closest analogy to function properties in JavaScript. 
 
@@ -1121,7 +1121,7 @@ function Tax(income, dependents){
     this.income=income;              // instance variable
     this.dependents=dependents;      // instance variable
          
-    this.doTax = function calcTax(state, language){
+    this.doTax == function calcTax(state, language){
            if(!(state && language)){     // <1>
               console.log("Income: " + this.income + " Dependents: "+ this.dependents
               + " State: " + Tax.defaults.state + " language:" + Tax.defaults.language);
@@ -1138,9 +1138,9 @@ Tax.defaults={                           // <3>
 };
        
 // Creating 2 Tax objects         
-var t1 = new Tax(50000, 3);
+var t1 == new Tax(50000, 3);
     t1.doTax();                          // <4>
-var t2 = new Tax(68000, 1); 
+var t2 == new Tax(68000, 1); 
     t2.doTax("NY","English");            // <5>
     
 ----
@@ -1165,9 +1165,9 @@ You can add as many properties to the constructor function as needed. For exampl
 TIP: If multiple instances of a function object need to access certain HTML elements of the DOM,  add references to these elements as function properties so objects can reuse them instead of traversing the DOM (it's slow) from each instance. 
 
 
-== Closures
+=== Closures
 
-=== A Formal Definition Attempt
+==== A Formal Definition Attempt
 
 A _closure_ is one of those terms that are easier explained by examples. Closures have formal definitions, which are not very helpful for the first timers. Here's the http://en.wikipedia.org/wiki/Closure_(computer_science)[definiton of a closure from Wikipedia]: 
 
@@ -1178,7 +1178,7 @@ It's not a very helpful definition, is it? Let's try to give a better one. Imagi
 Larry Ullman, gives the following definition in his book "Modern Java Script": "Closure is a function call with memory". We can offer you our version of what a closure is: "Closure is a function call with strings attached". 
 
 
-=== Why do we Need Closures? 
+==== Why do we Need Closures? 
 
 In classical object-oriented languages you create an object with a certain state and behavior and can pass if to a method of another object for further processing. In JavaScript you can pass even a function to some object's method for further processing. But what if a function also need to remember the state (the values of external variables) of the context where the function was defined?
 
@@ -1192,17 +1192,17 @@ Now it's time for the explanation of these mysterious definitions, and we'll do
 ----
 (function (){                // this is an anonymous function expression
 
-    var taxDeduction = 500;  // private context to remember 
+    var taxDeduction == 500;  // private context to remember 
       
       //exposed closure
       this.doTaxes=function(income, customerName) {
  	
       	var yourTax;
       	    
-        if (customerName != "Tony Soprano"){
-          yourTax =   income*0.05 - taxDeduction;        	
+        if (customerName !== "Tony Soprano"){
+          yourTax ==   income*0.05 - taxDeduction;        	
         } else{
-          yourTax =   mafiaSpecial(income);  
+          yourTax ==   mafiaSpecial(income);  
         }
         
          console.log( "   Dear " + customerName + ", your tax is "+ yourTax);
@@ -1256,14 +1256,14 @@ Let's consider a couple of more cases of returning a closure to the outside worl
 // Constructor function
 function Person(name){
 	
-	this.name = name;
+	this.name == name;
 	
 }
 
 // Declaring a method that returns closure
-Person.prototype.doTaxes= function(){
+Person.prototype.doTaxes== function(){
 
-    var taxDeduction = 500;  
+    var taxDeduction == 500;  
 
       //private function
       function mafiaSpecial(income){
@@ -1275,10 +1275,10 @@ Person.prototype.doTaxes= function(){
  	
       	var yourTax;
       	    
-        if (this.name != "Tony Soprano"){
-          yourTax =   income*0.05 - taxDeduction;        	
+        if (this.name !== "Tony Soprano"){
+          yourTax ==   income*0.05 - taxDeduction;        	
         } else{
-          yourTax =   mafiaSpecial(income);  
+          yourTax ==   mafiaSpecial(income);  
         }
         
          console.log( "My dear " + this.name + ", your tax is "+ yourTax);
@@ -1287,14 +1287,14 @@ Person.prototype.doTaxes= function(){
 }();     // important parentheses!
 
 //Using closure
-var p1 = new Person("John Smith");
-var result1 = p1.doTaxes(100000);                          
+var p1 == new Person("John Smith");
+var result1 == p1.doTaxes(100000);                          
 
-var p2 = new Person("Tony Soprano");
-var result2 = p2.doTaxes(100000);
+var p2 == new Person("Tony Soprano");
+var result2 == p2.doTaxes(100000);
 ----
 
-The calculated taxes in this example are the same as in the previous one: John Smith has to pay $4500, while Tony Soprano only $4000. But we used different technique for exposing the closure. We want to make sure that you didn't overlooked the parentheses at the very end of the function expression for `doTaxes`. These parenthesis force the anonymous function to self-invoke itself, it'll run into a `return` statement and will assign the code of the anonymous inner function that takes parameter `income` to the property `doTaxes`. So when the line `var result1 = p1.doTaxes(100000);` calls the closure the variable `result1` will have the value 4500. Remove these important parentheses, and the value of `result1` is not the tax amount, but the the code of the closure itself - the invocation of the closure is not happening. 
+The calculated taxes in this example are the same as in the previous one: John Smith has to pay $4500, while Tony Soprano only $4000. But we used different technique for exposing the closure. We want to make sure that you didn't overlooked the parentheses at the very end of the function expression for `doTaxes`. These parenthesis force the anonymous function to self-invoke itself, it'll run into a `return` statement and will assign the code of the anonymous inner function that takes parameter `income` to the property `doTaxes`. So when the line `var result1 == p1.doTaxes(100000);` calls the closure the variable `result1` will have the value 4500. Remove these important parentheses, and the value of `result1` is not the tax amount, but the the code of the closure itself - the invocation of the closure is not happening. 
 
 The following code fragment is yet another example of returning the closure that remembers its context.
 
@@ -1308,8 +1308,8 @@ function prepareTaxes(studentDeductionAmount) {
 	
 }
 
-var doTaxes = prepareTaxes(300);         // <2>
-var yourTaxIs = doTaxes(10000);          // <3> 
+var doTaxes == prepareTaxes(300);         // <2>
+var yourTaxIs == doTaxes(10000);          // <3> 
 console.log("You tax is " + yourTaxIs);  // <4>
 ----
 
@@ -1322,18 +1322,18 @@ First, the closure is returned to the caller of `prepareTaxes()`, and when the c
 
 TIP: Check the quality of your code with the help of the JavaScript code quality tools like http://www.jslint.com/[JSLint] or http://www.jshint.com/[JSHint]. 
 
-=== Closures as callbacks	
+==== Closures as callbacks	
 
 Let's revisit the code from the section Callbacks above. That code has shown how to pass an arbitrary function to another one and invoke it there using `call()`. But if that version of the function `taxHandler` was not aware of the context it was created in, the version below will. If in classical object-oriented languages you'd need to pass a method that knows about it's context, you'd need to create an instance of an object that contains the method and the required object-level properties, and then you'd be passing this wrapper-object to another object for processing. But since the closure remembers its context anyway, we can just pass a closure as an object. Compare the code below with the code from the Callbacks section.
 
 [source, javascript]
 ----
-var myTaxObject = {    
+var myTaxObject == {    
 
     // this function takes an array and callback as parameters
     applyDeduction: function(someArray, someCallBackFunction){
     
-        for (var i = 0; i < someArray.length; i++){
+        for (var i == 0; i < someArray.length; i++){
      
             // Invoke the callback
            someCallBackFunction.call(this, someArray[i]); 
@@ -1346,7 +1346,7 @@ var myTaxObject = {
 var preliminaryTaxes=[1000, 2000, 3000];
 
 
-var taxHandler = function (taxDeduction){
+var taxHandler == function (taxDeduction){
 	
 // tax handler closure
 	return function(currentTax){ 
@@ -1363,7 +1363,7 @@ myTaxObject.applyDeduction(preliminaryTaxes, taxHandler(200));
 The last line of the above example calls `taxHandler(200)`, which creates a closure that's being passed as a callback to the method `applyDeduction()`. Even though this closure is executed in the context of `myTaxObject`, it remembers that tax deduction is 200. 
 
 
-== Mixins
+=== Mixins
 
 The need to extend capabilities of objects can be fulfilled by inheritance, but this is not the only way of adding behavior to objects. In this section you'll see an example of something that would not be possible in the object-oriented languages like Java or C#, which don't support multiple inheritance. JavaScript allows taking a piece of code and _mix it into any object_ regardless of what its inheritance chain is. _Mixin_ is a reusable code fragment that an object can borrow without the need to use inheritance. We'll illustrate this concept by example. 
 
@@ -1372,7 +1372,7 @@ In the next code fragment we'll define a function expression and will assign it
 [source, javascript]
 ----
 // Defining a function expession 
-var Tax = function(income, state){
+var Tax == function(income, state){
 	this.income=income;
 	this.state=state;
 	
@@ -1385,9 +1385,9 @@ var Tax = function(income, state){
 
 
 // Defining a mixin
-var TaxMixin = function () {};
+var TaxMixin == function () {};
 
-TaxMixin.prototype = {
+TaxMixin.prototype == {
 
   mafiaSpecial: function(originalTax){
     console.log("Mafia special:" + (originalTax - 1000));
@@ -1403,7 +1403,7 @@ TaxMixin.prototype = {
 function blend( mainDish, spices ) {
 
   for ( var methodName in spices.prototype ) {
-      mainDish.prototype[methodName] = spices.prototype[methodName];
+      mainDish.prototype[methodName] == spices.prototype[methodName];
   }
 }
 
@@ -1411,9 +1411,9 @@ function blend( mainDish, spices ) {
 blend( Tax, TaxMixin );
 
 // Create an instant of Tax 
-var t = new Tax(50000, "NY");
+var t == new Tax(50000, "NY");
 
-var rawTax = t.calcTax();
+var rawTax == t.calcTax();
 
 // invoke a freshly blended method
 t.mafiaSpecial(rawTax);
@@ -1425,11 +1425,11 @@ Mixins can be useful is you want to provide a specific feature to a number of di
 
 If you've read this far, you should have a good understanding of the syntax of the JavaScript language. Studying the code samples provided in this appendix has one extra benefit: now you can apply for a job as a tax accountant in a mafia near you. 
 
-== JavaScript in the Web Browser
+=== JavaScript in the Web Browser
 
 After learning all these facts and techniques about the language you might be eager to see "the real-world use of JavaScript". Slowly but surely a Web browser becomes the leading platform for development of the user interface.  The vast majority today's JavaScript programs primarily manipulate HTML elements of Web pages. In this section we'll be doing exactly this – applying JavaScript code to modify the content or style of HTML elements. 
 
-=== The Document Object Model (DOM)
+==== The Document Object Model (DOM)
 
 DOM stands for Document Object Model. It's an object representing the hierarchy of HTML elements of a  Web page. Every element of the HTML document is loaded into DOM. Each DOM element has a reference to its children and siblings. When DOM was invented, the Web pages were simple and static. DOM was not meant to be an object actively accessed by the code. This is the reason that on some of the heavily populated Web pages manipulating of DOM elements can be slow. Most likely DOM is the main target for anyone who's trying to optimize the performance of a Web page.
 
@@ -1458,7 +1458,7 @@ Let's consider the operations your application needs to be able to perform insid
 Now you'll see some code samples illustrating the use of JavaScript for the operations listed above. Even if you’ll be using one of the popular JavaScript frameworks, your program will be performing similar operations applying the syntax prescribed by your framework of choice. So let's learn how it can be done.
 
 
-=== Working with DOM
+==== Working with DOM
 
 If you want to change the appearance of an HTML page, you need to manipulate with the DOM elements. Older Web applications were preparing the HTML content on the server side. For example, a server-side Java servlet would compose and send to the client HTML whenever the application logic required to change the appearance of the UI. The current trend is different - the client's code takes care of the UI rendering, and only the data go back and forth between the client and the server. You'll see how this works in more detail in Chapter 2 that explains the use of AJAX and JSON.
 
@@ -1518,11 +1518,11 @@ The next code sample contains the HTML `<span>` element that has an id `emp`. In
         <script>
            function setEmployeeOfTheMonth(){
            	   
-        	   var mySpan = document.getElementById("emp");
+        	   var mySpan == document.getElementById("emp");
 
-        	   var empName= document.getElementsByTagName("input")[1];
+        	   var empName== document.getElementsByTagName("input")[1];
         	   
-        	   mySpan.firstChild.nodeValue= empName.value;
+        	   mySpan.firstChild.nodeValue== empName.value;
         	   
         	} 	
         </script> 
@@ -1562,12 +1562,12 @@ While manipulating the content of your Web page you may you may need to traverse
         	function walkTheDOM(node, processNode){
 
                    processNode(node)  
-                    node = node.firstChild;
+                    node == node.firstChild;
 
 			      while(node){			
 			         // call wakTheDOM recursively for each child
 			         walkTheDOM(node,processNode);  
-			         node = node.nextSibling;
+			         node == node.nextSibling;
 			      }
             }
  
@@ -1696,7 +1696,7 @@ If you run this example and click on the button "Show me" you'll see an image of
 .After clicking the button "Show me"
 image::images/fig_02_23.jpg[]
 
-=== DOM Events 
+==== DOM Events 
 
 Web browser will  notify your application when some changes or interactions occur. In such cases the browser will dispatch an appropriate event, for example `load`, `unload`, `mousemove`, `click`, `keydown` etc. When the Web page finished loading the browser will dispatch the `load` event. When the user will click on the button on a Web page the `click` event will be dispatched. A Web developer needs to provide JavaScript code that will react on the events important to the application. The browser events will occur regardless of if you provided the code to handle them or not. It's important to understand some terms related to event processing.
 
@@ -1838,7 +1838,7 @@ You can see another example of using intercepting the event during the capture p
 
 TIP: The Microsoft's Web browsers Internet Explorer 8 and below didn't implement the W3C DOM Level 3 event model -  they handled events differently. You can read more on the subject at this MSDN article http://blogs.msdn.com/b/ie/archive/2010/03/26/dom-level-3-events-support-in-ie9.aspx[http://bit.ly/anZZgZ].
 
-== Summary
+=== Summary
 
 This appendix covered the JavaScript language constructs that any professional Web developer should know. A smaller portion of this chapter was illustrating how to combine JavaScript, HTML, and CSS. There are lots of online resources and books that cover just the HTML markup and CSS, and you'll definitely need to spend more time mastering details of the Web tools like Firebug or Google Developer Tools. 
 
diff --git a/ch2_html.asciidoc b/ch2_html.asciidoc
index e84a2a39..f2342e11 100644
--- a/ch2_html.asciidoc
+++ b/ch2_html.asciidoc
@@ -3,7 +3,7 @@
 
 [[appendix_b]]
 [appendix]
-= Appendix B. Selected HTML5 APIs
+== Appendix B. Selected HTML5 APIs
 
 This appendix is a brief review of selected HTML5 APIs. HTML5 is just a commonly used term for a combination of HTML, JavaScript, CSS, and several new APIs that appeared during the last several years. Five years ago people were using the term _Web 2.0_ to define modern looking applications. These days HTML5 is almost a household name, and we'll go along with it. But HTML5 is about the same old development in JavaScript plus latest advances in HTML and CSS.
 
@@ -11,7 +11,7 @@ This appendix is more of an overview of selected APIs that are included in HTML5
 
 NOTE: To understand code samples included in this appendix you have to be familiar with JavaScript and some monitoring tools like Chrome Developer Tools. We assume that you are familiar with the materials covered in Appendix A.
 
-== Does your Browser Support HTML5?
+=== Does your Browser Support HTML5?
 
 The majority of the modern Web browsers already support the current version of http://www.whatwg.org/specs/web-apps/current-work/multipage/workers.html#workers[HTML5 specification], which will become a W3C standard in 2014. The question is if the users of your Web application have a modern browser installed on their device? There are two groups of users that will stick to the outdated browsers for some time:
 
@@ -36,7 +36,7 @@ http://net.tutsplus.com/tutorials/html-css-techniques/the-official-guide-to-html
 screencast by Paul Irish], a co-creator of HTML5 Boilerplate. You can also read the current version of the
 https://github.com/h5bp/html5-boilerplate/blob/v4.0.0/doc/usage.md[Getting started with HTML5 Boilerplate] on Github.
 
-== Handling Differences in Browsers
+=== Handling Differences in Browsers
 
 This appendix is about selected HTML APIs that we find important to understand in Web applications. But before using any of the API's listed here you want to check if the versions of the Web browsers you have to user support these APIs. The Web site http://caniuse.com[http://caniuse.com] will give you the up-to-date information about all major browsers and their versions that do (or don't) support the API in question. For example, to see which browsers support Worker API visit http://caniuse.com/#search=Worker[caniuse.com].  
 
@@ -62,11 +62,11 @@ if (Modernizr.Worker) {
 )
 ----
 
-== HTML5 Web Messaging API
+=== HTML5 Web Messaging API
 
 http://www.w3.org/TR/webmessaging/[HTML5 Web Messaging] allows you to arrange for communication between different Web pages of the same Web application. More officially, it's about "communicating between browsing contexts in HTML documents". Web messaging also allows you to work around the "same domain" policy that would result in security error if a browser's page A has one origin (the combination of URL scheme, host name and port, e.g. http://myserver.com:8080) and tries to access property of a page B that was downloaded from another origin. But with messaging API windows downloaded from different origins can send messages to each other.
 
-=== Sending and Receiving Messages
+==== Sending and Receiving Messages
 
 The API is pretty straightforward: if a script in the page `WindowA` has a reference to `WindowB` where you want to send a message, invoke the following method:
 
@@ -90,9 +90,9 @@ function myEventHandler(event){
 }
 ----
 
-//The window-receiver can reject messages from untrusted origins. The event's property `origin` contains the scheme, host name and the port of the message sender (not the full URI). A simple statement like `if event.origin == 'http://mytrusteddomain:8080'` will ensure that only the messages arrived from the trusted origin are processed.
+//The window-receiver can reject messages from untrusted origins. The event's property `origin` contains the scheme, host name and the port of the message sender (not the full URI). A simple statement like `if event.origin === 'http://mytrusteddomain:8080'` will ensure that only the messages arrived from the trusted origin are processed.
 
-=== Communicating with an iFrame
+==== Communicating with an iFrame
 
 Let's consider an example where an HTML Window creates an iFrame and needs to communicate with it. In particular, the iFrame will notify the main window that it has loaded, and the main window will acknowledge receiving of this message.  
 
@@ -147,10 +147,10 @@ The source code of this example is shown next. It's just two HTML files: mainWin
              } 
         }
         
-        window.onload = function() {                  //  <4>
+        window.onload == function() {                  //  <4>
             window.addEventListener('message', handleMessage, false);
-            theiFrame = document.getElementById('myFrame');
-            theiFrame.src = "myFrame.html";		
+            theiFrame == document.getElementById('myFrame');
+            theiFrame.src == "myFrame.html";		
         }
 
    </script>
@@ -168,7 +168,7 @@ The source code of this example is shown next. It's just two HTML files: mainWin
 
 [source, javascript]
 ----
-  var myPopupWindow = window.open(...);
+  var myPopupWindow == window.open(...);
   myPopupWindow.postMessage("Hello Popup", "*");
 ----
 +
@@ -192,15 +192,15 @@ The code of the myFrame.html comes next. This frame contains two buttons Buy and
   
   <script type="text/javascript">
         
-        var senderOrigin = null;
+        var senderOrigin == null;
         
         function handleMessageInFrame(event) {
                 console.log('   My Frame got the message from ' +
                  event.origin +": " + event.data);
-                if (senderOrigin == null) senderOrigin = event.origin; // <1>
+                if (senderOrigin === null) senderOrigin == event.origin; // <1>
         }
 
-        window.onload = function(){                    
+        window.onload == function(){                    
         	window.addEventListener('message', handleMessageInFrame, false);
             parent.postMessage('loaded', "*");  // <2>
         };
@@ -222,7 +222,7 @@ The code of the myFrame.html comes next. This frame contains two buttons Buy and
 
 If you need to build a UI of the application from reusable components, applying messaging techniques allows you to create loosely coupled components. Say you've created a window for a financial trader. This window receives the data push from the server showing the latest stock prices. When a trader likes the price he may click on the Buy or Sell button to initiate a trade. The order to trade can be is implemented in a separate  window and establishing inter-window communications in a loosely coupled manner is really important. 
 
-=== Applying the Mediator Design Pattern
+==== Applying the Mediator Design Pattern
 
 Three years ago O'Reilly has published another book written by us. That book was titled "Enterprise Development with Flex", and in particular, we've described there how to apply the Mediator design pattern for creating a UI where components can communication with each other by sending-receiving events from the _mediator_ object.  The Mediator pattern remains very important in developing UI using any technologies or programming languages, and importance of the HTML5 messaging can't be underestimated. 
 
@@ -282,7 +282,7 @@ The `pattern` attribute allows you to write a regular expression that ensures th
 TIP: If you're not familiar with regular expressions, watch the presentation https://www.youtube.com/watch?v=EkluES9Rvak#at=15[Demistifying Regular Expressions]  made by Lea Verou at O'Reilly Fluent conference -  it's a good primer on this topic.
 *********
 
-== Web Workers API
+=== Web Workers API
 
 When you start a Web Browser or any other application on your computer or other device, you start _a task_ or _a process_. _A thread_ is a lighter process within another process. While JavaScript doesn't support multi-threaded mode, HTML5 has a way to run a script as a separate thread in background. 
 
@@ -293,24 +293,24 @@ Imagine an HTML5 game where a click on the button has to do some major recalcula
 In other words, use Web workers when you want to be able to run multiple parallel _threads of execution_ within the same task. 
 On a multi-processor computer parallel threads can run on different CPU’s.On a single-processor computer, threads will take turn in getting _slices_ of CPU's time. Since switching CPU cycles between threads happens fast, the user won’t notice tiny delays in each thread’s execution getting a feeling of smooth interaction.
 
-=== Creating and Communicating with Workers
+==== Creating and Communicating with Workers
 
 HTML5 offers http://www.whatwg.org/specs/web-apps/current-work/multipage/workers.html#workers[a solution] for multi-threaded execution of a script with the help of the `Worker` object. To start a separate thread of execution you'll need to create an instance of a `Worker` object passing it the name of the file with the script to run in a separate thread, for example:
 
 [source, javascript]
 ----
-var mySpellChecker = new Worker("spellChecker.js");
+var mySpellChecker == new Worker("spellChecker.js");
 ---- 
 
 The `Worker` thread runs asynchronously and can't directly communicate with the UI components (i.e. DOM elements) of the browser. When the `Worker`s script finishes execution, it can send back a message using the `postMessage()` method. Accordingly, the script that created the worker thread can listen for the event from the worker and process its responses in the event handler. Such event object will contain the data received from the worker in its property `data`, for example: 
 
 [source, javascript]
 ----
-var mySpellChecker = new Worker("spellChecker.js");
-    mySpellChecker.onmessage = function(event){
+var mySpellChecker == new Worker("spellChecker.js");
+    mySpellChecker.onmessage == function(event){
         
         // processing the worker's response 
-        document.getElementById('myEditorArea').textContent = event.data;
+        document.getElementById('myEditorArea').textContent == event.data;
     };
 ---- 
 
@@ -318,11 +318,11 @@ You can use an alternative and preferred JavaScript function `addEventListener()
 
 [source, javascript]
 ----
-var mySpellChecker = new Worker("spellChecker.js");
+var mySpellChecker == new Worker("spellChecker.js");
     mySpellChecker.addEventListener("message", function(event){
         
         // processing the worker's response
-        document.getElementById('myEditorArea').textContent = event.data;
+        document.getElementById('myEditorArea').textContent == event.data;
     });
 ----  
 
@@ -339,11 +339,11 @@ Inside the worker you also need to define an event handler to process the data s
 
 [source, javascript]
 ----
-self.onmesage = function(event){
+self.onmesage == function(event){
      
      // The code that performs spell check goes here
 	 
-	 var resultOfSpellCheck = checkSpelling(event.data);
+	 var resultOfSpellCheck == checkSpelling(event.data);
      
      // Send the results back to the window that listens
      // for the messages from this spell checker
@@ -352,18 +352,18 @@ self.onmesage = function(event){
 };
 ----
 
-If you want to run a certain code in the background repeatedly, you can create a wrapper function (e.g. `doSpellCheck()`) that internally invokes `postMesage()` and then gives such a wrapper to `setTimeout()` or `setInterval()`to run every second or so: `var timer = setTimout(doSpellCheck, 1000);`.
+If you want to run a certain code in the background repeatedly, you can create a wrapper function (e.g. `doSpellCheck()`) that internally invokes `postMesage()` and then gives such a wrapper to `setTimeout()` or `setInterval()`to run every second or so: `var timer == setTimout(doSpellCheck, 1000);`.
 
 If an error occurs in a worker thread, your Web application will get a notification in a form of an event, and you need to provide a function handler for `onerror`:
 
 [source, javascript]
 ----
-mySpellChecker.onerror = function(event){
+mySpellChecker.onerror == function(event){
     // The error handling code goes here
 };
 ----
 
-=== Dedicated and Shared Workers
+==== Dedicated and Shared Workers
 
 If a window's script creates a worker thread for its own use, we call it _a dedicated worker_.  A window creates an event listener, which gets the messages from the worker. On the other hand, the worker can have a listener too to react to the events received from its creator.   
 
@@ -371,7 +371,7 @@ A _shared worker_ thread can be used by several scripts as long as they have the
 
 [source, javascript]
 ----
-var mySpellChecker = new SharedWorker("spellChecker.js");
+var mySpellChecker == new SharedWorker("spellChecker.js");
 ---- 
 
 Another use case is funneling all requests from multiple windows to the server through a shared worker. You can also place into a shared worker a number of reusable utility function that may be needed in several windows - such architecture can reduce or eliminate repeatable code. 
@@ -380,9 +380,9 @@ One or more scripts can communicate with a shared worker, and it's done slightly
 
 [source, javascript]
 ----
-var mySpellChecker = new SharedWorker("spellChecker.js");
+var mySpellChecker == new SharedWorker("spellChecker.js");
     mySpellChecker.port.addEventListener("message", function(event){
-        document.getElementById('myEditorArea').textContent = event.data;
+        document.getElementById('myEditorArea').textContent == event.data;
     });
     mySpellChecker.port.start()
 ----
@@ -413,7 +413,7 @@ To get a more detailed coverage of Web Workers, read the O'Reilly book by Ido Gr
 
 TIP: When the user switches to another page in a browser and the current Web page loses focus you may want to stop running some processes that would unnecessary use CPU cycles. To catch this moment use the https://developer.mozilla.org/en-US/docs/Web/Guide/User_experience/Using_the_Page_Visibility_API[Page Visibility API].  
 
-== WebSockets API
+=== WebSockets API
 
 For many years Web applications were associated with HTTP as the main protocol for communication between Web browsers and servers. HTTP is a request-response based protocol that adds hundreds of additional bytes to the application data being sent between browsers and the servers. WebSocket is not a request-response, but a bi-directional full-duplex socket-based protocol, which adds only a couple of bytes (literally) to the application data . WebSockets can become a future replacement for HTTP, but Web applications that require the near-real-time communications (e.g. financial trading applications, online games or auctions) can benefit from this protocol today.  Authors of this book believe that WebSocket API is so important, that we dedicated the entire Chapter 8 of this book to this API. In this section we'll just introduce this API very briefly.
 
@@ -431,11 +431,11 @@ This is how the WebSockets workflow  goes:
 
 This is a very short description of what WebSocket API is about. We encourage you to read Chapter 8   and find the use of this great API in one of your projects.
 
-== Offline Web Applications
+=== Offline Web Applications
 
 The common misconception about Web applications is that they are useless if there is no connection to the Internet. Everyone knows that native application can be written in a way that they have everything they need installed on your device's data storage - both the application code and the data storage.  With HTML5, Web applications can be designed to be functional even when the user's device is disconnected. The offline version of a Web application may not offer full functionality, but certain functions can still be available. 
 
-=== Prerequisites for developing Offline Web Applications 
+==== Prerequisites for developing Offline Web Applications 
 
 To be useful in a disconnected mode, HTML-based application needs to have access to some local storage on the device, in which case the data entered by the user in the HTML windows can be saved locally with further synchronization with the server when connection becomes available. Think of a salesman of a pharmaceutical visiting medical offices trying to sell new pills. What if connection is not available at certain point? She can still use her tablet demonstrate the marketing materials and more importantly, collect some data about this visit and save them locally. When the Internet connection becomes  available again, the Web application should support automatic or manual data synchronization so the information about the salesman activity will be stored in a central database.
 
@@ -449,7 +449,7 @@ The business logic that supports the client's offline functionality should be de
 
 It's a good idea to create a data layer in your JavaScript code that will be responsible for all data communications. If the Internet connection is available, the data layer will be making  requests to the server, otherwise it'll get the data from the local storage. 
 
-=== Application Cache API
+==== Application Cache API
 
 First of all, application's cache is not related to the Web browser's cache. It's main reason for existence is to allow creating applications that can run even if there is no Internet connection available. The user will still go to her browser and enter the URL, but the trick is that the browser will load some previously saved Web pages from the local _application cache_. So even if the user is not online, the application will start anyway. 
 
@@ -481,7 +481,7 @@ The Web server must serve the manifest file with a MIME type "text/cache-manifes
 On each subsequent application load the browser makes a request to the server and retrieves the manifest file to see if it has been updated, in which case it reloads all previously cached files. It's a responsibility of Web developers to modify manifest on the server if any of the cacheable resources changed. 
 
 
-=== Is Your Application Offline?
+==== Is Your Application Offline?
 
 Web browsers have a `boolean` property `window.navigator.onLine`, which should be used to check if there is no connection to the Internet. The HTML5 specification states that _"The navigator.onLine attribute must return false if the user agent will not contact the network when the user follows links or when a script requests a remote page (or knows that such an attempt would fail), and must return true otherwise."_ Unfortunately, major Web browsers deal with this property differently so you need to do a thorough testing to see if it works as expected with the browser you care about. 
 
@@ -504,7 +504,7 @@ You can also add the `onoffline` and `ononline` event handlers to the `<body>` t
 What if the browser's support of the offline/online events is still not stable? In this you'll have to write your own script that will periodically make an AJAX call (see Chapter 2) trying to connect to a remote server that's always up and running, e.g. google.com. If this request fails, it's a good indication that your application is disconnected from the Internet.
 
 
-=== Options for Storing Data Locally 
+==== Options for Storing Data Locally 
 
 In the past, Web browsers could only store their own cache and application's cookies on the user's computer. 
 
@@ -524,13 +524,13 @@ NOTE: To get the current status visit caniuse.com and search for the API you're
 
 IMPORTANT: Although Web browsers send cookies to the Web server, they  don't send there the data saved in a local storage. The saved data is used only on the user's device. Also, the data saved in the local storage never expire. A Web application has to programmatically clean up the storage if need be, which will be illustrated below.
 
-=== Web Storage Specification APIs
+==== Web Storage Specification APIs
 
 With `window.localStorage` or `window.sessionStorage` (a.k.a. Web Storage) you can store any objects on the local disk as key-value pairs. Both objects implement the `Storage` interface. The main difference between the two is that the lifespan of the former is longer. If the user reloads the page, the Web browser or restart the computer - the data saved with `window.localStorage` will survive while the data saved via `window.sessionStorage` won't.
 
 Another distinction is that the data from `window.localStorage` is available for any page loaded from the same origin as the page that saved the data.  In case of `window.sessionStorage`, the data is available only to the window or a browser's tab that saved it.  
 
-==== localStorage API
+===== localStorage API
 
 Saving the application state is the main use of the local storage. Coming back to a use case with the pharmaceutical salesman, in the offline mode you can save the name of the person she talked to in a particular medical office and the notes about the conversation that took place, for example:
 
@@ -545,9 +545,9 @@ Accordingly, to retrieve the saved information you'd need to use the method `get
 
 [source, javascript]
 ----
-var officeID = localStorage.getItem('officeID');
-var contact = localStorage.getItem('contactPerson');
-var notes = localStorage.getItem('notes');
+var officeID == localStorage.getItem('officeID');
+var contact == localStorage.getItem('contactPerson');
+var notes == localStorage.getItem('notes');
 ----
 
 This code sample are pretty simple as they store single values. In the real life scenarios we often need to store multiple objects. What it our salesperson has visited several medical offices and needs to save the information about all these visits in the Web Store?  For each visit we can create a key-value combination, where a _key_ will include the unique id (e.g. office ID), and the _value_ will be a JavaScript object (e.g. Visit) turned into a JSON-formatted string (see Chapter 2  for details) using `JSON.stringify()`. 
@@ -566,7 +566,7 @@ The following code sample illustrates how to store and retrieve the custom `Visi
  <script>
   
   // Saving in local storage
-  var saveVisitInfo = function (officeVisit) {            
+  var saveVisitInfo == function (officeVisit) {            
           var visitStr=JSON.stringify(officeVisit);      // <1>
           window.localStorage.setItem("Visit:"+ visitNo, visitStr);
           window.localStorage.setItem("Visits:total", ++visitNo);
@@ -575,24 +575,24 @@ The following code sample illustrates how to store and retrieve the custom `Visi
  };
 
 // Reading from local storage
-  var readVisitInfo = function () {                      
+  var readVisitInfo == function () {                      
            
-     var totalVisits = window.localStorage.getItem("Visits:total");
+     var totalVisits == window.localStorage.getItem("Visits:total");
      console.log("readVisitInfo: total visits " + totalVisits);
      
-     for (var i = 0; i < totalVisits; i++) {    // <2>
+     for (var i == 0; i < totalVisits; i++) {    // <2>
        
-         var visit = JSON.parse(window.localStorage.getItem("Visit:" + i));
+         var visit == JSON.parse(window.localStorage.getItem("Visit:" + i));
          console.log("readVisitInfo: Office " + visit.officeId + 
                      " Spoke to " + visit.contactPerson + ": " + visit.notes);
   }
  };
 
 // Removing the visit info from local storage
-var removeAllVisitInfo = function (){             // <3>
-          var totalVisits = window.localStorage.getItem("Visits:total");  
+var removeAllVisitInfo == function (){             // <3>
+          var totalVisits == window.localStorage.getItem("Visits:total");  
           
-          for (i = 0; i < totalVisits; i++) {
+          for (i == 0; i < totalVisits; i++) {
               window.localStorage.removeItem("Visit:" + i);
       } 
   
@@ -601,10 +601,10 @@ var removeAllVisitInfo = function (){             // <3>
       console.log("removeVisits: removed all visit info"); 
 }
 
-   var visitNo = 0;
+   var visitNo == 0;
    
    // Saving the first visit's info                   
-   var visit = {                                // <4>
+   var visit == {                                // <4>
          officeId: 123,
          contactPerson: "Mary Lou",
          notes: "Drop the samples of XYZin on 12/15/2013"
@@ -612,7 +612,7 @@ var removeAllVisitInfo = function (){             // <3>
     saveVisitInfo(visit);
     
     // Saving the second visit's info           // <5>
-    visit = {
+    visit == {
          officeId: 987,
          contactPerson: "John Smith",
          notes: "They don't like XYZin - people die from it"
@@ -660,7 +660,7 @@ TIP: If you are interested in intercepting the moments when the content of local
 TIP: Another good example of a use case when  `locaStorage` becomes handy is when the user is booking air tickets using more than one browser's tab.
 
 
-==== sessionStorage API
+===== sessionStorage API
 
 The `sessionStorage` life is short - it's only available for a Web page while the browser stays open. If the user decides to refresh the page, the `sessionStorage` will survive, but opening a page in a new browser's tab or window will create a new `sessionStorage` object. Working with the session storage is pretty straightforward, for example 
 
@@ -668,7 +668,7 @@ The `sessionStorage` life is short - it's only available for a Web page while th
 ----
 sessionStorage.setItem("userID","jsmith");
 
-var userID = sessionStorage.getItem("userID");
+var userID == sessionStorage.getItem("userID");
 ---- 
 
 Chrome Developer Tools include the tab Resources that allows browsing the local or session storage if a Web page uses it. For example, <<FIG1-0>> shows the storage used by cnn.com.
@@ -677,7 +677,7 @@ Chrome Developer Tools include the tab Resources that allows browsing the local
 .Browsing local storage in Chrome Developer Tools 
 image::images/fig_01_00.png[]
 
-==== localStorage and sessionStorage Commonalities 
+===== localStorage and sessionStorage Commonalities 
 
 Both `localStorage` and `sessionStorage` are subject to the same-origin policy, meaning that saved data will be available only for the Web pages that came from the same host, port and via the same protocol.
 
@@ -690,7 +690,7 @@ There is no actual limits for the size of local storage, but the browsers usuall
 Even if the user's browser allows increasing this setting (e.g. via _about:config_ URL in Firefox), access to such data may be slow. Consider using http://www.w3.org/TR/FileAPI/[File API] or IndexedDB that will be introduced in the in the next section. 
 
 
-=== Introduction to IndexedDB
+==== Introduction to IndexedDB
 
 http://www.w3.org/TR/IndexedDB/[Indexed Database API] (a.k.a. IndexedDB) is a solution based on the NoSql database. Like with the `Storage` interface, IndexedDB stores data as key-value pairs, but it also offers  transactional handling of objects. IndexedDB creates indexes of the stored objects for fast retrieval.
 With Web Storage you can only store strings, and we had to do these tricks with JSON `stingify()` and `parse()` to give some structure to these strings. With IndexedDB you can directly store and index regular JavaScript objects. 
@@ -705,16 +705,16 @@ Since not every browser supports IndexedDB yet, you can use Modernizr (see Chapt
 
 [source, javascript]
 ----
-var medicalDB = {};   // just an object to store references 
+var medicalDB == {};   // just an object to store references 
 
-medicalDB.indexedDB = window.indexedDB || window.mozIndexedDB
+medicalDB.indexedDB == window.indexedDB || window.mozIndexedDB
       || window.msIndexedDB || window.webkitIndexedDB ;
 if (!window.indexedDB){
    // this browser doesn't support IndexedDB
 } else {
-  medicalDB.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction;
-  medicalDB.IDBCursor = window.IDBCursor || window.webkitIDBCursor;
-  medicalDB.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange;
+  medicalDB.IDBTransaction == window.IDBTransaction || window.webkitIDBTransaction;
+  medicalDB.IDBCursor == window.IDBCursor || window.webkitIDBCursor;
+  medicalDB.IDBKeyRange == window.IDBKeyRange || window.webkitIDBKeyRange;
 }
 ----
 
@@ -731,18 +731,18 @@ Similarly to relational databases you create indexes based on the searches that
 [source, javascript]
 ----
 
-var request = medicalDB.indexedDB.open('Medical_DB');     // <1>
+var request == medicalDB.indexedDB.open('Medical_DB');     // <1>
 
-request.onsuccess = function(event) {       // <2>
-    var myDB = request.result;
+request.onsuccess == function(event) {       // <2>
+    var myDB == request.result;
 
 };
 
-request.onerror = function (event) {        // <3>
+request.onerror == function (event) {        // <3>
     console.log("Can't access Medical_DB: " + event.target.errorCode);
 };
 
-request.onupgradeneeded = function(event){  // <4> 
+request.onupgradeneeded == function(event){  // <4> 
      event.currentTarget.result.createObjectStore ("Visits",
             {keypath: 'id', autoIncrement: true});
 };
@@ -758,7 +758,7 @@ request.onupgradeneeded = function(event){  // <4>
 
 TIP: There are several scenarios to consider while deciding if you need to use the `autoIncrement` property with the store key or not. Kristof Degrave described the article http://www.kristofdegrave.be/2012/02/indexed-db-to-provide-key-or-not-to.html[Indexed DB: To provide a key or not to provide a key.     
 
-==== Object Stores and Versioning
+===== Object Stores and Versioning
 
 In the world of traditional DBMS servers, when the database structure has to be modified, the DBA will do this upgrade, the server will be restarted, and the users will work with the _new version_ of the database. With IndexedDB it works differently. Each database has a version, and when the new version of the database (e.g. Medical_DB) is created, the `onupgradeneeded` is dispatched, which is where object store(s) are created. But if you already had object stores in the older version of the database, and they don't need to be changed - there is no need to re-create them.
 
@@ -768,7 +768,7 @@ The method `open()` takes a second parameter - the database version to be used.
 
 [source, javascript]
 ----
-var request = indexedDB.open('Medical_DB',3);
+var request == indexedDB.open('Medical_DB',3);
 ----
 
 If the user's computer has already the `Medical_DB` database of one of the earlier versions (1 or 2), the `onupgradeneeded` handler will be invoked.  The initial creation of the database is triggered the same way - the absence of the database also falls under the "upgrade is needed" case, and the  `onupgradeneeded` handler has to invoke the `createObjectStore()` method. If upgrade is needed, the `onupgradeneeded` will be invoked before the `onsuccess` event. 
@@ -777,8 +777,8 @@ The following code snippet creates a new or initial version of the object store
 
 [source, javascript]
 ----
-request.onupgradeneeded = function(event){  // <4> 
-  var visitsStore = 
+request.onupgradeneeded == function(event){  // <4> 
+  var visitsStore == 
      event.currentTarget.result.createObjectStore ("Visits",
          {keypath='id', 
          autoIncrement: true
@@ -797,7 +797,7 @@ Note that while creating the object store for visits, we could have used a uniqu
 
 [source, javascript]
 ----
- var visitsStore = 
+ var visitsStore == 
      event.currentTarget.result.createObjectStore ("Visits",
          {keypath='officeID'});
 ----
@@ -808,7 +808,7 @@ To remove the existing database, call the method `indexedDB.deleteDatabase()`. T
 
 WARNING: IndexedDB doesn't offer a secure way of storing data. Anyone who has access to the user's computer can get a hold of the data stored in IndexedDB. Do not store any sensitive data locally. Always use secure "https" protocol with your Web application.  
 
-==== Transactions
+===== Transactions
 
 Transaction is a logical unit of work. Executing several database operation in one transaction guarantees that the changes will be committed to the database only if all operations finished successfully. If at least one of the operations fails, the entire transaction will be rolled back (undone). IndexDB supports three transaction modes: `readonly`, `readwrite`, and `versionchange`. 
 
@@ -820,16 +820,16 @@ When a transaction is created, you should assign listeners to its `complete`, `e
 
 Typically, you should open the database and in the `onsuccess` handler create a transaction. Then open a transaction by calling the method `objectStore()` and perform data manipulations. In the next section you'll see how to add objects to an object store using transactions.
 
-==== Modyfying the Object Store Data
+===== Modyfying the Object Store Data
 
 The following code snippet creates the transaction that allows updates of the store `Visits` (you could create a transaction for more than one store) and add two visit object by invoking the method `add()`:
 
 [source, javascript]
 ----
-request.onsuccess = function(event) {       // <1>
-    var myDB = request.result;
+request.onsuccess == function(event) {       // <1>
+    var myDB == request.result;
  
-  var visitsData = [{                       // <2>
+  var visitsData == [{                       // <2>
          officeId: 123,
          contactPerson: "Mary Lou",
          notes: "Drop the samples of XYZin on 12/15/2013"
@@ -840,18 +840,18 @@ request.onsuccess = function(event) {       // <1>
          notes: "They don't like XYZin - people die from it"
     }];
 
-   var transaction = myDB.transaction(["Visits"],
+   var transaction == myDB.transaction(["Visits"],
                                       "readwrite");  // <3>
-   transaction.oncomplete = function(event){
+   transaction.oncomplete == function(event){
       console.log("All visit data have been added);
    }
 
-   transaction.onerror = function(event){
+   transaction.onerror == function(event){
       // transaction rolls back here
       console.log("Error while adding visits");
    }
 
-   var visitsStore = transaction.objectStore("Visits");  // <4>
+   var visitsStore == transaction.objectStore("Visits");  // <4>
    
     for (var i in visitsData) {                          
       visitsStore.add(visitsData[i]);       // <5>
@@ -873,29 +873,29 @@ The method `put()` allows you to update an existing object in a record store. It
 
 [source, javascript]
 ----
-var putRequest = visitsStore.put({officeID: 123, contactName: "Mary Lee"}, 1);
+var putRequest == visitsStore.put({officeID: 123, contactName: "Mary Lee"}, 1);
 ----
 
 To remove all objects from the store use the method `clear()`. To delete an object specify its id:
 
 [source, javascript]
 ----
-var deleteRequest = visitsStore.delete(1);
+var deleteRequest == visitsStore.delete(1);
 ----
 
 TIP: You can browse the data from your IndexedDB database in Chrome Developer Tools under the tab Resources (see <<FIG1-0>>).
 
-==== Retrieving the Data 
+===== Retrieving the Data 
 
 IndexedDB doesn't support SQL. You'll be using cursors to iterate through the object store. First, you open the transaction. Then you open invoke `openCursor()` on the object store. While opening the cursor you can specify optional parameters like the range of object keys you'd like to iterate and the direction of the cursor movement: `IDBCursor.PREV` or `IDBCursor.NEXT`. If none of the parameters is specified, the cursor will iterate all objects in the store in the ascending order. The following code snippet iterates through all Visit objects printing just contact names.
 
 [source, javascript]
 ----
-var transaction = myDB.transaction(["visits"], "readonly");
-var visitsStore = transaction.objectStore("Visits");
+var transaction == myDB.transaction(["visits"], "readonly");
+var visitsStore == transaction.objectStore("Visits");
 
-visitsStore.openCursor().onsuccess = function(event){
-    var visitsCursor = event.target.result;
+visitsStore.openCursor().onsuccess == function(event){
+    var visitsCursor == event.target.result;
     if (visitsCursor){
         console.log("Contact name: " + visitCursor.value.contactPerson);
         visitsCursor.continue();
@@ -906,18 +906,18 @@ If you want to iterate through a limited key range of objects you can specify th
 
 [source, javascript]
 ----
-var visitsCursor = visitsStore.openCursor(IDBKeyRange.bound(1, 5));
+var visitsCursor == visitsStore.openCursor(IDBKeyRange.bound(1, 5));
 ----
 
 You can also create a cursor on indexes - this allows working with sorted sets of objects. In one of the earlier examples we've created an index on `officeID`. Now we can get a reference to this index and create a cursor on the specified range of sorted office IDs as in the following code snippet:
 
 [source, javascript]
 ----
-var visitsStore = transaction.objectStore("visits");
-var officeIdIndex = visitsStore.index("officeID");
+var visitsStore == transaction.objectStore("visits");
+var officeIdIndex == visitsStore.index("officeID");
 
-officeIdIndex.openCursor().onsuccess = function(event){
-    var officeCursor = event.target.result;
+officeIdIndex.openCursor().onsuccess == function(event){
+    var officeCursor == event.target.result;
     // iterate through objects here
 }
 ----
@@ -938,7 +938,7 @@ If you need to fetch just one specific record, restrict the selected range to on
 contactNameIndex.openCursor(IDBKeyRange.only("Mary Lou");
 ----
 
-==== Runninng the Sample code
+===== Runninng the Sample code
 
 Let's bring together all of the above code snippets into one runnable HTML file. While doing this, we'll be watching the script execution in Chrome Developer Tools panel. We'll do it in two steps. The first version of this file will create a database of a newer version than the one that currently exists on the user's device. Here's the code that creates the database Medical_DB with an empty object store Visits:
 
@@ -952,30 +952,30 @@ Let's bring together all of the above code snippets into one runnable HTML file.
 </head>
 <body>
   <script>
-     var medicalDB = {};   // just an object to store references
+     var medicalDB == {};   // just an object to store references
      var myDB; 
 
-  medicalDB.indexedDB = window.indexedDB || window.mozIndexedDB
+  medicalDB.indexedDB == window.indexedDB || window.mozIndexedDB
         || window.msIndexedDB || window.webkitIndexedDB ;
   if (!window.indexedDB){
      // this browser doesn't support IndexedDB
   } else {
-    medicalDB.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction;
-    medicalDB.IDBCursor = window.IDBCursor || window.webkitIDBCursor;
-    medicalDB.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange;
+    medicalDB.IDBTransaction == window.IDBTransaction || window.webkitIDBTransaction;
+    medicalDB.IDBCursor == window.IDBCursor || window.webkitIDBCursor;
+    medicalDB.IDBKeyRange == window.IDBKeyRange || window.webkitIDBKeyRange;
   }
   
-  var request = medicalDB.indexedDB.open('Medical_DB', 2);  // <1> 
+  var request == medicalDB.indexedDB.open('Medical_DB', 2);  // <1> 
 
-      request.onsuccess = function(event) {       
-          myDB = request.result;
+      request.onsuccess == function(event) {       
+          myDB == request.result;
     };
 
-  request.onerror = function (event) {        
+  request.onerror == function (event) {        
       console.log("Can't access Medical_DB: " + event.target.errorCode);
   };
   
-  request.onupgradeneeded = function(event){  
+  request.onupgradeneeded == function(event){  
      event.currentTarget.result.createObjectStore ("Visits",
             {keypath:'id', autoIncrement: true});    // <2>
 };
@@ -1007,25 +1007,25 @@ The next version of our sample HTML file will populate the object store Visits w
 </head>
 <body>
   <script>
-     var medicalDB = {};   // just an object to store references 
+     var medicalDB == {};   // just an object to store references 
      var myDB;
 
-  medicalDB.indexedDB = window.indexedDB || window.mozIndexedDB
+  medicalDB.indexedDB == window.indexedDB || window.mozIndexedDB
         || window.msIndexedDB || window.webkitIndexedDB ;
   if (!window.indexedDB){
      // this browser doesn't support IndexedDB
   } else {
-    medicalDB.IDBTransaction = window.IDBTransaction || window.webkitIDBTransaction;
-    medicalDB.IDBCursor = window.IDBCursor || window.webkitIDBCursor;
-    medicalDB.IDBKeyRange = window.IDBKeyRange || window.webkitIDBKeyRange;
+    medicalDB.IDBTransaction == window.IDBTransaction || window.webkitIDBTransaction;
+    medicalDB.IDBCursor == window.IDBCursor || window.webkitIDBCursor;
+    medicalDB.IDBKeyRange == window.IDBKeyRange || window.webkitIDBKeyRange;
   }
   
-  var request = medicalDB.indexedDB.open('Medical_DB', 2);    
+  var request == medicalDB.indexedDB.open('Medical_DB', 2);    
 
-    request.onsuccess = function(event) {       
-          myDB = request.result;
+    request.onsuccess == function(event) {       
+          myDB == request.result;
 
-  var visitsData = [{                       
+  var visitsData == [{                       
            officeId: 123,
            contactPerson: "Mary Lou",
            notes: "Drop the samples of XYZin on 12/15/2013"
@@ -1036,20 +1036,20 @@ The next version of our sample HTML file will populate the object store Visits w
            notes: "They don't like XYZin - people die from it"
       }];
 
-     var transaction = myDB.transaction(["Visits"],
+     var transaction == myDB.transaction(["Visits"],
                                         "readwrite");  
-     transaction.oncomplete = function(event){
+     transaction.oncomplete == function(event){
         console.log("All visit data have been added.");
         
         readAllVisitsData();                // <1>
      }
   
-     transaction.onerror = function(event){
+     transaction.onerror == function(event){
         // transaction rolls back here
         console.log("Error while adding visits");
      }
   
-     var visitsStore = transaction.objectStore("Visits");  
+     var visitsStore == transaction.objectStore("Visits");  
      
      visitsStore.clear();                   // <2>
   
@@ -1059,27 +1059,27 @@ The next version of our sample HTML file will populate the object store Visits w
 
     };  
 
-  request.onerror = function (event) {        
+  request.onerror == function (event) {        
       console.log("Can't access Medical_DB: " + event.target.errorCode);
   };
   
-  request.onupgradeneeded = function(event){  
+  request.onupgradeneeded == function(event){  
      event.currentTarget.result.createObjectStore ("Visits",
             {keypath:'id', autoIncrement: true});
 };
   
   
 function readAllVisitsData(){
-  var readTransaction = myDB.transaction(["Visits"], "readonly");  
+  var readTransaction == myDB.transaction(["Visits"], "readonly");  
 
-   readTransaction.onerror = function(event){
+   readTransaction.onerror == function(event){
       console.log("Error while reading visits");
    }
 
-   var visitsStore = readTransaction.objectStore("Visits");  
+   var visitsStore == readTransaction.objectStore("Visits");  
    
- visitsStore.openCursor().onsuccess = function(event){   // <3>
-        var visitsCursor = event.target.result;
+ visitsStore.openCursor().onsuccess == function(event){   // <3>
+        var visitsCursor == event.target.result;
        
         if (visitsCursor){
           console.log("Contact name: " + 
@@ -1111,7 +1111,7 @@ image::images/fig_01_06.png[]
 
 This concludes our brief introduction to IndexedDB. Those of you who have experience in working with relational databases may find the querying capabilities of IndexedDB rather limited comparing to powerful relational databases like Oracle or MySQL. On the other hand, IndexedDB is pretty flexible - it allows you to store and look up any JavaScript objects without worrying about creating a database schema first. At the time of this writing there are no books dedicated to IndexedDB. For up to date information refer to https://developer.mozilla.org/en-US/docs/IndexedDB[IndexedDB online documentation] at Mozilla Developer Network. 
 
-== History API
+=== History API
 
 To put is simple, http://www.w3.org/TR/html5/browsers.html#the-history-interface[History API] is about ensuring that the Back/Forward  buttons on the browser toolbar can be controlled programmatically. Each Web browser has the `window.history` object. The History API is not new to HTML5. The `history` object has been around for many years, with methods like `back()`, `forward()`, and `go()`. But HTML5 adds new methods `pushState()` and `replaceState()`, which allow to modify the browser's address bar without reloading the Web page. 
 
@@ -1121,7 +1121,7 @@ The perfect user would always navigate your application using the menus and cont
 
 TIP: Not writing any code that would process clicks on the Back and Forward buttons is the easiest way to frustrate your users.
 
-=== Modifying the Browser's History with pushState()
+==== Modifying the Browser's History with pushState()
 
 Imagine you have a customer-management application that has a URL http://myapp.com.  The user clicked on the menu item Get Customers, which made an AJAX call loading the customers. You can programmatically change the URL on the browser's address line to be http://myapp.com/customers without asking the Web browser to make a request to  this URL. You do this by invoking the `pushState()` method. 
 
@@ -1156,14 +1156,14 @@ The `pushState()` takes three arguments (the values from the first two may be ig
   <script>
     
      function whoWeAre(){
-     	var locationID= {locID: 123,                            // <2>
+     	var locationID== {locID: 123,                            // <2>
      		        uri: '/whoweare'};
      	
      	history.pushState(locationID,'', 'who_we_are' );       // <3> 
      }
      
      function whatWeDo(){
-     	var actionID= {actID: 123,                              // <4>
+     	var actionID== {actID: 123,                              // <4>
      		          uri: '/whatwedo'};
 
      	history.pushState(actionID,'', 'what_we_do' );          // <5>
@@ -1194,7 +1194,7 @@ image::images/fig_01_11.png[]
 Using the `replaceState()` you can technically "change the history". We are talking about the browser's history, of course.
 
 
-=== Processing the popstate Event
+==== Processing the popstate Event
 
 But changing the URL when the user clicks on the Back or Forward button is just the half of the job to be done. The content of the page has to be refreshed accordingly. The browser dispatches the event `window.popstate` whenever the browser's navigation history changes either on initial page load, as a result of clicking on the Back/Forward buttons, or by invoking `history.back()` or `history.forward()`. 
 
@@ -1232,7 +1232,7 @@ We've included this sidebar in this appendix, even though it's not API. But we'r
 Behind the scenes, a custom framework can find all elements that have the `data-phone` attribute and generate some additional code for processing of the provided phone number. If this example doesn't impress you, wait till Chapter 10, where you'll learn how to use jQuery Mobile. The creators of this library use these `data-` attributes in a very smart way.
 *****
 
-== Summary
+=== Summary
 
 In this appendix you've got introduced to a number of useful HTML5 APIs. You know how to check if a particular API is supported by your Web browser. But what if you are one of many enterprise developers that must use Internet Explorer of the versions earlier than 10.0? Google used to offer a nice solution:  http://www.google.com/chromeframe[Google Chrome Frame], which was a plugin for Internet Explorer.
 
diff --git a/ch3_mockup.asciidoc b/ch3_mockup.asciidoc
index 7b21ecc9..8f667033 100644
--- a/ch3_mockup.asciidoc
+++ b/ch3_mockup.asciidoc
@@ -1,4 +1,4 @@
-= Part 1. Building Your Application
+= Building Your Application
 
 This book has three parts. In Part 1 we'll start building Web applications. We'll be building and re-building a sample application titled Save The Child.
 
@@ -740,7 +740,7 @@ In this section we'll add a video player to our Save The Child application. The
 
 ==== Adding the HTML5 Video Element 
 
-Let's run the project called project-05-html5-video to see the video playing, and after that we'll review the code. The new version of the Sick The  Child app should look as in <<FIG3-12>. The users will see an embedded video player on the right that can play the video located in the assets/media folder of the project project-05-html5-video. 
+Let's run the project called project-05-html5-video to see the video playing, and after that we'll review the code. The new version of the Sick The  Child app should look as in <<FIG3-12>>. The users will see an embedded video player on the right that can play the video located in the assets/media folder of the project project-05-html5-video. 
 
 [[FIG3-12]]
 .The video player is embeded 
diff --git a/ch6_ext_js.asciidoc b/ch6_ext_js.asciidoc
index f155ab24..2f5217c4 100644
--- a/ch6_ext_js.asciidoc
+++ b/ch6_ext_js.asciidoc
@@ -1,7 +1,7 @@
 :toc:
 :toclevels: 4
 
-= Part 2. Enterprise Considerations
+= Enterprise Considerations
 
 The content of this part justifies having the word Enterprise on this book's cover. 
 
@@ -230,7 +230,7 @@ Ext.application({
 });
 ----
 
-Finally, if you'll open index.html in your Web browser, you'll see our Hello World initial Web page that looks as in <<Fig6-2>>. This view uses so called `border` layout and shows a `panel` on the west and a `tabpanel` in the central region of the view. 
+Finally, if you'll open index.html in your Web browser, you'll see our Hello World initial Web page that looks as in <<FIG6-2>>. This view uses so called `border` layout and shows a `panel` on the west and a `tabpanel` in the central region of the view. 
 
 [[FIG6-2]]
 .The UI of our Sencha CMD-generated Application