This was originally published on Journalism.co.uk – cross-posted here for convenience.
Journalists rely on two sources of competitive advantage: being able to work faster than others, and being able to get more information than others. For both of these reasons, I love scraping: it is both a great time-saver, and a great source of stories no one else has. Continue reading
Next week I will start publishing my first ebook: Scraping for Journalists.
Although I’ve written about scraping before on the blog, this book is designed to take the reader step by step through a series of tasks (a chapter each) which build a gradual understanding of the principles and techniques for tackling scraping problems. Everything has a direct application for journalism, and each principle is related to their application in scraping for newsgathering.
For example: the first scraper requires no programming knowledge, and is working within 5 minutes of reading.
I’m using Leanpub for this ebook, because it allows you to publish in installments and update the book for users – which suits a book like this perfectly, as I’ll be publishing chapters week by week, Codecademy-style.
If you want to be alerted when the book is ready register on the book’s Leanpub page.
With local elections looming this is a great 20-30 minute project for any journalist wanting to create an interactive Google map of council ward boundaries.
For this you will need:
OpenlyLocal are trying to scrape planning application data from across the country. They want volunteers to help write the scrapers using Scraperwiki – and are paying £75 for each one.
This is a great opportunity for journalists or journalism students looking for an excuse to write their first scraper: there are 3 sample scrapers to help you find your feet, with many more likely to appear as they are written. Hopefully, some guidance will appear too (if not, I may try to write some myself).
Add your names in the comments on Andrew’s blog post, and happy scraping!
For the first Something For The Weekend of 2012 I want to tackle a common problem when you’re trying to scrape a collection of webpage: they have some sort of structure in their URL like this, where part of the URL refers to the name or code of an entity:
In this instance, you can see that the URL is identical apart from a 7 digit code at the end: the ID of the school the data refers to.
There are a number of ways you could scrape this data. You could use Google Docs and the =importXML formula, but Google Docs will only let you use this 50 times on any one spreadsheet (you could copy the results and select Edit > Paste Special > Values Only and then use the formula a further 50 times if it’s not too many – here’s one I prepared earlier).
And you could use Scraperwiki to write a powerful scraper – but you need to understand enough coding to do so quickly (here’s a demo I prepared earlier).
A middle option is to use Google Refine, and here’s how you do it.
With the basic URL structure identified, we already have half of our ingredients. What we need next is a list of the ID codes that we’re going to use to complete each URL.
An advanced search for “list seed number scottish schools filetype:xls” brings up a link to this spreadsheet (XLS) which gives us just that.
The spreadsheet will need editing: remove any rows you don’t need. This will reduce the time that the scraper will take in going through them. For example, if you’re only interested in one local authority, or one type of school, sort your spreadsheet so that you can delete those above or below them.
Now to combine the ID codes with the base URL.
Open Google Refine and create a new project with the edited spreadsheet containing the school IDs.
At the top of the school ID column click on the drop-down menu and select Edit column > Add column based on this column…
In the New column name box at the top call this ‘URL’.
In the Expression box type the following piece of GREL (Google Refine Expression Language):
“http://www.ltscotland.org.uk/scottishschoolsonline/schools/freemealentitlement.asp?iSchoolID=”+value
(Type in the quotation marks yourself – if you’re copying them from a webpage you may have problems)
The ‘value’ bit means the value of each cell in the column you just selected. The plus sign adds it to the end of the URL in quotes.
In the Preview window you should see the results – you can even copy one of the resulting URLs and paste it into a browser to check it works. (On one occasion Google Refine added .0 to the end of the ID number, ruining the URL. You can solve this by changing ‘value’ to value.substring(0,7) – this extracts the first 7 characters of the ID number, omitting the ‘.0’) UPDATE: in the comment Thad suggests “perhaps, upon import of your spreadsheet of IDs, you forgot to uncheck the importer option to Parse as numbers?”
Click OK if you’re happy, and you should have a new column with a URL for each school ID.
Now click on the top of this new URL column and select Edit column > Add column by fetching URLs…
In the New column name box at the top call this ‘HTML’.
All you need in the Expression window is ‘value’, so leave that as it is.
Click OK.
Google Refine will now go to each of those URLs and fetch the HTML contents. As we have a couple thousand rows here, this will take a long time – hours, depending on the speed of your computer and internet connection (it may not work at all if either isn’t very fast). So leave it running and come back to it later.
When it’s finished you’ll have another column where each cell is a bunch of HTML. You’ll need to create a new column to extract what you need from that, and you’ll also need some GREL expressions explained here.
First you need to identify what data you want, and where it is in the HTML. To find it, right-click on one of the webpages containing the data, and search for a key phrase or figure that you want to extract. Around that data you want to find a HTML tag like <table class=”destinations”> or <div id=”statistics”>. Keep that open in another window while you tweak the expression we come onto below…
Back in Google Refine, at the top of the HTML column click on the drop-down menu and select Edit column > Add column based on this column…
In the New column name box at the top give it a name describing the data you’re going to pull out.
In the Expression box type the following piece of GREL (Google Refine Expression Language):
value.parseHtml().select(“table.destinations”)[0].select(“tr”).toString()
(Again, type the quotation marks yourself rather than copying them from here or you may have problems)
I’ll break down what this is doing:
parse the HTML in each cell (value)
find a table with a class (.) of “destinations” (in the source HTML this reads <table class=”destinations”>. If it was <div id=”statistics”> then you would write .select(“div#statistics”) – the hash sign representing an ‘id’ and the full stop representing a ‘class’.
[0]
This zero in square brackets tells Refine to only grab the first table – a number 1 would indicate the second, and so on. This is because numbering (“indexing”) generally begins with zero in programming.
Now, within that table, find anything within the tag <tr>
And convert the results into a string of text.
The results of that expression in the Preview window should look something like this:
<tr> <th></th> <th>Abbotswell School</th> <th>Aberdeen City</th> <th>Scotland</th> </tr> <tr> <th>Percentage of pupils</th> <td>25.5%</td> <td>16.3%</td> <td>22.6%</td> </tr>
This is still HTML, but a much smaller and manageable chunk. You could, if you chose, now export it as a spreadsheet file and use various techniques to get rid of the tags (Find and Replace, for example) and split the data into separate columns (the =SPLIT formula, for example).
Or you could further tweak your GREL code in Refine to drill further into your data, like so:
value.parseHtml().select(“table.destinations”)[0].select(“td”)[0].toString()
Which would give you this:
<td>25.5%</td>
Or you can add the .substring function to strip out the HTML like so (assuming that the data you want is always 5 characters long):
value.parseHtml().select(“table.destinations”)[0].select(“td”)[0].toString().substring(5,10)
When you’re happy, click OK and you should have a new column for that data. You can repeat this for every piece of data you want to extract into a new column.
Then click Export in the upper right corner and save as a CSV or Excel file.
More on how this data was used on Help Me Investigate Education.
Quite often when you’re looking for data as part of a story, that data will not be on a single page, but on a series of pages. To manually copy the data from each one – or even scrape the data individually – would take time. Here I explain a way to use Google Docs to grab the data for you.
Although Google Docs is a pretty clumsy tool to use to scrape webpages, the method used is much the same as if you were writing a scraper in a programming language like Python or Ruby. For that reason, I think this is a good quick way to introduce the basics of certain types of scrapers.
Here’s how it works:
Firstly, you need a list of links to the pages containing data.
Quite often that list might be on a webpage which links to them all, but if not you should look at whether the links have any common structure, for example “http://www.country.com/data/australia” or “http://www.country.com/data/country2″. If it does, then you can generate a list by filling in the part of the URL that changes each time (in this case, the country name or number), assuming you have a list to fill it from (i.e. a list of countries, codes or simple addition).
Second, you need the destination pages to have some consistent structure to them. In other words, they should look the same (although looking the same doesn’t mean they have the same structure – more on this below).
The scraper then cycles through each link in your list, grabs particular bits of data from each linked page (because it is always in the same place), and saves them all in one place.
If you’ve not used =importXML before it’s worth catching up on my previous 2 posts How to scrape webpages and ask questions with Google Docs and =importXML and Asking questions of a webpage – and finding out when those answers change.
This takes things a little bit further.
In this case I’m going to scrape some data for a story about local history – the data for which is helpfully published by the Durham Mining Museum. Their homepage has a list of local mining disasters, with the date and cause of the disaster, the name and county of the colliery, the number of deaths, and links to the names and to a page about each colliery.
However, there is not enough geographical information here to map the data. That, instead, is provided on each colliery’s individual page.
So we need to go through this list of webpages, grab the location information, and pull it all together into a single list.
To do this we need to isolate which part of the homepage contains the list. If you right-click on the page to ‘view source’ and search for ‘Haig’ (the first colliery listed) we can see it’s in a table that has a beginning tag like so: <table border=0 align=center style=”font-size:10pt”>
We can use =importXML to grab the contents of the table like so:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, ”//table[starts-with(@style, ‘font-size:10pt’)]“)
But we only want the links, so how do we grab just those instead of the whole table contents?
The answer is to add more detail to our request. If we look at the HTML that contains the link, it looks like this:
<td valign=top><a href=”http://www.dmm.org.uk/colliery/h029.htm“>Haig Pit</a></td>
So it’s within a <td> tag – but all the data in this table is, not surprisingly, contained within <td> tags. The key is to identify which <td> tag we want – and in this case, it’s always the fourth one in each row.
So we can add “//td[4]” (‘look for the fourth <td> tag’) to our function like so:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, ”//table[starts-with(@style, ‘font-size:10pt’)]//td[4]“)
Now we should have a list of the collieries – but we want the actual URL of the page that is linked to with that text. That is contained within the value of the href attribute – or, put in plain language: it comes after the bit that says href=”.
So we just need to add one more bit to our function: “//@href”:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, ”//table[starts-with(@style, ‘font-size:10pt’)]//td[4]//@href”)
So, reading from the far right inwards, this is what it says: “Grab the value of href, within the fourth <td> tag on every row, of the table that has a style value of font-size:10pt”
Note: if there was only one link in every row, we wouldn’t need to include //td[4] to specify the link we needed.
Now we have a list – but we still need to scrape some information from each link in that list
Firstly, we need to identify the location of information that we need on the linked pages. Taking the first page, view source and search for ‘Sheet 89′, which are the first two words of the ‘Map Ref’ line.
The HTML code around that information looks like this:
<td valign=top>(Sheet 89) NX965176, 54° 32' 35" N, 3° 36' 0" W</td>
Looking a little further up, the table that contains this cell uses HTML like this:
<table border=0 width=”95%”>
So if we needed to scrape this information, we would write a function like this:
=importXML(“http://www.dmm.org.uk/colliery/h029.htm”, “//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]“)
…And we’d have to write it for every URL.
But because we have a list of URLs, we can do this much quicker by using cell references instead of the full URL.
So. Let’s assume that your formula was in cell C2 (as it is in this example), and the results have formed a column of links going from C2 down to C11. Now we can write a formula that looks at each URL in turn and performs a scrape on it.
In D2 then, we type the following:
=importXML(C2, “//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]“)
If you copy the cell all the way down the column, it will change the function so that it is performed on each neighbouring cell.
In fact, we could simplify things even further by putting the second part of the function in cell D1 – without the quotation marks – like so:
//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]
And then in D2 change the formula to this:
=ImportXML(C2,$D$1)
(The dollar signs keep the D1 reference the same even when the formula is copied down, while C2 will change in each cell)
Now it works – we have the data from each of 8 different pages. Almost.
The problem is that the structure of those pages is not as consistent as we thought: the scraper is producing extra cells of data for some, which knocks out the data that should be appearing there from other cells.
So I’ve used an IF formula to clean that up as follows:
In cell E2 I type the following:
=if(D2=””, ImportXML(C2,$D$1), D2)
Which says ‘If D2 is empty, then run the importXML formula again and put the results here, but if it’s not empty then copy the values across‘
That formula is copied down the column.
But there’s still one empty column even now, so the same formula is used again in column F:
=if(E2=””, ImportXML(C2,$D$1), E2)
As I said earlier, this isn’t the best way to write a scraper, but it is a useful way to start to understand how they work, and a quick method if you don’t have huge numbers of pages to scrape. With hundreds of pages, it’s more likely you will miss problems – so watch out for inconsistent structure and data that doesn’t line up.
Quite often when you’re looking for data as part of a story, that data will not be on a single page, but on a series of pages. To manually copy the data from each one – or even scrape the data individually – would take time. Here I explain a way to use Google Docs to grab the data for you.
Although Google Docs is a pretty clumsy tool to use to scrape webpages, the method used is much the same as if you were writing a scraper in a programming language like Python or Ruby. For that reason, I think this is a good quick way to introduce the basics of certain types of scrapers.
Here’s how it works:
Firstly, you need a list of links to the pages containing data.
Quite often that list might be on a webpage which links to them all, but if not you should look at whether the links have any common structure, for example “http://www.country.com/data/australia” or “http://www.country.com/data/country2”. If it does, then you can generate a list by filling in the part of the URL that changes each time (in this case, the country name or number), assuming you have a list to fill it from (i.e. a list of countries, codes or simple addition).
Second, you need the destination pages to have some consistent structure to them. In other words, they should look the same (although looking the same doesn’t mean they have the same structure – more on this below).
The scraper then cycles through each link in your list, grabs particular bits of data from each linked page (because it is always in the same place), and saves them all in one place.
If you’ve not used =importXML before it’s worth catching up on my previous 2 posts How to scrape webpages and ask questions with Google Docs and =importXML and Asking questions of a webpage – and finding out when those answers change.
This takes things a little bit further.
In this case I’m going to scrape some data for a story about local history – the data for which is helpfully published by the Durham Mining Museum. Their homepage has a list of local mining disasters, with the date and cause of the disaster, the name and county of the colliery, the number of deaths, and links to the names and to a page about each colliery.
However, there is not enough geographical information here to map the data. That, instead, is provided on each colliery’s individual page.
So we need to go through this list of webpages, grab the location information, and pull it all together into a single list.
To do this we need to isolate which part of the homepage contains the list. If you right-click on the page to ‘view source’ and search for ‘Haig’ (the first colliery listed) we can see it’s in a table that has a beginning tag like so: <table border=0 align=center style=”font-size:10pt”>
We can use =importXML to grab the contents of the table like so:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, “//table[starts-with(@style, ‘font-size:10pt’)]”)
But we only want the links, so how do we grab just those instead of the whole table contents?
The answer is to add more detail to our request. If we look at the HTML that contains the link, it looks like this:
<td valign=top><a href=”http://www.dmm.org.uk/colliery/h029.htm“>Haig Pit</a></td>
So it’s within a <td> tag – but all the data in this table is, not surprisingly, contained within <td> tags. The key is to identify which <td> tag we want – and in this case, it’s always the fourth one in each row.
So we can add “//td[4]” (‘look for the fourth <td> tag’) to our function like so:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, “//table[starts-with(@style, ‘font-size:10pt’)]//td[4]”)
Now we should have a list of the collieries – but we want the actual URL of the page that is linked to with that text. That is contained within the value of the href attribute – or, put in plain language: it comes after the bit that says href=”.
So we just need to add one more bit to our function: “//@href”:
=Importxml(“http://www.dmm.org.uk/mindex.htm”, “//table[starts-with(@style, ‘font-size:10pt’)]//td[4]//@href”)
So, reading from the far right inwards, this is what it says: “Grab the value of href, within the fourth <td> tag on every row, of the table that has a style value of font-size:10pt”
Note: if there was only one link in every row, we wouldn’t need to include //td[4] to specify the link we needed.
Now we have a list – but we still need to scrape some information from each link in that list
Firstly, we need to identify the location of information that we need on the linked pages. Taking the first page, view source and search for ‘Sheet 89’, which are the first two words of the ‘Map Ref’ line.
The HTML code around that information looks like this:
<td valign=top>(Sheet 89) NX965176, 54° 32' 35" N, 3° 36' 0" W</td>
Looking a little further up, the table that contains this cell uses HTML like this:
<table border=0 width=”95%”>
So if we needed to scrape this information, we would write a function like this:
=importXML(“http://www.dmm.org.uk/colliery/h029.htm”, “//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]”)
…And we’d have to write it for every URL.
But because we have a list of URLs, we can do this much quicker by using cell references instead of the full URL.
So. Let’s assume that your formula was in cell C2 (as it is in this example), and the results have formed a column of links going from C2 down to C11. Now we can write a formula that looks at each URL in turn and performs a scrape on it.
In D2 then, we type the following:
=importXML(C2, “//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]”)
If you copy the cell all the way down the column, it will change the function so that it is performed on each neighbouring cell.
In fact, we could simplify things even further by putting the second part of the function in cell D1 – without the quotation marks – like so:
//table[starts-with(@width, ‘95%’)]//tr[2]//td[2]
And then in D2 change the formula to this:
=ImportXML(C2,$D$1)
(The dollar signs keep the D1 reference the same even when the formula is copied down, while C2 will change in each cell)
Now it works – we have the data from each of 8 different pages. Almost.
The problem is that the structure of those pages is not as consistent as we thought: the scraper is producing extra cells of data for some, which knocks out the data that should be appearing there from other cells.
So I’ve used an IF formula to clean that up as follows:
In cell E2 I type the following:
=if(D2=””, ImportXML(C2,$D$1), D2)
Which says ‘If D2 is empty, then run the importXML formula again and put the results here, but if it’s not empty then copy the values across‘
That formula is copied down the column.
But there’s still one empty column even now, so the same formula is used again in column F:
=if(E2=””, ImportXML(C2,$D$1), E2)
As I said earlier, this isn’t the best way to write a scraper, but it is a useful way to start to understand how they work, and a quick method if you don’t have huge numbers of pages to scrape. With hundreds of pages, it’s more likely you will miss problems – so watch out for inconsistent structure and data that doesn’t line up.
Previously I wrote on how to use the =importXML formula in Google Docs to pull information from an XML page into a conventional spreadsheet. In this Something For The Weekend post I’ll show how to take that formula further to grab information from webpages – and get updates when that information changes.
Despite its name, the =importXML formula can be used to grab information from HTML pages as well. This post on SEO Gadget, for example, gives a series of examples ranging from grabbing information on Twitter users to price information and web analytics (it also has some further guidance on using these techniques, and is well worth a read for that).
Asking questions of webpages typically requires more advanced use of XPath than I outlined previously – and more trial and error.
This is because, while XML is a language designed to provide structure around data, HTML – used as it is for a much wider range of purposes – isn’t quite so tidy.
To illustrate how you can use =importXML to grab data from a webpage, I’m going to grab data from Gorkana, a job ads site.
If you look at their journalists jobs page, you’ll see all sorts of information, from navigation and ads to feeds and policies. This is how you could grab a specific piece of data from a page, and put it into a table structure, to answer any questions you might have:
Make a note of the first word or phrase in the section you want (e.g. “Senior account executive”) then right-click on the page and select View Source or whatever option allows you to see the HTML code behind the page.
You could scroll through this to try to find the bit you want, but it’s easier to use your search facility to find that key phrase you noted earlier (e.g. “Senior account executive”)
What you’re hoping to find is some sort of div class tag just above that key phrase – and in this case there’s one called div class=”jobWrap”
This means that the creator of the webpage has added some structure to it, wrapping all their job ads in that div.
We just need to write a formula that is equally specific.
Open up a spreadsheet in Google Docs and write the following formula in cell B1:
=importXML(“http://www.gorkanajobs.co.uk/jobs/journalist/”, “//div[starts-with(@class, ‘jobWrap’)]“)
When you press Enter you should see 3 columns filled with values from that particular part of the webpage: the job title; the package; and a brief description. Now that you have this data in a structured format you could, for example, work out average wages of job ads, or the most common job titles.
But how did that formula work? As I’ve explained most of =importXML in the previous post, I’ll just explain the query part here. So:
//div
is looking for a tag that begins
[starts-with
is specifying that the this div must begin in a particular way, and it does so by grabbing one thing, and looking for another thing within it:
(@class, ‘jobWrap’)
is saying that the div class should contain ‘jobWrap’ (bonus points: the @ sign indicates an attribute; class is an attribute of the div; ‘jobWrap’ is the value of the attribute)
]
…finishes off that test.
Even if you don’t understand the code itself, you can adapt it to your own purposes as long as you can find the right div class tag and replace ‘jobWrap’ with whatever the value is in your case.
It doesn’t even have to be a div class – you could replace //div with other tags such as //p for each paragraph fitting a particular criteria.
You can also replace @class with another attribute, such as @id or @title. It depends on the HTML of the page you’re trying to grab information from.
Why has this data been put into 3 columns? The answer is in the HTML again. You’ll see that the job title is between h4 tags. The location and package is within ul tags and the description is within p tags, before each div is closed with the tag /div
But if you keep reading that HTML you’ll also see that after that /div there is some more information within a different div tag: div class=”adBody”. This contains the name of the recruiter and a link to a page where you can apply. There’s also a third div with a link to an image of the recruiter.
You could adapt your importXML formula to grab these instead – or add a new formula in D2 to add this extra information alongside the others (watch out for mismatches where one div may be missing for some reason).
You’ll notice that the formula above grabs text, but not the links within each job ad. To do that we need to adapt the formula as follows. Try typing this in cell D2:
=ImportXML(“http://www.gorkanajobs.co.uk/jobs/journalist/”, “//div[starts-with(@class, ‘jobWrap’)]//@href”)
This is identical to the previous formula, with one addition at the end:
//@href
What this does is grab the value of any link in the HTML. In other words, the bit after a href=”
You’ll notice that the results are partial URLs, such as /job/3807/senior-account-executive-account-manager/
These are known as relative URLs, because they are relative to the site they are on, but will not work when placed on another site.
This is easily cleaned up. In cell E2 type the following:
=CONCATENATE(“http://www.gorkanajobs.co.uk”,D2)
This creates a new URL beginning with http://www.gorkanajobs.co.uk and ending with the contents of cell D2 – the relative URL. Copy the formula down the column so it works for all cells in column D.
Not all websites will be so structured. The more structured the webpage – or the data within it – the better. But you may have to dig into the HTML and/or tweak your formula to find that structure. Or you may have to settle for some rough and ready data that you clean later.
The key advantage of =importXML, however, is how it is able to pull information from HTML into a table that you can then interrogate, with different columns for different parts of that data.
For more help with these processes you can find explanations of how to write expressions in XPath here but be prepared to use trial and error to get the right expression for the question you’re asking. The Vancouver Data Blog offers some specific examples that can be easily adapted.
Finally, this can be useful because Google Docs allows you to receive notifications whenever any changes are made, and to publish your spreadsheet as an RSS feed. This is explained in this blog post, which is also the source of the movie above.
And if you want to see all of this in action I’ve published an example spreadsheet demonstrating all the above techniques here.
Previously I wrote on how to use the =importXML formula in Google Docs to pull information from an XML page into a conventional spreadsheet. In this Something For The Weekend post I’ll show how to take that formula further to grab information from webpages – and get updates when that information changes.
Animation from Digital Inspiration
Despite its name, the =importXML formula can be used to grab information from HTML pages as well. This post on SEO Gadget, for example, gives a series of examples ranging from grabbing information on Twitter users to price information and web analytics (it also has some further guidance on using these techniques, and is well worth a read for that).
Asking questions of webpages typically requires more advanced use of XPath than I outlined previously – and more trial and error.
This is because, while XML is a language designed to provide structure around data, HTML – used as it is for a much wider range of purposes – isn’t quite so tidy.
To illustrate how you can use =importXML to grab data from a webpage, I’m going to grab data from Gorkana, a job ads site.
There have been quite a few scraping-related stories that I’ve been meaning to blog about – so many I’ve decided to write a round up instead. It demonstrates just the increasing role that scraping is playing in journalism – and the possibilities for those who don’t know them:
Chris Taggart explains how he built a database of corporations which will be particularly useful to journalists and anyone looking at public spending:
“Let’s have a look at one we did earlier: the Isle of Man (there’s also one for Gibraltar, Ireland, and in the US, the District of Columbia) … In the space of a couple of hours not only have we liberated the data, but both the code and the data are there for anyone else to use too, as well as being imported in OpenCorporates.”
OpenCorporates are also offering a bounty for programmers who can scrape company information from other jurisdictions.
The Scraperwiki blog gives the story behind a front page investigation by James Ball on lobbyist influence in the UK Parliament: Continue reading
Online Journalism Blog 