diff --git a/guide/english/computer-science/just-in-time-compilation/index.md b/guide/english/computer-science/just-in-time-compilation/index.md
index 2dd160d3f6..28e3e94b52 100644
--- a/guide/english/computer-science/just-in-time-compilation/index.md
+++ b/guide/english/computer-science/just-in-time-compilation/index.md
@@ -24,11 +24,11 @@ What is important to understand about the JIT compilation, is that it will compi
 
 Two examples of JIT Compilers are : JVM (Java Virtual Machine) in Java and CLR (Common Language Runtime), in C#.
 
-## JIT stands for Just-in-Time which means that code gets compiled when it is needed, not before runtime.
+## JIT stands for Just-in-Time, which means that code gets compiled when it is needed, not before runtime.
 
 In the beginning, a compiler was responsible for turning a high-level language (defined as higher level than assembler) into object code (machine instructions), which would then be linked (by a linker) into an executable.
 
-At one point in the evolution of languages, compilers would compile a high-level language into pseudo-code, which would then be interpreted (by an interpreter) to run your program. This eliminated the object code and executables, and allowed these languages to be portable to multiple operating systems and hardware platforms. Pascal (which compiled to P-Code) was one of the first; Java and C# are more recent examples. Eventually the term P-Code was replaced with bytecode, since most of the pseudo-operations are a byte long.
+At one point in the evolution of languages, compilers would compile a high-level language into pseudo-code, which would then be interpreted (by an interpreter) to run your program. This eliminated the object code and executables and allowed these languages to be portable to multiple operating systems and hardware platforms. Pascal (which compiled to P-Code) was one of the first; Java and C# are more recent examples. Eventually the term P-Code was replaced with bytecode, since most of the pseudo-operations are a byte long.
 
 A Just-In-Time (JIT) compiler is a feature of the run-time interpreter, that instead of interpreting bytecode every time a method is invoked, will compile the bytecode into the machine code instructions of the running machine, and then invoke this object code instead. Ideally the efficiency of running object code will overcome the inefficiency of recompiling the program every time it runs.
 
@@ -60,9 +60,9 @@ In Android it is in DVM (Dalvik Virtual Machine), or ART (Android RunTime) in ne
 
 Java Virtual Machine (JVM)( JVM executes bytecode) maintains a count as of how many time a function is executed. If this count exceeds a predefined limit JIT compiles the code into machine language which can directly be executed by the processor (unlike the normal case in which javac compile the code into bytecode and then java - the interpreter interprets this bytecode line by line converts it into machine code and executes).
 
-Also next time this function is calculated same compiled code is executed again unlike normal interpretation in which the code is interpreted again line by line. This makes execution faster.
+Also, next time this function is calculated same compiled code is executed again unlike normal interpretation in which the code is interpreted again line by line. This makes execution faster.
 
 #### More Information
 
 - [JIT Compilation (Wikipedia)](https://en.wikipedia.org/wiki/Just-in-time_compilation)
-- [JIT Introduction](https://eli.thegreenplace.net/2013/11/05/how-to-jit-an-introduction/)
\ No newline at end of file
+- [JIT Introduction](https://eli.thegreenplace.net/2013/11/05/how-to-jit-an-introduction/)