Fix up spacing in extras

Few copy editing things

Author: Ivoz

extras/css.md

@@ -17,11 +17,10 @@ CSS Frameworks make it easier to manage styles for these larger, more complicate
 
 Here is an example of a two-column layout:
 
-
-	<div class="row">
-		<div class="column-3">Left sidebar</div>
-		<div class="column-9">Main content</div>
-	</div>
+    <div class="row">
+      <div class="column-3">Left sidebar</div>
+      <div class="column-9">Main content</div>
+    </div>
 
 **Typographical reset**. This is a font reset that looks a little more pleasing to the eye. It sets things like line spacing and font size.
 
@@ -46,18 +45,18 @@ There are in fact a few entire languages that are dedicated to CSS. These langua
 
 A common problem is how to deal with colours. For example if you had a corporate colour scheme of `#3311FF` your CSS would be littered with `#3311FF` references:
 
-	.nav { background-color: #3311FF; }
-	.button { border-color: #3311FF; }
-	.cake .icing { color: #3311FF; }
+    .nav { background-color: #3311FF; }
+    .button { border-color: #3311FF; }
+    .cake .icing { color: #3311FF; }
 
 In a CSS language you would be able to use a variable instead:
 
-	$corporate_color: #3311FF;
-	.nav { background-color: $corporate_color; }
-	.button { border-color: $corporate_color; }
-	.cake .icing { color: $corporate_color; }
+    $corporate_color: #3311FF;
+    .nav { background-color: $corporate_color; }
+    .button { border-color: $corporate_color; }
+    .cake .icing { color: $corporate_color; }
 
-Use of a CSS language is very common in large websites these days. Here are some of the more popular ones in use today:
+And if you later decided that the colour needed to be #3311EE instead, there would only be one place you needed to change it! Use of a CSS language is very common in large websites these days. Here are some of the more popular ones in use today:
 
 * [SASS](http://sass-lang.com/) is one of the original CSS languages. It uses the Ruby programming language under the hood. You might like to try the [Python](https://pypi.python.org/pypi/pyScss/1.1.5) port which is compatible with SASS 3.2. You can also take a look at [Compass](http://compass-style.org/) which pushes SASS even further.
 * [LESS](http://lesscss.org/) has a very similar philosophy. It is written in JavaScript, so it can either be run in the browser or, using Node, on the server.

extras/databases.md

@@ -5,22 +5,22 @@ title: Databases
 
 There is a reason why we haven't used a more permanent method for storing our email addresses, and that's because _databases are complicated_. Seriously.
 
-But fortunately they are not that difficult once you get the hang of it. Since the 1970s many databases have standardised on using the **SQL** language. It defines how to store and search data in _tables_, which contain _columns_. If you learn SQL then you can use quite a lot of different databases.
+But fortunately they are not that difficult once you get the hang of it. Since the 1970s many databases have standardised on using the **SQL** language. It defines how to store and search data in _tables_, which contain _columns_, and rows of data usually referred to as _records_. If you learn SQL then you can use quite a lot of different databases.
 
-Because of their size and complexity databases are generally written as their own separate servers that run in addition to your web server. That comes with additional work that we probably don't need at this moment. For now we'll use [SQLite](http://www.sqlite.org/) which is a very widely used database engine that just happens to come bundled in Python.
+Because of their size and complexity databases are generally written as their own separate servers that run in addition to your web server. That comes with additional work that we probably don't need at this moment. For now we'll use [SQLite](http://www.sqlite.org/) which is a simple and very widely used database engine that just happens to come bundled in Python.
 
 ## Creating the database
 
 Since Python 2.5 the SQLite library has shipped in the standard distribution. This means it should be available already. You can import the `sqlite3` library in a Python shell to see if it works:
 
-	>>> import sqlite3
+    >>> import sqlite3
 
 We are going to start by creating a database in a file called `emails.db`. It will have one table called `email_addresses` which will keep all our emails. Make sure your Python shell started in the same directory as your website code.
 
-	>>> conn = sqlite3.connect("emails.db")
-	>>> cursor = conn.cursor()
-	>>> cursor.execute("CREATE TABLE email_addresses ( email TEXT );")
-	<sqlite3.Cursor object at 0xb7467ce0>
+    >>> conn = sqlite3.connect("emails.db")
+    >>> cursor = conn.cursor()
+    >>> cursor.execute("CREATE TABLE email_addresses ( email TEXT );")
+    <sqlite3.Cursor object at 0xb7467ce0>
 
 Here you can see we connected to `emails.db` (this file didn't exist, so SQLite created it). We opened a _cursor_, which is what allows us to send commands, and executed a _CREATE TABLE_ statement to create the email addresses table. It has one column, _email_, which can just be a string of text.
 
@@ -30,21 +30,21 @@ The Flask documentation has a [section](http://flask.pocoo.org/docs/patterns/sql
 
 We'll need to import the `g` object from Flask, as well as `sqlite3`:
 
-	from flask import g
-	import sqlite3
+    from flask import g
+    import sqlite3
 
 Now we use `@app.before_request` to run a function before every request from the browser:
 
-	@app.before_request
-	def before_request():
-		g.db = sqlite3.connect("emails.db")
+    @app.before_request
+    def before_request():
+        g.db = sqlite3.connect("emails.db")
 
 Likewise we use `@app.teardown_request` to close the database connection after every request.
 
-	@app.teardown_request
-	def teardown_request(exception):
-		if hasattr(g, 'db'):
-		g.db.close()
+    @app.teardown_request
+    def teardown_request(exception):
+        if hasattr(g, 'db'):
+        g.db.close()
 
 ## Adding a new email address
 
@@ -65,15 +65,15 @@ Now that we have all our emails stored in a database we have to use a _SELECT_ s
 
     @app.route('/emails.html')
     def emails():
-        email_addresses = g.db.execute("SELECT email FROM     email_addresses").fetchall()
-        return render_template('emails.html', email_addresses =     email_addresses)
+        email_addresses = g.db.execute("SELECT email FROM email_addresses").fetchall()
+        return render_template('emails.html', email_addresses=email_addresses)
 
 You might notice that the list of emails now looks a little strange on the web page. This is because the `g.db.execute()` statement returns an entire tuple for _every_ email address. In the Python console it looks like this:
 
-	>>> db.execute('select * from email_addresses').fetchall()
-	[(u'eroaskdlg',), (u'kjzdfhks',), (u'lksrlajkr',)]
+    >>> db.execute('select * from email_addresses').fetchall()
+    [(u'eroaskdlg',), (u'kjzdfhks',), (u'lksrlajkr',)]
 
-So every email is actually a list. The email itself is at position 0 in the list. So update the emails template to use position 0:
+So every item in the list is actually a tuple (a non-modifiable list). The email itself is at position 0 in each tuple. So update the emails template to print just the first element:
 
 {% raw %}
 
@@ -85,7 +85,7 @@ So every email is actually a list. The email itself is at position 0 in the list
 
 {% endraw %}
 
-And that's it! You can now restart the web server as many times as you like! All the emails are now stored directly in the database.
+And that's it! You can now restart the web server as many times as you like, and your list of emails will remain! All the emails are now stored directly in the database.
 
 ## Further Reading
 

extras/sessions.md

@@ -21,7 +21,7 @@ It sure does, and they're very simple to use. Firstly, **add `session` as anothe
 
 Then you need to give flask a secret key to use, to make sure the session is secure. To get a nice secret key, **run this at a command prompt**:
 
-     python -c "import os; print repr(os.urandom(24))"
+    python -c "import os; print repr(os.urandom(24))"
      
 and copy the string you get. To set this as the flask app's secret key, just **add the following line** after you initialize your `app` (use your own key!):
 
@@ -69,4 +69,8 @@ Here, we use a few `if` checks to make sure that our user added an email address
 
 * Allow the app to remember when a user has already registered their email, and not show them an email input form when they have (maybe say Thanks! for signing up). Check out the [Jinja2 template documentation](http://jinja.pocoo.org/docs/templates/) if you'd like to use a little template logic to help with this. You could change the above button so that it also only shows after registering an email.
 
+Extra points:
+
 * Add a "protected" page which allows you to delete any email address, and a very simple admin login system (with just a single password) to access it. You can use a session to determine whether someone is currently logged in or not. This might be a little more difficult, but any challengers are welcome to try it out! You can check out the code sample [here](http://flask.pocoo.org/docs/quickstart/#sessions) for some hints on how to go about that.
+
+* Integrate these features into using your databases as needed