Adds code explanation

Author: Pavithra K

content/pluginsapi/compiler.md

@@ -7,7 +7,7 @@ The `Compiler` module of webpack is the main engine that creates a compilation i
 
 It is exported by `webpack` api under `webpack.Compiler`.
 
-The compiler is used by webpack by instantiating it and then calling the `run` method.
+The compiler is used by webpack by instantiating it and then calling the `run` method. Below is a trivial example of how one might use the `Compiler`. In fact, this is very close to how webpack itself uses it.
 
 [__compiler-examples__](https://github.com/pksjce/webpack-internal-examples/blob/master/compiler-example.js)
 
@@ -37,27 +37,38 @@ new LogPlugin().apply(compiler);
 /* Add other supporting plugins */
 
 // Callback to be executed after run is complete
-const callback = () => {
-    console.log('Compiler has finished execution.')
+const callback = (err, stats) => {
+    console.log('Compiler has finished execution.');
+    /* Do something to show the stats */
 };
 
 // call run on the compiler along with the callback
 compiler.run(callback);
 ```
 
-?>TODO: Add more explanation of how above code works explaining compiler parts and hooks.
-Also tell Tapable is mixed in with Compiler.Differentiate between Compiler's and Tapable's methods
+The `Compiler` is what we call a `Tapable` instance. By this, we mean that it mixes in `Tapable` class to imbibe functionality to register and call plugins on itself.
+All user facing plugins are first registered on the `Compiler`.
+The working of a Compiler can be condensed into the following highlights
+ - Usually there is one master instance of Compiler. Child instances for delegating are possible.
+ - A lot of the complexity in creating a compiler goes into populating all the relevant options for it.
+ - `webpack` has [`WebpackOptionsDefaulter`](https://github.com/webpack/webpack/blob/master/lib/WebpackOptionsDefaulter.js) and [`WebpackOptionsApply`](https://github.com/webpack/webpack/blob/master/lib/WebpackOptionsApply.js) specifically designed to provide the `Compiler` with all the intial data it requires.
+ - The `Compiler` is just a skeleton which performs bare minimum functionality to keep a lifecycle running. It delegates all the loading/bundling/writing work to various plugins.
+ - `new LogPlugin(args).apply(compiler)` registers the plugin to any particular hook event in the `Compiler`'s lifecycle.
+ - The `Compiler` exposes a `run` method which kickstarts all compilation work for `webpack`. When that is done, it should call the passed in `callback` function. All the tail end work of logging stats and errors are done in this callback function.
 
 ## Watching
 
-?>TODO: Add that compiler duplicates all above functionality and adds watch functionality to it. Highlight differences.
+However, the `Compiler` supports two flavors of execution. One on watch mode and one on a normal single run.
+While it essentially performs the same functionality while watching, there are some subtle changes to the lifecycle events. This allows `webpack` to have Watch specific plugins.
 
 ## MultiCompiler
 
 ?> Can create child compilers?
 
 ## Event Hooks
 
+This a reference guide to all the event hooks exposed by the `Compiler`.
+
 ?>TODO: For each hook follow template of
 1. event name
 2. reason for event.