Small fixes regarding Assembly (#55)

* Make code C89 compiliant

* Clarification

Hand-crafted assembly can be more efficent than compiler-generated one, because as a human You know better, what does the code mean, making it easier to express, ultimatly reducing size or/and increasing efficency.

* Assembly can be (but doesn't have to!) programmer ...

... friendly.

* Hexadecimal is more readable and ...

...  makes text less quack. Also, X86 assembly is more popular.

* Linter is way too pedantic.

Author: kspalaiologos

book/languages/assembly/advantages.md

@@ -8,7 +8,7 @@ Since machine code and assembly are tied together, assembly can be used in appli
 The assembly language can be used in these types of application:
 
 * To build software which requires serious machine level optimizations or to beat compilers in code optimization. \
-  For e.g.: System software in an OS (not needed though as modern compilers do a pretty good job).
+  For e.g.: System software in an OS.
 
 * In embedded programming where space is limited to an extent that higher level languages
   (like C) can use more space than required or actually present.

book/languages/assembly/disadvantages.md

@@ -3,12 +3,12 @@
 Consider the same example as in the previous section to add two numbers, lets say 1 and 2, but this time it is written in C.
 
 ```C
-#include<stdio.h>
-int main()
-{
+#include <stdio.h>
+
+int main(void) {
     int x = 1;
     int y = 2;
-    int z = x+y;
+    int z = x + y;
     return 0;
 }
 ```
@@ -21,12 +21,12 @@ But there is a trade-off between the performance offered by assembly language an
 
 * The entire code in assembly language could turn out to be monstrous in some stage cannot, because of which it can't be handled or maintained easily.
 
-* Manually writing in assembly language for large programs such as an OS for instance can be frustrating.
+* Manually writing in assembly language for large programs such as an OS for instance can be frustrating (but doesn't have to).
 
 ## Birth of the higher-level languages
 
-Even though assembly language offers high performance it cannot be effectively used to build user applications, because a higher abstraction is necessary to do so.
-Also, it is not “programmer friendly” in the sense that it still remains a low level language and can be difficult to grasp or understand.
+Even though assembly language offers high performance it cannot be effectively used to build user applications, because a higher abstraction is really helpful to do so.
+Also, it is not “programmer friendly” in the sense that it still remains a low level language and can be difficult to grasp or understand for casual programmers.
 Hence, a need for abstracting assembly language itself arises which is both understandable and “programmer friendly”.
 
 From this need new assembly languages were born with a higher abstraction, which were more “programmer friendly” than the initial low level assembly languages, but they still remained assembly languages.

book/languages/assembly/what_it_solves.md

@@ -5,30 +5,30 @@ Consider this instruction, where we have to add the two numbers 1 and 2.
 ## Assembly
 
 ```assembly
-addi x5 x0 1
-addi x6 x0 2
-add x7 x5 x6
+mov edx, 1
+mov eax, 2
+add eax, edx
 ```
 
-## Binary
+## Hexadecimal
 
-```binary
-000000000001001010000000000100110000000000100011000000000001001100000000011100101000001101100011
+```hex
+ba01000000b80200000001d0
 ```
 
-## Binary in human readable format
+## More readable hexadecimal
 
 ```binary
-0000000 00001 00101 000 00000 0010011
-0000000 00010 00110 000 00000 0010011
-0000000 00111 00101 000 00110 1100011
+0:  ba 01 00 00 00   mov edx,0x1
+5:  b8 02 00 00 00   mov eax,0x2
+a:  01 d0            add eax,edx
 ```
 
-## Binary with a mistake. Happy debugging
+## Binary code with a mistake. Happy debugging
 
 ```binary
 000000000001001010000000000100110000000000100011000000000001001100000000010100101000001101100011
 ```
 
 The purpose of an assembly language can easily be seen with the help of the above example. Assembly language with the help of its syntax makes it easier to code and not worry about trivial tasks such as opcodes, address calculations, etc. Mistakes if any can easily identified in assembly
-rather than in binary. Imagine finding such mistakes in a pool of 0's and 1's!
+rather than in binary. Imagine finding such mistakes in a pool of just a numbers!