Merge pull request #495 from batjko/patch-1

Ironed out some spelling and grammar issues.

docs/tutorial/quick-start.md

@@ -2,48 +2,47 @@
 
 ## Introduction
 
-Generally atom-shell enables you to create desktop applications with pure
+Generally, atom-shell enables you to create desktop applications with pure
 JavaScript by providing a runtime with rich native APIs. You could see it as
-an variant of the Node.js runtime which is focused on desktop applications
-instead of web server.
+a variant of the Node.js runtime which is focused on desktop applications
+instead of web servers.
 
 It doesn't mean atom-shell is a JavaScript binding to GUI libraries. Instead,
-atom-shell uses web pages as GUI, so you could also see it as a minimal Chromium
+atom-shell uses web pages as its GUI, so you could also see it as a minimal Chromium
 browser, controlled by JavaScript.
 
 ### The browser side
 
-If you had experience with Node.js web applications, you would notice that there
+If you have experience with Node.js web applications, you will know that there
 are two types of JavaScript scripts: the server side scripts and the client side
-scripts. The server side JavaScript are the scripts that run on the Node.js
-runtime, and the client side JavaScript are the ones that run on user's browser.
+scripts. Server-side JavaScript is that which runs on the Node.js
+runtime, while client-side JavaScript runs inside the user's browser.
 
-In atom-shell we have similar concepts, since atom-shell displays GUI by showing
-web pages, we would have **scripts that run in the web page**, and also have
-**scripts ran by the atom-shell runtime**, which created those web pages.
-Like Node.js, we call them **client scripts**, and **browser scripts**.
+In atom-shell we have similar concepts: Since atom-shell displays a GUI by showing
+web pages, we have **scripts that run in the web page**, and also **scripts run by the atom-shell runtime**, which creates those web pages.
+Like Node.js, we call them **client scripts**, and **browser scripts** (meaning the browser replaces the concept of the server here).
 
-In traditional Node.js applications, communication between server side and
-client side are usually done by web sockets. In atom-shell, we have provided
-the [ipc](../api/ipc-renderer.md) module for browser side to client
+In traditional Node.js applications, communication between server and
+client is usually facilitated via web sockets. In atom-shell, we have provided
+the [ipc](../api/ipc-renderer.md) module for browser to client
 communication, and the [remote](../api/remote.md) module for easy RPC
 support.
 
 ### Web page and Node.js
 
-Normal web pages are designed to not touch outside world, which makes them
+Normal web pages are designed to not reach outside of the browser, which makes them
 unsuitable for interacting with native systems. Atom-shell provides Node.js APIs
-in web pages so you could access native resources in web pages, just like
+in web pages so you can access native resources from web pages, just like
 [Node-Webkit](https://github.com/rogerwang/node-webkit).
 
-But unlike Node-Webkit, you could not do native GUI related operations in web
-pages, instead you need to do them on the browser side by sending messages or
-use the easy [remote](../api/remote.md) module.
+But unlike Node-Webkit, you cannot do native GUI related operations in web
+pages. Instead you need to do them on the browser side by sending messages to it, or
+using the easy [remote](../api/remote.md) module.
 
 
 ## Write your first atom-shell app
 
-Generally, an atom-shell app would be like this (see this repo for reference [hello-atom](https://github.com/dougnukem/hello-atom)):
+Generally, an atom-shell app would be structured like this (see the   [hello-atom](https://github.com/dougnukem/hello-atom) repo for reference):
 
 ```text
 your-app/
@@ -52,9 +51,9 @@ your-app/
 └── index.html
 ```
 
-The format of `package.json` is exactly the same with Node's modules, and the
+The format of `package.json` is exactly the same as that of Node's modules, and the
 script specified by the `main` field is the startup script of your app, which
-will run under the browser side. An example of your `package.json` is like
+will run on the browser side. An example of your `package.json` might look like
 this:
 
 ```json
@@ -65,8 +64,8 @@ this:
 }
 ```
 
-The `main.js` should create windows and handle system events, and a typical
-example is:
+The `main.js` should create windows and handle system events, a typical
+example being:
 
 ```javascript
 var app = require('app');  // Module to control application life.
@@ -122,10 +121,10 @@ Finally the `index.html` is the web page you want to show:
 
 ## Run your app
 
-After you're done writing your app, you could create a distribution by
+After you're done writing your app, you can create a distribution by
 following the [Application distribution](./application-distribution.md) guide
-and then execute the packaged app. You can also just use the downloaded atom-shell
-binary to execute your app directly.
+and then execute the packaged app. 
+You can also just use the downloaded atom-shell binary to execute your app directly.
 
 On Windows:
 
@@ -145,4 +144,4 @@ On Mac OS X:
 $ ./Atom.app/Contents/MacOS/Atom your-app/
 ```
 
-`Atom.app` here is in the atom-shell's release package, you can download it from [here](https://github.com/atom/atom-shell/releases).
+`Atom.app` here is part of the atom-shell's release package, you can download it from [here](https://github.com/atom/atom-shell/releases).