From 4499e5eb6e7f6dcc9e6f9ab48d97199de7f2a29b Mon Sep 17 00:00:00 2001 From: Maja Komel Date: Wed, 22 Apr 2020 17:54:56 +0200 Subject: [PATCH] [deploy] Add Wikipedia liquid tag (#7193) --- app/assets/images/wikipedia-logo.svg | 4 + app/assets/stylesheets/ltags/LiquidTags.scss | 1 + .../stylesheets/ltags/WikipediaTag.scss | 62 +++++++++++ app/liquid_tags/wikipedia_tag.rb | 102 ++++++++++++++++++ app/views/liquids/_wikipedia.html.erb | 12 +++ app/views/pages/_editor_guide_text.html.erb | 7 ++ docs/frontend/liquid-tags.md | 1 + spec/liquid_tags/wikipedia_tag_spec.rb | 37 +++++++ .../vcr_cassettes/wikipedia_section_tag.yml | 86 +++++++++++++++ .../fixtures/vcr_cassettes/wikipedia_tag.yml | 86 +++++++++++++++ 10 files changed, 398 insertions(+) create mode 100644 app/assets/images/wikipedia-logo.svg create mode 100644 app/assets/stylesheets/ltags/WikipediaTag.scss create mode 100644 app/liquid_tags/wikipedia_tag.rb create mode 100644 app/views/liquids/_wikipedia.html.erb create mode 100644 spec/liquid_tags/wikipedia_tag_spec.rb create mode 100644 spec/support/fixtures/vcr_cassettes/wikipedia_section_tag.yml create mode 100644 spec/support/fixtures/vcr_cassettes/wikipedia_tag.yml diff --git a/app/assets/images/wikipedia-logo.svg b/app/assets/images/wikipedia-logo.svg new file mode 100644 index 000000000..165b3f62c --- /dev/null +++ b/app/assets/images/wikipedia-logo.svg @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/app/assets/stylesheets/ltags/LiquidTags.scss b/app/assets/stylesheets/ltags/LiquidTags.scss index 898ea4e7f..529b1a487 100644 --- a/app/assets/stylesheets/ltags/LiquidTags.scss +++ b/app/assets/stylesheets/ltags/LiquidTags.scss @@ -13,3 +13,4 @@ @import 'PollTag'; @import 'ClassifiedListingTag'; @import 'StackexchangeTag'; +@import 'WikipediaTag'; diff --git a/app/assets/stylesheets/ltags/WikipediaTag.scss b/app/assets/stylesheets/ltags/WikipediaTag.scss new file mode 100644 index 000000000..8888e1400 --- /dev/null +++ b/app/assets/stylesheets/ltags/WikipediaTag.scss @@ -0,0 +1,62 @@ +@import 'variables'; +.ltag__wikipedia--container { + border: 1px solid $light-medium-gray; + border-radius: 3px; + box-shadow: $shadow; + margin: 1.1em auto 1.3em; + font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Helvetica, Arial, + sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol' !important; + overflow: hidden; + max-width: 620px; + padding: 0.8em 0.5em 0; + a { + color: #0366d6 !important; + color: var(--theme-anchor-color, #0366d6) !important; + } + .ltag__wikipedia--header { + font-weight: 400; + font-size: 1.2em; + line-height: 1.3em; + margin: 0em 0px 0.5em; + .ltag__wikipedia--logo { + width: 1.15em; + max-width: 1.1em; + display: inline-block; + left: 0px; + margin-right: 0.3em; + vertical-align: -0.18em; + filter: invert(0); + filter: var(--theme-social-icon-invert, invert(0)); + } + } + .ltag__wikipedia--extract { + font-weight: 400; + margin: 0; + margin-left: 0.15em; + font-size: 0.75em; + line-height: 1.5em; + padding-bottom: 1em; + } + .ltag__wikipedia--btn--container { + padding: 0.1em 0 1.15em; + z-index: 100; + text-align: center; + position: relative; + box-shadow: 0px 0px 60px 42px #fff; + box-shadow: 0px 0px 60px 42px var(--theme-container-background, #fff); + } + .ltag__wikipedia--btn { + color: #0366d6; + background-color: #f1f8ff; + border-radius: 3px; + line-height: 20px; + padding: 0.25em 1.2em; + opacity: 0.9; + font-weight: bold; + border: 1px solid #0366d6; + font-size: 0.75em; + &:hover { + opacity: 1; + } + } +} diff --git a/app/liquid_tags/wikipedia_tag.rb b/app/liquid_tags/wikipedia_tag.rb new file mode 100644 index 000000000..bf2902a34 --- /dev/null +++ b/app/liquid_tags/wikipedia_tag.rb @@ -0,0 +1,102 @@ +class WikipediaTag < LiquidTagBase + PARTIAL = "liquids/wikipedia".freeze + WIKI_REGEXP = %r{^https?://([a-z-]+)\.wikipedia.org/wiki/([\S]+)$}.freeze + + def initialize(tag_name, input, tokens) + super + @data = get_data(input.strip) + end + + def render(_context) + ActionController::Base.new.render_to_string( + partial: PARTIAL, + locals: { + title: @data[:title], + extract: @data[:extract], + url: @data[:url] + }, + ) + end + + private + + def valid_url?(input) + input.match?(WIKI_REGEXP) + end + + def get_data(input) + url = ActionController::Base.helpers.strip_tags(input).strip + raise StandardError, "Invalid Wikipedia URL" unless valid_url?(url) + + uri = URI.parse(url) + lang = uri.host.split(".", 2).first + title = uri.path.split("/").last + anchor = uri.fragment + + if anchor + parse_page_with_anchor(url, lang, title, anchor) + else + parse_page(url, lang, title) + end + end + + def parse_page_with_anchor(url, lang, title, anchor) + api_url = "https://#{lang}.wikipedia.org/api/rest_v1/page/mobile-sections/#{title}" + response = HTTParty.get(api_url, headers: { 'user-agent': URL.url("/contact") }) + handle_response_error(response, url) + + text, section_title = get_section_contents(response, anchor, url) + title = "#{response['lead']['normalizedtitle']} - #{section_title}" + + { + title: title, + url: url, + extract: text_clean_up(text) + } + end + + def parse_page(url, lang, title) + api_url = "https://#{lang}.wikipedia.org/api/rest_v1/page/summary/#{title}" + response = HTTParty.get(api_url, headers: { 'user-agent': URL.url("/contact") }) + handle_response_error(response, url) + + { + title: response["title"], + url: url, + extract: response["extract_html"] + } + end + + def handle_response_error(response, input) + return if response.code == 200 + + raise StandardError, "Couldn't find the Wikipedia article - #{input}: #{response['detail']}" + end + + def get_section_contents(response, anchor, input) + text = title = "" + response["remaining"]["sections"].each do |section| + if section["anchor"] == CGI.unescape(anchor) + text = section["text"] + title = section["line"] + end + end + + return [text, title] if title.present? + + raise StandardError, "Couldn't find the section of the Wikipedia article - #{input}" + end + + def text_clean_up(text) + doc = Nokogiri::HTML(text) + path_expression = "//div[contains(@class, 'noprint') or contains(@class, 'hatnote')] | + //span[@class='mw-ref'] | + //figure | + //sup" + doc.xpath(path_expression).each(&:remove) + doc.xpath("//a").each { |x| x.replace Nokogiri::XML::Text.new(x.inner_html, x.document) } + doc.to_html + end +end + +Liquid::Template.register_tag("wikipedia", WikipediaTag) diff --git a/app/views/liquids/_wikipedia.html.erb b/app/views/liquids/_wikipedia.html.erb new file mode 100644 index 000000000..b2d8922df --- /dev/null +++ b/app/views/liquids/_wikipedia.html.erb @@ -0,0 +1,12 @@ +
+
+ " class="ltag__wikipedia--logo" alt="Wikipedia Logo" aria-label="Wikipedia Logo"> + <%= title %> +
+
<%= (HTML_Truncator.truncate extract, 150).html_safe %>
+
+ +
+
diff --git a/app/views/pages/_editor_guide_text.html.erb b/app/views/pages/_editor_guide_text.html.erb index 9f19f9b7e..181c76ef6 100644 --- a/app/views/pages/_editor_guide_text.html.erb +++ b/app/views/pages/_editor_guide_text.html.erb @@ -332,6 +332,13 @@ 
{% stackexchange 170185 diy %}

+

Wikipedia Embed

+

Enter the full URL of the Wikipedia article you want to embed, with or without the anchor.

+

+ {% wikipedia https://en.wikipedia.org/wiki/Wikipedia %} +
+ {% wikipedia https://en.wikipedia.org/wiki/Wikipedia#Diversity %} +

Asciinema Embed

All you need is the Asciinema id:

{% asciinema 239367 %} diff --git a/docs/frontend/liquid-tags.md b/docs/frontend/liquid-tags.md index 040497911..fd0d46ed5 100644 --- a/docs/frontend/liquid-tags.md +++ b/docs/frontend/liquid-tags.md @@ -53,6 +53,7 @@ Here is a bunch of liquid tags supported on DEV: {% spotify spotify:episode:5V4XZWqZQJvbddd31n56mf %} {% blogcast 1234 %} {% kotlin https://pl.kotl.in/owreUFFUG %} +{% wikipedia https://en.wikipedia.org/wiki/Wikipedia %} ``` ## How liquid tags are developed diff --git a/spec/liquid_tags/wikipedia_tag_spec.rb b/spec/liquid_tags/wikipedia_tag_spec.rb new file mode 100644 index 000000000..6db297efa --- /dev/null +++ b/spec/liquid_tags/wikipedia_tag_spec.rb @@ -0,0 +1,37 @@ +require "rails_helper" + +RSpec.describe WikipediaTag, type: :liquid_tag, vcr: true do + describe "#id" do + let(:valid_url) { "https://en.wikipedia.org/wiki/Wikipedia" } + let(:valid_section_url) { "https://en.wikipedia.org/wiki/Wikipedia#Diversity" } + let(:invalid_url) { "https://123.wikipedia.org/wiki/Wiki" } + + def generate_new_liquid(url) + Liquid::Template.register_tag("wikipedia", WikipediaTag) + Liquid::Template.parse("{% wikipedia #{url} %}") + end + + it "renders wikipedia excerpt html" do + VCR.use_cassette("wikipedia_tag") do + liquid = generate_new_liquid(valid_url) + expect(liquid.render).to include("ltag__wikipedia") + expect(liquid.render).to include("Wikipedia is a multilingual online encyclopedia") + end + end + + it "renders wikipedia article section html" do + VCR.use_cassette("wikipedia_section_tag") do + liquid = generate_new_liquid(valid_section_url) + expect(liquid.render).to include("ltag__wikipedia") + expect(liquid.render).to include("Several studies have shown that most of the Wikipedia contributors are male.") + end + end + + it "rejects invalid url" do + expect do + liquid = generate_new_liquid(invalid_url) + liquid.render + end.to raise_error(StandardError) + end + end +end diff --git a/spec/support/fixtures/vcr_cassettes/wikipedia_section_tag.yml b/spec/support/fixtures/vcr_cassettes/wikipedia_section_tag.yml new file mode 100644 index 000000000..6fd0ee78b --- /dev/null +++ b/spec/support/fixtures/vcr_cassettes/wikipedia_section_tag.yml @@ -0,0 +1,86 @@ +--- +http_interactions: +- request: + method: get + uri: https://en.wikipedia.org/api/rest_v1/page/mobile-sections/Wikipedia + body: + encoding: US-ASCII + string: '' + headers: + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + User-Agent: + - Ruby + response: + status: + code: 200 + message: OK + headers: + Content-Language: + - en + Content-Type: + - application/json; charset=utf-8; profile="https://www.mediawiki.org/wiki/Specs/mobile-sections/0.14.5" + Vary: + - Accept-Encoding + Cache-Control: + - s-maxage=1209600, max-age=0, must-revalidate + Content-Location: + - https://en.wikipedia.org/api/rest_v1/page/mobile-sections/Wikipedia + Access-Control-Allow-Origin: + - "*" + Access-Control-Allow-Methods: + - GET,HEAD + Access-Control-Allow-Headers: + - accept, content-type, content-length, cache-control, accept-language, api-user-agent, + if-match, if-modified-since, if-none-match, dnt, accept-encoding + Access-Control-Expose-Headers: + - etag + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + Referrer-Policy: + - origin-when-cross-origin + X-Xss-Protection: + - 1; mode=block + Content-Security-Policy: + - default-src 'none'; frame-ancestors 'none' + X-Content-Security-Policy: + - default-src 'none'; frame-ancestors 'none' + X-Webkit-Csp: + - default-src 'none'; frame-ancestors 'none' + X-Request-Id: + - 1ce19f3c-1cf3-44a7-8c6f-367461236230 + Server: + - restbase1020 + Date: + - Thu, 16 Apr 2020 10:36:05 GMT + Etag: + - W/"951253630/bc726ab0-7fb3-11ea-b5ad-4fb52f3dd7c0" + Age: + - '0' + X-Cache: + - cp3052 miss, cp3056 pass + X-Cache-Status: + - pass + Server-Timing: + - cache;desc="pass" + Strict-Transport-Security: + - max-age=106384710; includeSubDomains; preload + X-Client-Ip: + - 89.12.52.122 + Accept-Ranges: + - bytes + Transfer-Encoding: + - chunked + Connection: + - keep-alive + body: + encoding: ASCII-8BIT + string: !binary |- + {"lead":{"ns":0,"id":5043734,"revision":"951253630","lastmodified":"2020-04-16T07:27:09Z","lastmodifier":{"user":"Jerry Steinfield","gender":"unknown"},"displaytitle":"Wikipedia","normalizedtitle":"Wikipedia","wikibase_item":"Q52","description":"Free online encyclopedia that anyone can edit","description_source":"local","protection":{"edit":["autoconfirmed"],"move":["sysop"]},"editable":false,"languagecount":284,"image":{"file":"Wikipedia-logo-v2.svg","urls":{"320":"https://upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/320px-Wikipedia-logo-v2.svg.png","640":"https://upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/640px-Wikipedia-logo-v2.svg.png","800":"https://upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/800px-Wikipedia-logo-v2.svg.png","1024":"https://upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/1024px-Wikipedia-logo-v2.svg.png"}},"pronunciation":{"url":"//upload.wikimedia.org/wikipedia/commons/c/c5/En-uk-Wikipedia.ogg"},"hatnotes":["This article is about this encyclopedia. For the English edition, see <a rel=\"mw:WikiLink\" href=\"./English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia</a>. For Wikipedia's home page, see <a rel=\"mw:WikiLink\" href=\"./Main_Page\" title=\"Main Page\">Main Page</a>. For Wikipedia's visitor introduction, see <a rel=\"mw:WikiLink\" href=\"./Wikipedia:About\" title=\"Wikipedia:About\">Wikipedia:About</a>. For other uses, see <a rel=\"mw:WikiLink\" href=\"./Wikipedia_(disambiguation)\" title=\"Wikipedia (disambiguation)\" class=\"mw-disambig\">Wikipedia (disambiguation)</a>.","\"The Free Encyclopedia\" redirects here. For a list of other encyclopedias, see <a rel=\"mw:WikiLink\" href=\"./Lists_of_encyclopedias\" title=\"Lists of encyclopedias\">Lists of encyclopedias</a>."],"sections":[{"id":0,"text":"<p><b>Wikipedia</b> (<span class=\"rt-commentedText nowrap\"><span class=\"IPA nopopups noexcerpt\"><a href=\"/wiki/Help:IPA/English\" title=\"Help:IPA/English\">/<span style=\"border-bottom:1px dotted\"><span>ˌ</span><span>w</span><span>ɪ</span><span>k</span><span>ɪ</span><span>ˈ</span><span>p</span><span>iː</span><span>d</span><span>i</span><span>ə</span></span>/</a></span><span> </span><span class=\"nowrap\" style=\"font-size:85%\">(<span class=\"unicode haudio\"><span class=\"fn\"><span style=\"white-space:nowrap;margin-right:.25em;\"><figure-inline><a href=\"/wiki/File:En-uk-Wikipedia.ogg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/11px-Loudspeaker.svg.png\" data-file-width=\"20\" data-file-height=\"20\" data-file-type=\"drawing\" height=\"11\" width=\"11\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/22px-Loudspeaker.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/17px-Loudspeaker.svg.png 1.5x\"></a></figure-inline></span><a href=\"//upload.wikimedia.org/wikipedia/commons/c/c5/En-uk-Wikipedia.ogg\" resource=\"./Media:En-uk-Wikipedia.ogg\" title=\"En-uk-Wikipedia.ogg\">listen</a></span></span>)</span></span> <a href=\"/wiki/Help:Pronunciation_respelling_key\" title=\"Help:Pronunciation respelling key\"><i title=\"English pronunciation respelling\">wik-ih-<span style=\"font-size:90%\">PEE</span>-dee-ə</i></a> or <span class=\"rt-commentedText nowrap\"><span class=\"IPA nopopups noexcerpt\"><a href=\"/wiki/Help:IPA/English\" title=\"Help:IPA/English\">/<span style=\"border-bottom:1px dotted\"><span>ˌ</span><span>w</span><span>ɪ</span><span>k</span><span>i</span><span>ˈ</span><span>p</span><span>iː</span><span>d</span><span>i</span><span>ə</span></span>/</a></span><span> </span><span class=\"nowrap\" style=\"font-size:85%\">(<span class=\"unicode haudio\"><span class=\"fn\"><span style=\"white-space:nowrap;margin-right:.25em;\"><figure-inline><a href=\"/wiki/File:En-us-Wikipedia.ogg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/11px-Loudspeaker.svg.png\" data-file-width=\"20\" data-file-height=\"20\" data-file-type=\"drawing\" height=\"11\" width=\"11\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/22px-Loudspeaker.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/8/8a/Loudspeaker.svg/17px-Loudspeaker.svg.png 1.5x\"></a></figure-inline></span><a href=\"//upload.wikimedia.org/wikipedia/commons/2/2e/En-us-Wikipedia.ogg\" resource=\"./Media:En-us-Wikipedia.ogg\" title=\"En-us-Wikipedia.ogg\">listen</a></span></span>)</span></span> <a href=\"/wiki/Help:Pronunciation_respelling_key\" title=\"Help:Pronunciation respelling key\"><i title=\"English pronunciation respelling\">wik-ee-<span style=\"font-size:90%\">PEE</span>-dee-ə</i></a>) (<a href=\"/wiki/Abbreviation\" title=\"Abbreviation\">abbreviation</a>: \"<b>WP</b>\") is a multilingual <a href=\"/wiki/Online_encyclopedia\" title=\"Online encyclopedia\">online encyclopedia</a> created and maintained as an <a href=\"/wiki/Open_collaboration\" title=\"Open collaboration\">open collaboration</a> project<span class=\"mw-ref\" id=\"cite_ref-McNeil2011_6-0\"><a href=\"#cite_note-McNeil2011-6\" style=\"counter-reset: mw-Ref 4;\"><span class=\"mw-reflink-text\">[4]</span></a></span> by a <a href=\"/wiki/Wikipedians\" title=\"Wikipedians\" class=\"mw-redirect\">community of volunteer editors</a> using a <a href=\"/wiki/Wiki\" title=\"Wiki\">wiki</a>-based editing system.<span class=\"mw-ref\" id=\"cite_ref-Poe2006_7-0\"><a href=\"#cite_note-Poe2006-7\" style=\"counter-reset: mw-Ref 5;\"><span class=\"mw-reflink-text\">[5]</span></a></span> It is the largest and most popular general reference work on the <a href=\"/wiki/World_Wide_Web\" title=\"World Wide Web\">World Wide Web</a>,<span class=\"mw-ref\" id=\"cite_ref-Tancer_8-0\"><a href=\"#cite_note-Tancer-8\" style=\"counter-reset: mw-Ref 6;\"><span class=\"mw-reflink-text\">[6]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Woodson_9-0\"><a href=\"#cite_note-Woodson-9\" style=\"counter-reset: mw-Ref 7;\"><span class=\"mw-reflink-text\">[7]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-10\"><a href=\"#cite_note-10\" style=\"counter-reset: mw-Ref 8;\"><span class=\"mw-reflink-text\">[8]</span></a></span> and is one of the 20 most popular websites ranked by <a href=\"/wiki/Alexa_Internet\" title=\"Alexa Internet\">Alexa</a>, <span>as of March</span><span>&nbsp;</span><span>2020</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>.<span class=\"mw-ref\" id=\"cite_ref-Alexa_siteinfo_11-0\"><a href=\"#cite_note-Alexa_siteinfo-11\" style=\"counter-reset: mw-Ref 9;\"><span class=\"mw-reflink-text\">[9]</span></a></span> It features exclusively <a href=\"/wiki/Free_content\" title=\"Free content\">free content</a> and no commercial <a href=\"/wiki/Advertising\" title=\"Advertising\">ads</a>, and is owned and supported by the <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a>, a <a href=\"/wiki/501(c)(3)_organization\" title=\"501(c)(3) organization\">non-profit organization</a> funded primarily through <a href=\"/wiki/Donation\" title=\"Donation\">donations</a>.<span class=\"mw-ref\" id=\"cite_ref-12\"><a href=\"#cite_note-12\" style=\"counter-reset: mw-Ref 10;\"><span class=\"mw-reflink-text\">[10]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-13\"><a href=\"#cite_note-13\" style=\"counter-reset: mw-Ref 11;\"><span class=\"mw-reflink-text\">[11]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-14\"><a href=\"#cite_note-14\" style=\"counter-reset: mw-Ref 12;\"><span class=\"mw-reflink-text\">[12]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-15\"><a href=\"#cite_note-15\" style=\"counter-reset: mw-Ref 13;\"><span class=\"mw-reflink-text\">[13]</span></a></span></p>\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1\">This article is about this encyclopedia. For the English edition, see <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia</a>. For Wikipedia's home page, see <a href=\"/wiki/Main_Page\" title=\"Main Page\">Main Page</a>. For Wikipedia's visitor introduction, see <a href=\"/wiki/Wikipedia:About\" title=\"Wikipedia:About\">Wikipedia:About</a>. For other uses, see <a href=\"/wiki/Wikipedia_(disambiguation)\" title=\"Wikipedia (disambiguation)\" class=\"mw-disambig\">Wikipedia (disambiguation)</a>.</div>\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt2\">\"The Free Encyclopedia\" redirects here. For a list of other encyclopedias, see <a href=\"/wiki/Lists_of_encyclopedias\" title=\"Lists of encyclopedias\">Lists of encyclopedias</a>.</div>\n<p>\n\n\n</p>\n<div class=\"shortdescription nomobile noexcerpt noprint searchaux\" style=\"display:none\" about=\"#mwt16\">Free online encyclopedia that anyone can edit</div>\n<table class=\"infobox vcard\" style=\"width:22em\"><caption class=\"fn org\">Wikipedia</caption><tbody><tr><td colspan=\"2\" style=\"text-align:center\"><figure-inline><a href=\"/wiki/File:Wikipedia-v2-logo.svg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/80/Wikipedia-logo-v2.svg/150px-Wikipedia-logo-v2.svg.png\" data-file-width=\"103\" data-file-height=\"94\" data-file-type=\"drawing\" height=\"137\" width=\"150\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/80/Wikipedia-logo-v2.svg/300px-Wikipedia-logo-v2.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/8/80/Wikipedia-logo-v2.svg/225px-Wikipedia-logo-v2.svg.png 1.5x\"></a></figure-inline><br><figure-inline><a href=\"/wiki/File:Wikipedia_wordmark.svg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/bb/Wikipedia_wordmark.svg/200px-Wikipedia_wordmark.svg.png\" data-file-width=\"500\" data-file-height=\"85\" data-file-type=\"drawing\" height=\"34\" width=\"200\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/bb/Wikipedia_wordmark.svg/400px-Wikipedia_wordmark.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/b/bb/Wikipedia_wordmark.svg/300px-Wikipedia_wordmark.svg.png 1.5x\"></a></figure-inline><div>The <a href=\"/wiki/Wikipedia_logo\" title=\"Wikipedia logo\">logo of Wikipedia</a>, a globe featuring <a href=\"/wiki/Glyph\" title=\"Glyph\">glyphs</a> from various <a href=\"/wiki/Writing_system\" title=\"Writing system\">writing systems</a></div></td></tr><tr><td colspan=\"2\" style=\"text-align:center\"><div class=\"mw-collapsible  mw-collapsed \" style=\"box-sizing:border-box;width:100%;font-size:95%;padding:4px;border:none;\"><div style=\"font-size:100%;line-height:1.6;font-weight:bold;background:transparent;text-align:left;;background:gainsboro;text-align:center\">Screenshot</div><div class=\"mw-collapsible-content\" style=\"background:transparent;text-align:left;;text-align:center\">\n<figure-inline class=\"mw-image-border\"><a href=\"/wiki/File:Wikipedia_Main_Page.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/87/Wikipedia_Main_Page.png/300px-Wikipedia_Main_Page.png\" data-file-width=\"1903\" data-file-height=\"3092\" data-file-type=\"bitmap\" height=\"487\" width=\"300\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/87/Wikipedia_Main_Page.png/600px-Wikipedia_Main_Page.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/8/87/Wikipedia_Main_Page.png/450px-Wikipedia_Main_Page.png 1.5x\"></a></figure-inline><div><a href=\"/wiki/Main_Page\" title=\"Main Page\">Main Page</a> of the English Wikipedia on July 23, 2018</div></div></div></td></tr><tr><th scope=\"row\"><div style=\"padding:0.1em 0;line-height:1.2em;\">Type of site</div></th><td><a href=\"/wiki/Online_encyclopedia\" title=\"Online encyclopedia\">Online encyclopedia</a></td></tr><tr><th scope=\"row\">Available<span>&nbsp;</span>in</th><td>285 languages</td></tr><tr><th scope=\"row\">Country of origin</th><td><span class=\"flagicon\"><figure-inline class=\"mw-image-border\"><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/a/a4/Flag_of_the_United_States.svg/23px-Flag_of_the_United_States.svg.png\" data-file-width=\"1235\" data-file-height=\"650\" data-file-type=\"drawing\" height=\"12\" width=\"23\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/a/a4/Flag_of_the_United_States.svg/46px-Flag_of_the_United_States.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/a/a4/Flag_of_the_United_States.svg/35px-Flag_of_the_United_States.svg.png 1.5x\"></span></figure-inline><span>&nbsp;</span></span>United States</td></tr><tr><th scope=\"row\">Owner</th><td><a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a></td></tr><tr><th scope=\"row\">Created<span>&nbsp;</span>by</th><td><a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a><br><a href=\"/wiki/Larry_Sanger\" title=\"Larry Sanger\">Larry Sanger</a><span class=\"mw-ref\" id=\"cite_ref-Sidener_1-0\"><a href=\"#cite_note-Sidener-1\" style=\"counter-reset: mw-Ref 1;\"><span class=\"mw-reflink-text\">[1]</span></a></span></td></tr><tr><th scope=\"row\">URL</th><td class=\"url\"><span class=\"url\"><a rel=\"mw:ExtLink\" href=\"https://www.wikipedia.org/\" class=\"external text\">www<wbr>.wikipedia<wbr>.org</a></span> <figure-inline class=\"mw-valign-text-top\"><a href=\"https://www.wikidata.org/wiki/Q52#P856\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/10px-OOjs_UI_icon_edit-ltr-progressive.svg.png\" data-file-width=\"20\" data-file-height=\"20\" data-file-type=\"drawing\" height=\"10\" width=\"10\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/20px-OOjs_UI_icon_edit-ltr-progressive.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/15px-OOjs_UI_icon_edit-ltr-progressive.svg.png 1.5x\"></a></figure-inline></td></tr><tr><th scope=\"row\"><a href=\"/wiki/Alexa_Internet\" title=\"Alexa Internet\">Alexa</a> rank</th><td><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Decrease2.svg/11px-Decrease2.svg.png\" data-file-width=\"300\" data-file-height=\"300\" data-file-type=\"drawing\" height=\"11\" width=\"11\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Decrease2.svg/22px-Decrease2.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/e/ed/Decrease2.svg/17px-Decrease2.svg.png 1.5x\"></span></figure-inline> 13 <span class=\"nowrap\">(Global, February 2020<sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>)</span><span class=\"mw-ref\" id=\"cite_ref-alexasiteinfo_2-0\"><a href=\"#cite_note-alexasiteinfo-2\" style=\"counter-reset: mw-Ref 2;\"><span class=\"mw-reflink-text\">[2]</span></a></span></td></tr><tr><th scope=\"row\">Commercial</th><td>No</td></tr><tr><th scope=\"row\">Registration</th><td>Optional<span class=\"mw-ref\" id=\"cite_ref-3\"><a href=\"#cite_note-3\" style=\"counter-reset: mw-Ref 1;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 1]</span></a></span></td></tr><tr><th scope=\"row\"><a href=\"/wiki/Registered_user\" title=\"Registered user\">Users</a></th><td><a href=\"/wiki/List_of_Wikipedias#Grand_total\" title=\"List of Wikipedias\">&gt;317,203</a> active users<span class=\"mw-ref\" id=\"cite_ref-4\"><a href=\"#cite_note-4\" style=\"counter-reset: mw-Ref 2;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 2]</span></a></span> and <a href=\"/wiki/List_of_Wikipedias#Grand_total\" title=\"List of Wikipedias\">&gt;88,475,803</a> registered users<br>1,145 administrators (<a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English</a>)</td></tr><tr><th scope=\"row\">Launched</th><td>January<span>&nbsp;</span>15, 2001<span class=\"noprint\"><span>;</span><span> </span>19 years ago</span><span style=\"display:none\"><span>&nbsp;</span>(<span class=\"bday dtstart published updated\">2001-01-15</span>)</span></td></tr><tr><th scope=\"row\">Current<span>&nbsp;</span>status</th><td class=\"category\">Active</td></tr><tr><th scope=\"row\"><div style=\"padding:0.1em 0;line-height:1.2em;\">Content license</div></th><td><span class=\"nowrap\"><a href=\"/wiki/Creative_Commons_licenses\" title=\"Creative Commons licenses\" class=\"mw-redirect\">CC Attribution / Share-Alike</a> 3.0</span><br>Most text is also dual-licensed under <a href=\"/wiki/GFDL\" title=\"GFDL\" class=\"mw-redirect\">GFDL</a>; media licensing varies</td></tr><tr><th scope=\"row\">Written<span>&nbsp;</span>in</th><td><a href=\"/wiki/LAMP_(software_bundle)\" title=\"LAMP (software bundle)\">LAMP</a> platform<span class=\"mw-ref\" id=\"cite_ref-roadchap_5-0\"><a href=\"#cite_note-roadchap-5\" style=\"counter-reset: mw-Ref 3;\"><span class=\"mw-reflink-text\">[3]</span></a></span></td></tr><tr><th scope=\"row\"><a href=\"/wiki/OCLC\" title=\"OCLC\">OCLC</a><span>&nbsp;</span>number</th><td><a rel=\"mw:ExtLink\" href=\"https://www.worldcat.org/oclc/52075003\" class=\"external text\">52075003 </a></td></tr></tbody></table>\n\n<p>Wikipedia was launched on January 15, 2001, by <a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a> and <a href=\"/wiki/Larry_Sanger\" title=\"Larry Sanger\">Larry Sanger</a>.<span class=\"mw-ref\" id=\"cite_ref-16\"><a href=\"#cite_note-16\" style=\"counter-reset: mw-Ref 14;\"><span class=\"mw-reflink-text\">[14]</span></a></span> Sanger coined its name,<span class=\"mw-ref\" id=\"cite_ref-MiliardWho_17-0\"><a href=\"#cite_note-MiliardWho-17\" style=\"counter-reset: mw-Ref 15;\"><span class=\"mw-reflink-text\">[15]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-J_Sidener_18-0\"><a href=\"#cite_note-J_Sidener-18\" style=\"counter-reset: mw-Ref 16;\"><span class=\"mw-reflink-text\">[16]</span></a></span> as a <a href=\"/wiki/Portmanteau\" title=\"Portmanteau\">blend</a> of \"<a href=\"https://en.wiktionary.org/wiki/wiki#Hawaiian\" title=\"wikt:wiki\">wiki</a>\" (the <a href=\"/wiki/Hawaiian_language\" title=\"Hawaiian language\">Hawaiian</a> word for \"quick\")<span class=\"mw-ref\" id=\"cite_ref-19\"><a href=\"#cite_note-19\" style=\"counter-reset: mw-Ref 17;\"><span class=\"mw-reflink-text\">[17]</span></a></span> and \"encyclopedia\". Initially an English-language encyclopedia, versions of Wikipedia in other languages were quickly developed. With <a href=\"/wiki/Special:Statistics\" title=\"Special:Statistics\"><span>6.1</span><span class=\"nowrap\"><span>&nbsp;</span></span>million articles</a>, the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia</a> is the largest of the more than 300 Wikipedia encyclopedias. Overall, Wikipedia comprises more than <span>52</span><span class=\"nowrap\"><span>&nbsp;</span></span>million articles<span class=\"mw-ref\" id=\"cite_ref-CBS_20-0\"><a href=\"#cite_note-CBS-20\" style=\"counter-reset: mw-Ref 18;\"><span class=\"mw-reflink-text\">[18]</span></a></span> attracting 1.5<span class=\"nowrap\"><span>&nbsp;</span></span>billion unique visitors per month.<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-0\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Wikimedia_Stats_22-0\"><a href=\"#cite_note-Wikimedia_Stats-22\" style=\"counter-reset: mw-Ref 20;\"><span class=\"mw-reflink-text\">[20]</span></a></span></p>\n\n<p>In 2005, <i><a href=\"/wiki/Nature_(journal)\" title=\"Nature (journal)\">Nature</a></i> published a peer review comparing 42 <a href=\"/wiki/Hard_science\" title=\"Hard science\" class=\"mw-redirect\">hard science</a> articles from <i><a href=\"/wiki/Encyclopædia_Britannica\" title=\"Encyclopædia Britannica\">Encyclopædia Britannica</a></i> and Wikipedia and found that Wikipedia's level of accuracy approached that of <i>Britannica</i>,<span class=\"mw-ref\" id=\"cite_ref-GilesJ2005Internet_23-0\"><a href=\"#cite_note-GilesJ2005Internet-23\" style=\"counter-reset: mw-Ref 21;\"><span class=\"mw-reflink-text\">[21]</span></a></span> although critics suggested that it might not have fared so well in a similar study of a <a href=\"/wiki/Random_sampling\" title=\"Random sampling\" class=\"mw-redirect\">random sampling</a> of all articles or one focused on social science or contentious social issues.<span class=\"mw-ref\" id=\"cite_ref-Reagle,_pp._165–166_24-0\"><a href=\"#cite_note-Reagle,_pp._165–166-24\" style=\"counter-reset: mw-Ref 22;\"><span class=\"mw-reflink-text\">[22]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Orlowski2005_25-0\"><a href=\"#cite_note-Orlowski2005-25\" style=\"counter-reset: mw-Ref 23;\"><span class=\"mw-reflink-text\">[23]</span></a></span> The following year, <i><a href=\"/wiki/Time_(magazine)\" title=\"Time (magazine)\">Time</a></i> magazine stated that the open-door policy of allowing anyone to edit had made Wikipedia the biggest and possibly the best encyclopedia in the world, and was a testament to the vision of Jimmy Wales.<span class=\"mw-ref\" id=\"cite_ref-26\"><a href=\"#cite_note-26\" style=\"counter-reset: mw-Ref 24;\"><span class=\"mw-reflink-text\">[24]</span></a></span></p>\n\n<p>Wikipedia <a href=\"/wiki/Criticism_of_Wikipedia\" title=\"Criticism of Wikipedia\">has been criticized</a> for exhibiting <a href=\"/wiki/Systemic_bias\" title=\"Systemic bias\">systemic bias</a>, for presenting a mixture of \"truth, half truth, and some falsehoods\",<span class=\"mw-ref\" id=\"cite_ref-EdwinBlack_27-0\"><a href=\"#cite_note-EdwinBlack-27\" style=\"counter-reset: mw-Ref 25;\"><span class=\"mw-reflink-text\">[25]</span></a></span> and for being subject to manipulation and <a href=\"/wiki/Spin_(propaganda)\" title=\"Spin (propaganda)\">spin</a> in controversial topics.<span class=\"mw-ref\" id=\"cite_ref-Petrilli_28-0\"><a href=\"#cite_note-Petrilli-28\" style=\"counter-reset: mw-Ref 26;\"><span class=\"mw-reflink-text\">[26]</span></a></span> <a href=\"/wiki/Gender_bias_on_Wikipedia\" title=\"Gender bias on Wikipedia\">Wikipedia has also been criticized for gender bias</a>, particularly on its English-language site, where the dominant majority of editors are male. However, <a href=\"/wiki/Edit-a-thon\" title=\"Edit-a-thon\">Edit-a-thons</a> have been held to encourage female editors and increase the coverage of women's topics.<span class=\"mw-ref\" id=\"cite_ref-tnw_29-0\"><a href=\"#cite_note-tnw-29\" style=\"counter-reset: mw-Ref 27;\"><span class=\"mw-reflink-text\">[27]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-indy500_30-0\"><a href=\"#cite_note-indy500-30\" style=\"counter-reset: mw-Ref 28;\"><span class=\"mw-reflink-text\">[28]</span></a></span> <a href=\"/wiki/Facebook\" title=\"Facebook\">Facebook</a> announced that by 2017 it would help readers detect <a href=\"/wiki/Fake_news\" title=\"Fake news\">fake news</a> by suggesting links to related Wikipedia articles. <a href=\"/wiki/YouTube\" title=\"YouTube\">YouTube</a> announced a similar plan in 2018.<span class=\"mw-ref\" id=\"cite_ref-auto_31-0\"><a href=\"#cite_note-auto-31\" style=\"counter-reset: mw-Ref 29;\"><span class=\"mw-reflink-text\">[29]</span></a></span></p>\n<style data-mw-deduplicate=\"TemplateStyles:r886046785\" typeof=\"mw:Extension/templatestyles mw:Transclusion\">.mw-parser-output .toclimit-2 .toclevel-1 ul,.mw-parser-output .toclimit-3 .toclevel-2 ul,.mw-parser-output .toclimit-4 .toclevel-3 ul,.mw-parser-output .toclimit-5 .toclevel-4 ul,.mw-parser-output .toclimit-6 .toclevel-5 ul,.mw-parser-output .toclimit-7 .toclevel-6 ul{display:none}</style><div class=\"toclimit-3\" about=\"#mwt204\"><meta property=\"mw:PageProp/toc\"></div>\n\n"},{"id":1,"toclevel":1,"anchor":"History","line":"History"},{"id":2,"toclevel":2,"anchor":"Nupedia","line":"Nupedia"},{"id":3,"toclevel":2,"anchor":"Launch_and_early_growth","line":"Launch and early growth"},{"id":4,"toclevel":2,"anchor":"Milestones","line":"Milestones"},{"id":5,"toclevel":1,"anchor":"Openness","line":"Openness"},{"id":6,"toclevel":2,"anchor":"Restrictions","line":"Restrictions"},{"id":7,"toclevel":2,"anchor":"Review_of_changes","line":"Review of changes"},{"id":8,"toclevel":2,"anchor":"Vandalism","line":"Vandalism"},{"id":9,"toclevel":2,"anchor":"Edit_warring","line":"Edit warring"},{"id":10,"toclevel":1,"anchor":"Policies_and_laws","line":"<span id=\"Rules_and_laws_governing_content\">Policies and laws</span>"},{"id":11,"toclevel":2,"anchor":"Content_policies_and_guidelines","line":"Content policies and guidelines"},{"id":12,"toclevel":1,"anchor":"Governance","line":"Governance"},{"id":13,"toclevel":2,"anchor":"Administrators","line":"Administrators"},{"id":14,"toclevel":2,"anchor":"Dispute_resolution","line":"Dispute resolution"},{"id":15,"toclevel":3,"anchor":"Arbitration_Committee","line":"Arbitration Committee"},{"id":16,"toclevel":1,"anchor":"Community","line":"Community"},{"id":17,"toclevel":2,"anchor":"Studies","line":"Studies"},{"id":18,"toclevel":2,"anchor":"Diversity","line":"Diversity"},{"id":19,"toclevel":1,"anchor":"Language_editions","line":"Language editions"},{"id":20,"toclevel":2,"anchor":"English_Wikipedia_editor_decline","line":"English Wikipedia editor decline"},{"id":21,"toclevel":1,"anchor":"Reception","line":"Reception"},{"id":22,"toclevel":2,"anchor":"Accuracy_of_content","line":"Accuracy of content"},{"id":23,"toclevel":2,"anchor":"Discouragement_in_education","line":"Discouragement in education"},{"id":24,"toclevel":3,"anchor":"Medical_information","line":"Medical information"},{"id":25,"toclevel":2,"anchor":"Quality_of_writing","line":"Quality of writing"},{"id":26,"toclevel":2,"anchor":"Coverage_of_topics_and_systemic_bias","line":"Coverage of topics and systemic bias"},{"id":27,"toclevel":3,"anchor":"Coverage_of_topics_and_selection_bias","line":"Coverage of topics and selection bias"},{"id":28,"toclevel":3,"anchor":"Systemic_bias","line":"Systemic bias"},{"id":29,"toclevel":2,"anchor":"Explicit_content","line":"Explicit content"},{"id":30,"toclevel":2,"anchor":"Privacy","line":"Privacy"},{"id":31,"toclevel":2,"anchor":"Sexism","line":"Sexism"},{"id":32,"toclevel":1,"anchor":"Operation","line":"Operation"},{"id":33,"toclevel":2,"anchor":"Wikimedia_Foundation_and_Wikimedia_movement_affiliates","line":"Wikimedia Foundation and Wikimedia movement affiliates"},{"id":34,"toclevel":2,"anchor":"Software_operations_and_support","line":"Software operations and support"},{"id":35,"toclevel":2,"anchor":"Automated_editing","line":"Automated editing"},{"id":36,"toclevel":2,"anchor":"Hardware_operations_and_support","line":"Hardware operations and support"},{"id":37,"toclevel":2,"anchor":"Internal_research_and_operational_development","line":"Internal research and operational development"},{"id":38,"toclevel":2,"anchor":"Internal_news_publications","line":"Internal news publications"},{"id":39,"toclevel":1,"anchor":"Access_to_content","line":"Access to content"},{"id":40,"toclevel":2,"anchor":"Content_licensing","line":"Content licensing"},{"id":41,"toclevel":2,"anchor":"Methods_of_access","line":"Methods of access"},{"id":42,"toclevel":3,"anchor":"Mobile_access","line":"Mobile access"},{"id":43,"toclevel":1,"anchor":"Cultural_impact","line":"Cultural impact"},{"id":44,"toclevel":2,"anchor":"Trusted_source_to_combat_fake_news","line":"Trusted source to combat fake news"},{"id":45,"toclevel":2,"anchor":"Readership","line":"Readership"},{"id":46,"toclevel":2,"anchor":"Cultural_significance","line":"Cultural significance"},{"id":47,"toclevel":3,"anchor":"Awards","line":"Awards"},{"id":48,"toclevel":3,"anchor":"Satire","line":"Satire"},{"id":49,"toclevel":2,"anchor":"Sister_projects—Wikimedia","line":"Sister projects—Wikimedia"},{"id":50,"toclevel":2,"anchor":"Publishing","line":"Publishing"},{"id":51,"toclevel":2,"anchor":"Research_use","line":"Research use"},{"id":52,"toclevel":1,"anchor":"Related_projects","line":"Related projects"},{"id":53,"toclevel":1,"anchor":"See_also","line":"See also"},{"id":54,"toclevel":1,"anchor":"Notes","line":"Notes"},{"id":55,"toclevel":1,"anchor":"References","line":"References"},{"id":56,"toclevel":1,"anchor":"Further_reading","line":"Further reading"},{"id":57,"toclevel":2,"anchor":"Academic_studies","line":"Academic studies"},{"id":58,"toclevel":2,"anchor":"Books","line":"Books"},{"id":59,"toclevel":2,"anchor":"Book_review-related_articles","line":"Book review-related articles"},{"id":60,"toclevel":2,"anchor":"Learning_resources","line":"Learning resources"},{"id":61,"toclevel":2,"anchor":"Other_media_coverage","line":"Other media coverage"},{"id":62,"toclevel":3,"anchor":"General_articles","line":"General articles"},{"id":63,"toclevel":3,"anchor":"Articles_re_Wikipedia_usage_patterns","line":"Articles re Wikipedia usage patterns"},{"id":64,"toclevel":1,"anchor":"External_links","line":"External links"}]},"remaining":{"sections":[{"id":1,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt208\">Main article: <a href=\"/wiki/History_of_Wikipedia\" title=\"History of Wikipedia\">History of Wikipedia</a></div>\n<style data-mw-deduplicate=\"TemplateStyles:r923042769/mw-parser-output/.tmulti\" typeof=\"mw:Extension/templatestyles mw:Transclusion\">.mw-parser-output .tmulti .thumbinner{display:flex;flex-direction:column}.mw-parser-output .tmulti .trow{display:flex;flex-direction:row;clear:left;flex-wrap:wrap;width:100%;box-sizing:border-box}.mw-parser-output .tmulti .tsingle{margin:1px;float:left}.mw-parser-output .tmulti .theader{clear:both;font-weight:bold;text-align:center;align-self:center;background-color:transparent;width:100%}.mw-parser-output .tmulti .thumbcaption{text-align:left;background-color:transparent}.mw-parser-output .tmulti .thumbcaption-center{text-align:center;background-color:transparent}.mw-parser-output .tmulti .text-align-left{text-align:left}.mw-parser-output .tmulti .text-align-right{text-align:right}.mw-parser-output .tmulti .text-align-center{text-align:center}@media all and (max-width:720px){.mw-parser-output .tmulti .thumbinner{width:100%!important;box-sizing:border-box;max-width:none!important;align-items:center}.mw-parser-output .tmulti .trow{justify-content:center}.mw-parser-output .tmulti .tsingle{float:none!important;max-width:100%!important;box-sizing:border-box;text-align:center}.mw-parser-output .tmulti .thumbcaption{text-align:center}}</style><div class=\"thumb tmulti tright\" about=\"#mwt209\"><div class=\"thumbinner\" style=\"width:224px;max-width:224px\"><div class=\"trow\"><div class=\"tsingle\" style=\"width:102px;max-width:102px\"><div class=\"thumbimage\"><figure-inline><a href=\"/wiki/File:Jimmy_Wales_September_2015.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/65/Jimmy_Wales_September_2015.jpg/100px-Jimmy_Wales_September_2015.jpg\" data-file-width=\"2088\" data-file-height=\"2962\" data-file-type=\"bitmap\" height=\"142\" width=\"100\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/65/Jimmy_Wales_September_2015.jpg/200px-Jimmy_Wales_September_2015.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/6/65/Jimmy_Wales_September_2015.jpg/150px-Jimmy_Wales_September_2015.jpg 1.5x\"></a></figure-inline></div></div><div class=\"tsingle\" style=\"width:118px;max-width:118px\"><div class=\"thumbimage\"><figure-inline><a href=\"/wiki/File:L_Sanger.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a5/L_Sanger.jpg/116px-L_Sanger.jpg\" data-file-width=\"1209\" data-file-height=\"1490\" data-file-type=\"bitmap\" height=\"143\" width=\"116\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a5/L_Sanger.jpg/232px-L_Sanger.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/a/a5/L_Sanger.jpg/174px-L_Sanger.jpg 1.5x\"></a></figure-inline></div></div></div><div class=\"trow\"><div class=\"thumbcaption\" style=\"background-color:transparent\">Jimmy Wales and Larry Sanger</div></div></div></div>\n\n","toclevel":1,"line":"History","anchor":"History"},{"id":2,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt213\">Main article: <a href=\"/wiki/Nupedia\" title=\"Nupedia\">Nupedia</a></div>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Nupedia_logo_and_wordmark.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a4/Nupedia_logo_and_wordmark.png/220px-Nupedia_logo_and_wordmark.png\" data-file-width=\"500\" data-file-height=\"117\" data-file-type=\"bitmap\" height=\"51\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a4/Nupedia_logo_and_wordmark.png/440px-Nupedia_logo_and_wordmark.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/a/a4/Nupedia_logo_and_wordmark.png/330px-Nupedia_logo_and_wordmark.png 1.5x\"></a><figcaption>Wikipedia originally developed from another encyclopedia project called Nupedia</figcaption></figure>\n\n<p>Other collaborative online encyclopedias were attempted before Wikipedia, but none were as successful.<span class=\"mw-ref\" id=\"cite_ref-32\"><a href=\"#cite_note-32\" style=\"counter-reset: mw-Ref 30;\"><span class=\"mw-reflink-text\">[30]</span></a></span> Wikipedia began as a complementary project for <a href=\"/wiki/Nupedia\" title=\"Nupedia\">Nupedia</a>, a free online English-language encyclopedia project whose articles were written by experts and reviewed under a formal process.<span class=\"mw-ref\" id=\"cite_ref-KockJungSyn2016_33-0\"><a href=\"#cite_note-KockJungSyn2016-33\" style=\"counter-reset: mw-Ref 31;\"><span class=\"mw-reflink-text\">[31]</span></a></span> It was founded on March 9, 2000, under the ownership of <a href=\"/wiki/Bomis\" title=\"Bomis\">Bomis</a>, a <a href=\"/wiki/Web_portal\" title=\"Web portal\">web portal</a> company. Its main figures were Bomis CEO <a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a> and <a href=\"/wiki/Larry_Sanger\" title=\"Larry Sanger\">Larry Sanger</a>, editor-in-chief for Nupedia and later Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-autogenerated1_34-0\"><a href=\"#cite_note-autogenerated1-34\" style=\"counter-reset: mw-Ref 32;\"><span class=\"mw-reflink-text\">[32]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Meyers_35-0\"><a href=\"#cite_note-Meyers-35\" style=\"counter-reset: mw-Ref 33;\"><span class=\"mw-reflink-text\">[33]</span></a></span> Nupedia was initially licensed under its own Nupedia <a href=\"/wiki/Open_Content\" title=\"Open Content\" class=\"mw-redirect\">Open Content</a> License, but even before Wikipedia was founded, Nupedia switched to the <a href=\"/wiki/GNU_Free_Documentation_License\" title=\"GNU Free Documentation License\">GNU Free Documentation License</a> at the urging of <a href=\"/wiki/Richard_Stallman\" title=\"Richard Stallman\">Richard Stallman</a>.<span class=\"mw-ref\" id=\"cite_ref-stallman1999_36-0\"><a href=\"#cite_note-stallman1999-36\" style=\"counter-reset: mw-Ref 34;\"><span class=\"mw-reflink-text\">[34]</span></a></span> Wales is credited with defining the goal of making a publicly editable encyclopedia,<span class=\"mw-ref\" id=\"cite_ref-SangerMemoir_37-0\"><a href=\"#cite_note-SangerMemoir-37\" style=\"counter-reset: mw-Ref 35;\"><span class=\"mw-reflink-text\">[35]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Sanger_38-0\"><a href=\"#cite_note-Sanger-38\" style=\"counter-reset: mw-Ref 36;\"><span class=\"mw-reflink-text\">[36]</span></a></span> while Sanger is credited with the strategy of using a <a href=\"/wiki/Wiki\" title=\"Wiki\">wiki</a> to reach that goal.<span class=\"mw-ref\" id=\"cite_ref-WM_foundation_of_WP_1_39-0\"><a href=\"#cite_note-WM_foundation_of_WP_1-39\" style=\"counter-reset: mw-Ref 37;\"><span class=\"mw-reflink-text\">[37]</span></a></span> On January 10, 2001, Sanger proposed on the Nupedia mailing list to create a wiki as a \"feeder\" project for Nupedia.<span class=\"mw-ref\" id=\"cite_ref-nupedia_feeder_from_WP_1_40-0\"><a href=\"#cite_note-nupedia_feeder_from_WP_1-40\" style=\"counter-reset: mw-Ref 38;\"><span class=\"mw-reflink-text\">[38]</span></a></span></p>\n\n","toclevel":2,"line":"Nupedia","anchor":"Nupedia"},{"id":3,"text":"\n\n<p>The <a href=\"/wiki/Domain_name\" title=\"Domain name\">domains</a> <i>wikipedia.com</i> and <i>wikipedia.org</i> were registered on January 12, 2001<span class=\"mw-ref\" id=\"cite_ref-41\"><a href=\"#cite_note-41\" style=\"counter-reset: mw-Ref 39;\"><span class=\"mw-reflink-text\">[39]</span></a></span> and January 13, 2001<span class=\"mw-ref\" id=\"cite_ref-42\"><a href=\"#cite_note-42\" style=\"counter-reset: mw-Ref 40;\"><span class=\"mw-reflink-text\">[40]</span></a></span> respectively, and Wikipedia was launched on January 15, 2001,<span class=\"mw-ref\" id=\"cite_ref-KockJungSyn2016_33-1\"><a href=\"#cite_note-KockJungSyn2016-33\" style=\"counter-reset: mw-Ref 31;\"><span class=\"mw-reflink-text\">[31]</span></a></span> as a single English-language edition at www.wikipedia.com,<span class=\"mw-ref\" id=\"cite_ref-WikipediaHome_43-0\"><a href=\"#cite_note-WikipediaHome-43\" style=\"counter-reset: mw-Ref 41;\"><span class=\"mw-reflink-text\">[41]</span></a></span> and announced by Sanger on the Nupedia mailing list.<span class=\"mw-ref\" id=\"cite_ref-SangerMemoir_37-1\"><a href=\"#cite_note-SangerMemoir-37\" style=\"counter-reset: mw-Ref 35;\"><span class=\"mw-reflink-text\">[35]</span></a></span> Wikipedia's policy of \"neutral point-of-view\"<span class=\"mw-ref\" id=\"cite_ref-NPOV_44-0\"><a href=\"#cite_note-NPOV-44\" style=\"counter-reset: mw-Ref 42;\"><span class=\"mw-reflink-text\">[42]</span></a></span> was codified in its first few months. Otherwise, there were relatively few rules initially and Wikipedia operated independently of Nupedia.<span class=\"mw-ref\" id=\"cite_ref-SangerMemoir_37-2\"><a href=\"#cite_note-SangerMemoir-37\" style=\"counter-reset: mw-Ref 35;\"><span class=\"mw-reflink-text\">[35]</span></a></span> Originally, Bomis intended to make Wikipedia a business for profit.<span class=\"mw-ref\" id=\"cite_ref-Seth-Finkelstein_45-0\"><a href=\"#cite_note-Seth-Finkelstein-45\" style=\"counter-reset: mw-Ref 43;\"><span class=\"mw-reflink-text\">[43]</span></a></span></p>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:English_Wikipedia_main_page_20011217.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/c/c4/English_Wikipedia_main_page_20011217.jpg/220px-English_Wikipedia_main_page_20011217.jpg\" data-file-width=\"554\" data-file-height=\"600\" data-file-type=\"bitmap\" height=\"238\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/c/c4/English_Wikipedia_main_page_20011217.jpg/440px-English_Wikipedia_main_page_20011217.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/c/c4/English_Wikipedia_main_page_20011217.jpg/330px-English_Wikipedia_main_page_20011217.jpg 1.5x\"></a><figcaption>The Wikipedia Page on December 17, 2001</figcaption></figure>\n\n<p>Wikipedia gained early contributors from Nupedia, <a href=\"/wiki/Slashdot\" title=\"Slashdot\">Slashdot</a> postings, and <a href=\"/wiki/Web_search_engine\" title=\"Web search engine\">web search engine</a> indexing. Language editions were also created, with a total of 161 by the end of 2004.<span class=\"mw-ref\" id=\"cite_ref-WP_early_language_stats_1_46-0\"><a href=\"#cite_note-WP_early_language_stats_1-46\" style=\"counter-reset: mw-Ref 44;\"><span class=\"mw-reflink-text\">[44]</span></a></span> Nupedia and Wikipedia coexisted until the former's servers were taken down permanently in 2003, and its text was incorporated into Wikipedia. The English Wikipedia passed the mark of two million articles on September 9, 2007, making it the largest encyclopedia ever assembled, surpassing the 1408 <i><a href=\"/wiki/Yongle_Encyclopedia\" title=\"Yongle Encyclopedia\">Yongle Encyclopedia</a></i>, which had held the record for almost 600<span>&nbsp;</span>years.<span class=\"mw-ref\" id=\"cite_ref-EB_encyclopedia_47-0\"><a href=\"#cite_note-EB_encyclopedia-47\" style=\"counter-reset: mw-Ref 45;\"><span class=\"mw-reflink-text\">[45]</span></a></span></p>\n\n<p>Citing fears of <a href=\"/wiki/Paid_advertisement\" title=\"Paid advertisement\" class=\"mw-redirect\">commercial advertising</a> and lack of control in <a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Wikipedia</a>, users of the <a href=\"/wiki/Spanish_Wikipedia\" title=\"Spanish Wikipedia\">Spanish Wikipedia</a> <a href=\"/wiki/Fork_(software_development)\" title=\"Fork (software development)\">forked</a> from Wikipedia to create the <a href=\"/wiki/Enciclopedia_Libre_Universal_en_Español\" title=\"Enciclopedia Libre Universal en Español\">Enciclopedia Libre</a> in February 2002.<span class=\"mw-ref\" id=\"cite_ref-EL_fears_and_start_1_48-0\"><a href=\"#cite_note-EL_fears_and_start_1-48\" style=\"counter-reset: mw-Ref 46;\"><span class=\"mw-reflink-text\">[46]</span></a></span> These moves encouraged Wales to announce that Wikipedia would not display advertisements, and to change Wikipedia's domain from <i>wikipedia.com</i> to <i>wikipedia.org</i>.<span class=\"mw-ref\" id=\"cite_ref-Shirky_49-0\"><a href=\"#cite_note-Shirky-49\" style=\"counter-reset: mw-Ref 47;\"><span class=\"mw-reflink-text\">[47]</span></a></span> <a href=\"/wiki/Brion_Vibber\" title=\"Brion Vibber\" class=\"mw-redirect\">Brion Vibber</a> applied the change on August 15, 2002.<span class=\"mw-ref\" id=\"cite_ref-50\"><a href=\"#cite_note-50\" style=\"counter-reset: mw-Ref 48;\"><span class=\"mw-reflink-text\">[48]</span></a></span></p>\n\n<p>Though the English Wikipedia reached three million articles in August 2009, the growth of the edition, in terms of the numbers of new articles and of contributors, appears to have peaked around early 2007.<span class=\"mw-ref\" id=\"cite_ref-guardian_WP_user_peak_1_51-0\"><a href=\"#cite_note-guardian_WP_user_peak_1-51\" style=\"counter-reset: mw-Ref 49;\"><span class=\"mw-reflink-text\">[49]</span></a></span> Around 1,800 articles were added daily to the encyclopedia in 2006; by 2013 that average was roughly 800.<span class=\"mw-ref\" id=\"cite_ref-WP_growth_modelling_1_52-0\"><a href=\"#cite_note-WP_growth_modelling_1-52\" style=\"counter-reset: mw-Ref 50;\"><span class=\"mw-reflink-text\">[50]</span></a></span> A team at the <a href=\"/wiki/Palo_Alto_Research_Center\" title=\"Palo Alto Research Center\" class=\"mw-redirect\">Palo Alto Research Center</a> attributed this slowing of growth to the project's increasing exclusivity and resistance to change.<span class=\"mw-ref\" id=\"cite_ref-wikisym_slowing_growth_1_53-0\"><a href=\"#cite_note-wikisym_slowing_growth_1-53\" style=\"counter-reset: mw-Ref 51;\"><span class=\"mw-reflink-text\">[51]</span></a></span> Others suggest that the growth is flattening naturally because articles that could be called \"<a href=\"https://en.wiktionary.org/wiki/low-hanging%20fruit\" title=\"wikt:low-hanging fruit\">low-hanging fruit</a>\"—topics that clearly merit an article—have already been created and built up extensively.<span class=\"mw-ref\" id=\"cite_ref-bostonreview_the_end_of_WP_1_54-0\"><a href=\"#cite_note-bostonreview_the_end_of_WP_1-54\" style=\"counter-reset: mw-Ref 52;\"><span class=\"mw-reflink-text\">[52]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-55\"><a href=\"#cite_note-55\" style=\"counter-reset: mw-Ref 53;\"><span class=\"mw-reflink-text\">[53]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-stanford_WP_lack_of_future_growth_1_56-0\"><a href=\"#cite_note-stanford_WP_lack_of_future_growth_1-56\" style=\"counter-reset: mw-Ref 54;\"><span class=\"mw-reflink-text\">[54]</span></a></span>\n</p>\n<figure class=\"mw-default-size mw-halign-right\"><span><a href=\"/wiki/File:Wikipedia_Edit_2014.webm\" class=\"app_media\"><video poster=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4d/Wikipedia_Edit_2014.webm/220px--Wikipedia_Edit_2014.webm.jpg\" preload=\"none\" height=\"124\" width=\"220\" resource=\"./File:Wikipedia_Edit_2014.webm\"><source src=\"//upload.wikimedia.org/wikipedia/commons/4/4d/Wikipedia_Edit_2014.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-file-width=\"1920\" data-file-height=\"1080\" data-title=\"Original WebM file, 1,920 × 1,080 (4.45 Mbps)\" data-shorttitle=\"WebM source\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.120p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"214\" data-height=\"120\" data-title=\"Lowest bandwidth VP9 (120P)\" data-shorttitle=\"VP9 120P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.160p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"284\" data-height=\"160\" data-title=\"Low bandwidth WebM (160P)\" data-shorttitle=\"WebM 160P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.180p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"320\" data-height=\"180\" data-title=\"Low bandwidth VP9 (180P)\" data-shorttitle=\"VP9 180P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.240p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"426\" data-height=\"240\" data-title=\"Small VP9 (240P)\" data-shorttitle=\"VP9 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.240p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"426\" data-height=\"240\" data-title=\"Small WebM (240P)\" data-shorttitle=\"WebM 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.360p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"640\" data-height=\"360\" data-title=\"VP9 (360P)\" data-shorttitle=\"VP9 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.360p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"640\" data-height=\"360\" data-title=\"WebM (360P)\" data-shorttitle=\"WebM 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.480p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"854\" data-height=\"480\" data-title=\"SD VP9 (480P)\" data-shorttitle=\"VP9 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.480p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"854\" data-height=\"480\" data-title=\"SD WebM (480P)\" data-shorttitle=\"WebM 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.720p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1280\" data-height=\"720\" data-title=\"HD VP9 (720P)\" data-shorttitle=\"VP9 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.720p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1280\" data-height=\"720\" data-title=\"HD WebM (720P)\" data-shorttitle=\"WebM 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.1080p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1920\" data-height=\"1080\" data-title=\"Full HD VP9 (1080P)\" data-shorttitle=\"VP9 1080P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/4/4d/Wikipedia_Edit_2014.webm/Wikipedia_Edit_2014.webm.1080p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1920\" data-height=\"1080\" data-title=\"Full HD WebM (1080P)\" data-shorttitle=\"WebM 1080P\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ar&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ar\" label=\"العربية (ar) subtitles\" data-mwtitle=\"\" data-dir=\"rtl\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=bn&amp;trackformat=srt&amp;origin=%2A\" srclang=\"bn\" label=\"বাংলা (bn) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ca&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ca\" label=\"català (ca) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=cs&amp;trackformat=srt&amp;origin=%2A\" srclang=\"cs\" label=\"čeština (cs) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=de&amp;trackformat=srt&amp;origin=%2A\" srclang=\"de\" label=\"Deutsch (de) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=en&amp;trackformat=srt&amp;origin=%2A\" srclang=\"en\" label=\"English (en) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=eo&amp;trackformat=srt&amp;origin=%2A\" srclang=\"eo\" label=\"Esperanto (eo) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=es&amp;trackformat=srt&amp;origin=%2A\" srclang=\"es\" label=\"español (es) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=fr&amp;trackformat=srt&amp;origin=%2A\" srclang=\"fr\" label=\"français (fr) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=he&amp;trackformat=srt&amp;origin=%2A\" srclang=\"he\" label=\"עברית (he) subtitles\" data-mwtitle=\"\" data-dir=\"rtl\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=it&amp;trackformat=srt&amp;origin=%2A\" srclang=\"it\" label=\"italiano (it) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ja&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ja\" label=\"日本語 (ja) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ko&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ko\" label=\"한국어 (ko) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=nl&amp;trackformat=srt&amp;origin=%2A\" srclang=\"nl\" label=\"Nederlands (nl) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=pl&amp;trackformat=srt&amp;origin=%2A\" srclang=\"pl\" label=\"polski (pl) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=pt&amp;trackformat=srt&amp;origin=%2A\" srclang=\"pt\" label=\"português (pt) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ro&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ro\" label=\"română (ro) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=ru&amp;trackformat=srt&amp;origin=%2A\" srclang=\"ru\" label=\"русский (ru) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=sv&amp;trackformat=srt&amp;origin=%2A\" srclang=\"sv\" label=\"svenska (sv) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=tr&amp;trackformat=srt&amp;origin=%2A\" srclang=\"tr\" label=\"Türkçe (tr) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=uk&amp;trackformat=srt&amp;origin=%2A\" srclang=\"uk\" label=\"українська (uk) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"><track kind=\"subtitles\" type=\"text/x-srt\" src=\"//commons.wikimedia.org/w/api.php?action=timedtext&amp;title=File%3AWikipedia_Edit_2014.webm&amp;lang=zh&amp;trackformat=srt&amp;origin=%2A\" srclang=\"zh\" label=\"中文 (zh) subtitles\" data-mwtitle=\"\" data-dir=\"ltr\"></video></a></span><figcaption>A promotional video of the Wikimedia Foundation that encourages viewers to edit Wikipedia, mostly reviewing 2014 via Wikipedia content</figcaption></figure>\n\n<p>In November 2009, a researcher at the <a href=\"/wiki/Rey_Juan_Carlos_University\" title=\"Rey Juan Carlos University\" class=\"mw-redirect\">Rey Juan Carlos University</a> in <a href=\"/wiki/Madrid\" title=\"Madrid\">Madrid</a> found that the English Wikipedia had lost 49,000 editors during the first three months of 2009; in comparison, the project lost only 4,900 editors during the same period in 2008.<span class=\"mw-ref\" id=\"cite_ref-guardian_editors_leaving_1_57-0\"><a href=\"#cite_note-guardian_editors_leaving_1-57\" style=\"counter-reset: mw-Ref 55;\"><span class=\"mw-reflink-text\">[55]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-58\"><a href=\"#cite_note-58\" style=\"counter-reset: mw-Ref 56;\"><span class=\"mw-reflink-text\">[56]</span></a></span> <i>The Wall Street Journal</i> cited the array of rules applied to editing and disputes related to such content among the reasons for this trend.<span class=\"mw-ref\" id=\"cite_ref-WSJ_WP_losing_editors_1_59-0\"><a href=\"#cite_note-WSJ_WP_losing_editors_1-59\" style=\"counter-reset: mw-Ref 57;\"><span class=\"mw-reflink-text\">[57]</span></a></span> Wales disputed these claims in 2009, denying the decline and questioning the methodology of the study.<span class=\"mw-ref\" id=\"cite_ref-telegraph_Wales_WP_not_losing_editors_1_60-0\"><a href=\"#cite_note-telegraph_Wales_WP_not_losing_editors_1-60\" style=\"counter-reset: mw-Ref 58;\"><span class=\"mw-reflink-text\">[58]</span></a></span> Two years later, in 2011, Wales acknowledged the presence of a slight decline, noting a decrease from \"a little more than 36,000 writers\" in June 2010 to 35,800 in June 2011. In the same interview, Wales also claimed the number of editors was \"stable and sustainable\".<span class=\"mw-ref\" id=\"cite_ref-wiki-women_61-0\"><a href=\"#cite_note-wiki-women-61\" style=\"counter-reset: mw-Ref 59;\"><span class=\"mw-reflink-text\">[59]</span></a></span> A 2013 article titled \"The Decline of Wikipedia\" in MIT's <i><a href=\"/wiki/Technology_Review\" title=\"Technology Review\" class=\"mw-redirect\">Technology Review</a></i> questioned this claim. The article revealed that since 2007, Wikipedia had lost a third of its volunteer editors, and those still there have focused increasingly on minutiae.<span class=\"mw-ref\" id=\"cite_ref-Simonite-2013_62-0\"><a href=\"#cite_note-Simonite-2013-62\" style=\"counter-reset: mw-Ref 60;\"><span class=\"mw-reflink-text\">[60]</span></a></span> In July 2012, <i><a href=\"/wiki/The_Atlantic\" title=\"The Atlantic\">The Atlantic</a></i> reported that the number of administrators is also in decline.<span class=\"mw-ref\" id=\"cite_ref-63\"><a href=\"#cite_note-63\" style=\"counter-reset: mw-Ref 61;\"><span class=\"mw-reflink-text\">[61]</span></a></span> In the November 25, 2013, issue of <i><a href=\"/wiki/New_York_(magazine)\" title=\"New York (magazine)\">New York</a></i> magazine, Katherine Ward stated \"Wikipedia, the sixth-most-used website, is facing an internal crisis\".<span class=\"mw-ref\" id=\"cite_ref-64\"><a href=\"#cite_note-64\" style=\"counter-reset: mw-Ref 62;\"><span class=\"mw-reflink-text\">[62]</span></a></span></p>\n\n","toclevel":2,"line":"Launch and early growth","anchor":"Launch_and_early_growth"},{"id":4,"text":"\n\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Tourism_Ranking-page-001.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/b6/Tourism_Ranking-page-001.jpg/220px-Tourism_Ranking-page-001.jpg\" data-file-width=\"2628\" data-file-height=\"1901\" data-file-type=\"bitmap\" height=\"159\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/b6/Tourism_Ranking-page-001.jpg/440px-Tourism_Ranking-page-001.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/b/b6/Tourism_Ranking-page-001.jpg/330px-Tourism_Ranking-page-001.jpg 1.5x\"></a><figcaption>Map is showing how many articles of each European language there were as of January 2019. One square represents 1000 articles. Languages with less than 1000 articles are represented with one square. Languages are grouped by language family and each language family is presented by a separate colour.</figcaption></figure>\n\n<p>In January 2007, Wikipedia entered for the first time the top-ten <a href=\"/wiki/List_of_most_popular_websites\" title=\"List of most popular websites\">list of the most popular websites</a> in the US, according to <a href=\"/wiki/ComScore\" title=\"ComScore\" class=\"mw-redirect\">comScore</a> Networks. With 42.9<span>&nbsp;</span>million unique visitors, Wikipedia was ranked number 9, surpassing <i><a href=\"/wiki/The_New_York_Times\" title=\"The New York Times\">The New York Times</a></i> (#10) and <a href=\"/wiki/Apple_Inc.\" title=\"Apple Inc.\">Apple</a> (#11). This marked a significant increase over January 2006, when the rank was number 33, with Wikipedia receiving around 18.3<span>&nbsp;</span>million unique visitors.<span class=\"mw-ref\" id=\"cite_ref-65\"><a href=\"#cite_note-65\" style=\"counter-reset: mw-Ref 63;\"><span class=\"mw-reflink-text\">[63]</span></a></span> <span>As of September</span><span>&nbsp;</span><span>2019</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>, Wikipedia has rank 9<span class=\"mw-ref\" id=\"cite_ref-Alexa_siteinfo_11-1\"><a href=\"#cite_note-Alexa_siteinfo-11\" style=\"counter-reset: mw-Ref 9;\"><span class=\"mw-reflink-text\">[9]</span></a></span> among websites in terms of popularity according to <a href=\"/wiki/Alexa_Internet\" title=\"Alexa Internet\">Alexa Internet</a>. In 2014, it received eight billion pageviews every month.<span class=\"mw-ref\" id=\"cite_ref-66\"><a href=\"#cite_note-66\" style=\"counter-reset: mw-Ref 64;\"><span class=\"mw-reflink-text\">[64]</span></a></span> On February 9, 2014, <i>The New York Times</i> reported that Wikipedia has 18<span>&nbsp;</span>billion <a href=\"/wiki/Page_view\" title=\"Page view\" class=\"mw-redirect\">page views</a> and nearly 500<span>&nbsp;</span>million <a href=\"/wiki/Unique_visitor\" title=\"Unique visitor\" class=\"mw-redirect\">unique visitors</a> a month, \"according to the ratings firm comScore\".<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-1\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span>\n</p>\n<figure class=\"mw-default-size mw-halign-right\"><a href=\"/wiki/File:History_Wikipedia_English_SOPA_2012_Blackout2.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a1/History_Wikipedia_English_SOPA_2012_Blackout2.jpg/220px-History_Wikipedia_English_SOPA_2012_Blackout2.jpg\" data-file-width=\"1580\" data-file-height=\"770\" data-file-type=\"bitmap\" height=\"107\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/a/a1/History_Wikipedia_English_SOPA_2012_Blackout2.jpg/440px-History_Wikipedia_English_SOPA_2012_Blackout2.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/a/a1/History_Wikipedia_English_SOPA_2012_Blackout2.jpg/330px-History_Wikipedia_English_SOPA_2012_Blackout2.jpg 1.5x\"></a><figcaption>Wikipedia blackout protest against <a href=\"/wiki/Stop_Online_Piracy_Act\" title=\"Stop Online Piracy Act\">SOPA</a> on January 18, 2012</figcaption></figure>\n\n<p>On January 18, 2012, the English Wikipedia participated in a series of coordinated protests against two proposed laws in the <a href=\"/wiki/United_States_Congress\" title=\"United States Congress\">United States Congress</a>—the <a href=\"/wiki/Stop_Online_Piracy_Act\" title=\"Stop Online Piracy Act\">Stop Online Piracy Act</a> (SOPA) and the <a href=\"/wiki/PROTECT_IP_Act\" title=\"PROTECT IP Act\">PROTECT IP Act</a> (PIPA)—by <a href=\"/wiki/Protest_against_SOPA_and_PIPA\" title=\"Protest against SOPA and PIPA\" class=\"mw-redirect\">blacking out its pages for 24 hours</a>.<span class=\"mw-ref\" id=\"cite_ref-LA_Times_Jan_19_67-0\"><a href=\"#cite_note-LA_Times_Jan_19-67\" style=\"counter-reset: mw-Ref 65;\"><span class=\"mw-reflink-text\">[65]</span></a></span> More than 162<span>&nbsp;</span>million people viewed the blackout explanation page that temporarily replaced Wikipedia content.<span class=\"mw-ref\" id=\"cite_ref-BBC_WP_blackout_protest_1_68-0\"><a href=\"#cite_note-BBC_WP_blackout_protest_1-68\" style=\"counter-reset: mw-Ref 66;\"><span class=\"mw-reflink-text\">[66]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-69\"><a href=\"#cite_note-69\" style=\"counter-reset: mw-Ref 67;\"><span class=\"mw-reflink-text\">[67]</span></a></span></p>\n\n<p>Loveland and Reagle argue that, in process, Wikipedia follows a long tradition of historical encyclopedias that accumulated improvements piecemeal through \"<a href=\"/wiki/Stigmergy\" title=\"Stigmergy\">stigmergic</a> accumulation\".<span class=\"mw-ref\" id=\"cite_ref-sagepub_WP_and_encyclopedic_production_1_70-0\"><a href=\"#cite_note-sagepub_WP_and_encyclopedic_production_1-70\" style=\"counter-reset: mw-Ref 68;\"><span class=\"mw-reflink-text\">[68]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-theatlantic_WP_actually_a_reversion_1_71-0\"><a href=\"#cite_note-theatlantic_WP_actually_a_reversion_1-71\" style=\"counter-reset: mw-Ref 69;\"><span class=\"mw-reflink-text\">[69]</span></a></span></p>\n\n<p>On January 20, 2014, Subodh Varma reporting for <i><a href=\"/wiki/The_Economic_Times\" title=\"The Economic Times\">The Economic Times</a></i> indicated that not only had Wikipedia's growth stalled, it \"had lost nearly ten percent of its page views last year. There was a decline of about two billion between December 2012 and December 2013. Its most popular versions are leading the slide: page-views of the English Wikipedia declined by twelve percent, those of German version slid by 17 percent and the Japanese version lost nine percent.\"<span class=\"mw-ref\" id=\"cite_ref-economictimes.indiatimes.com_72-0\"><a href=\"#cite_note-economictimes.indiatimes.com-72\" style=\"counter-reset: mw-Ref 70;\"><span class=\"mw-reflink-text\">[70]</span></a></span> Varma added that, \"While Wikipedia's managers think that this could be due to errors in counting, other experts feel that Google's <a href=\"/wiki/Knowledge_Graph\" title=\"Knowledge Graph\">Knowledge Graphs</a> project launched last year may be gobbling up Wikipedia users.\"<span class=\"mw-ref\" id=\"cite_ref-economictimes.indiatimes.com_72-1\"><a href=\"#cite_note-economictimes.indiatimes.com-72\" style=\"counter-reset: mw-Ref 70;\"><span class=\"mw-reflink-text\">[70]</span></a></span> When contacted on this matter, <a href=\"/wiki/Clay_Shirky\" title=\"Clay Shirky\">Clay Shirky</a>, associate professor at New York University and fellow at <a href=\"/wiki/Berkman_Klein_Center_for_Internet_&amp;_Society\" title=\"Berkman Klein Center for Internet &amp; Society\">Harvard's Berkman Center for Internet &amp; Society</a> indicated that he suspected much of the page view decline was due to Knowledge Graphs, stating, \"If you can get your question answered from the search page, you don't need to click [any further].\"<span class=\"mw-ref\" id=\"cite_ref-economictimes.indiatimes.com_72-2\"><a href=\"#cite_note-economictimes.indiatimes.com-72\" style=\"counter-reset: mw-Ref 70;\"><span class=\"mw-reflink-text\">[70]</span></a></span></p>\n\n<p>By the end of December 2016, Wikipedia was ranked fifth in the most popular websites globally.<span class=\"mw-ref\" id=\"cite_ref-Alexa_73-0\"><a href=\"#cite_note-Alexa-73\" style=\"counter-reset: mw-Ref 71;\"><span class=\"mw-reflink-text\">[71]</span></a></span></p>\n\n<p>In January 2013, <a href=\"/wiki/274301_Wikipedia\" title=\"274301 Wikipedia\">274301 Wikipedia</a>, an <a href=\"/wiki/Asteroid\" title=\"Asteroid\">asteroid</a>, was named after Wikipedia; in October 2014, Wikipedia was honored with the <i><a href=\"/wiki/Wikipedia_Monument\" title=\"Wikipedia Monument\">Wikipedia Monument</a></i>; and, in July 2015, Wikipedia became available as <a href=\"/wiki/Print_Wikipedia\" title=\"Print Wikipedia\">7,473 books for $500,000</a>. In 2019, a species of flowering plant was named <i><a href=\"/wiki/Viola_wikipedia\" title=\"Viola wikipedia\">Viola wikipedia</a></i>.<span class=\"mw-ref\" id=\"cite_ref-Watson_74-0\"><a href=\"#cite_note-Watson-74\" style=\"counter-reset: mw-Ref 72;\"><span class=\"mw-reflink-text\">[72]</span></a></span></p>\n\n<p>In April 2019, an Israeli <a href=\"/wiki/Lunar_lander\" title=\"Lunar lander\">lunar lander</a>, <a href=\"/wiki/Beresheet\" title=\"Beresheet\">Beresheet</a>, crash landed on the surface of the <a href=\"/wiki/Moon\" title=\"Moon\">Moon</a> carrying a copy of nearly all of the English Wikipedia engraved on thin nickel plates; experts say the plates likely survived the crash.<span class=\"mw-ref\" id=\"cite_ref-WRD-20190805_75-0\"><a href=\"#cite_note-WRD-20190805-75\" style=\"counter-reset: mw-Ref 73;\"><span class=\"mw-reflink-text\">[73]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-VOX-20190806_76-0\"><a href=\"#cite_note-VOX-20190806-76\" style=\"counter-reset: mw-Ref 74;\"><span class=\"mw-reflink-text\">[74]</span></a></span></p>\n\n<p>In June 2019, scientists reported that all 16<span>&nbsp;</span>GB of article text from the English Wikipedia have been encoded into <a href=\"/wiki/Synthetic_DNA\" title=\"Synthetic DNA\" class=\"mw-redirect\">synthetic DNA</a>.<span class=\"mw-ref\" id=\"cite_ref-CNET-20190629_77-0\"><a href=\"#cite_note-CNET-20190629-77\" style=\"counter-reset: mw-Ref 75;\"><span class=\"mw-reflink-text\">[75]</span></a></span></p>\n\n","toclevel":2,"line":"Milestones","anchor":"Milestones"},{"id":5,"text":"\n\n<div class=\"thumb tright\" style=\"\" about=\"#mwt506\"><div class=\"thumbinner\" style=\"width:262px\"><div class=\"thumbimage noresize\" style=\"width:260px;\"><style data-mw-deduplicate=\"TemplateStyles:r950958020\" typeof=\"mw:Extension/templatestyles\">@media all and (max-width:720px){body.skin-minerva .mw-parser-output div.mw-graph{min-width:auto!important;max-width:100%;overflow-x:auto;overflow-y:visible}}.mw-parser-output .mw-graph-img{width:inherit;height:inherit}</style><div class=\"mw-graph\" style=\"min-width:190px;min-height:150px\" about=\"#mwt513\"><img class=\"mw-graph-img\" src=\"/api/rest_v1/page/graph/png/Wikipedia/0/0ae355c9441944475f60652a9c3b7b98f00f94b0.png\"></div><span>\n</span></div><div class=\"thumbcaption\">Number of English Wikipedia articles<span class=\"mw-ref\" id=\"cite_ref-Wikimedia_Stats_22-1\"><a href=\"#cite_note-Wikimedia_Stats-22\" style=\"counter-reset: mw-Ref 20;\"><span class=\"mw-reflink-text\">[20]</span></a></span></div></div></div><span>\n</span><div class=\"thumb tright\" style=\"\" about=\"#mwt520\"><div class=\"thumbinner\" style=\"width:262px\"><div class=\"thumbimage noresize\" style=\"width:260px;\"><div class=\"mw-graph\" style=\"min-width:211px;min-height:120px\" about=\"#mwt527\"><img class=\"mw-graph-img\" src=\"/api/rest_v1/page/graph/png/Wikipedia/0/ce1141d2ed567337af88321dbef9f7aef9cc7262.png\"></div><span>\n</span></div><div class=\"thumbcaption\">English Wikipedia editors with &gt;100 edits per month<span class=\"mw-ref\" id=\"cite_ref-stats.wikimedia.org_editor_metric_graph_78-0\"><a href=\"#cite_note-stats.wikimedia.org_editor_metric_graph-78\" style=\"counter-reset: mw-Ref 76;\"><span class=\"mw-reflink-text\">[76]</span></a></span></div></div></div><span>\n</span>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:History_Comparison_Example_(Vector).png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/96/History_Comparison_Example_%28Vector%29.png/220px-History_Comparison_Example_%28Vector%29.png\" data-file-width=\"1225\" data-file-height=\"768\" data-file-type=\"bitmap\" height=\"138\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/96/History_Comparison_Example_%28Vector%29.png/440px-History_Comparison_Example_%28Vector%29.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/9/96/History_Comparison_Example_%28Vector%29.png/330px-History_Comparison_Example_%28Vector%29.png 1.5x\"></a><figcaption>Differences between versions of an article are highlighted</figcaption></figure>\n\n<p>Unlike traditional encyclopedias, Wikipedia follows the <a href=\"/wiki/Procrastination\" title=\"Procrastination\">procrastination</a> principle<span class=\"mw-ref\" id=\"cite_ref-79\"><a href=\"#cite_note-79\" style=\"counter-reset: mw-Ref 3;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 3]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-zittrain_80-0\"><a href=\"#cite_note-zittrain-80\" style=\"counter-reset: mw-Ref 77;\"><span class=\"mw-reflink-text\">[77]</span></a></span> regarding the security of its content.<span class=\"mw-ref\" id=\"cite_ref-zittrain_80-1\"><a href=\"#cite_note-zittrain-80\" style=\"counter-reset: mw-Ref 77;\"><span class=\"mw-reflink-text\">[77]</span></a></span> It started almost entirely open—anyone could create articles, and any Wikipedia article could be edited by any reader, even those who did not have a Wikipedia account. Modifications to all articles would be published immediately. As a result, any article could contain inaccuracies such as errors, <a href=\"/wiki/Ideological_bias_on_Wikipedia\" title=\"Ideological bias on Wikipedia\">ideological biases</a>, and nonsensical or irrelevant text.</p>\n\n","toclevel":1,"line":"Openness","anchor":"Openness"},{"id":6,"text":"\n\n<p>Due to the increasing popularity of Wikipedia, some editions, including the English version, have introduced editing restrictions in some cases. For instance, on the English Wikipedia and some other language editions, only registered users may create a new article.<span class=\"mw-ref\" id=\"cite_ref-81\"><a href=\"#cite_note-81\" style=\"counter-reset: mw-Ref 78;\"><span class=\"mw-reflink-text\">[78]</span></a></span> On the English Wikipedia, among others, some particularly controversial, sensitive and/or vandalism-prone pages have been protected to some degree.<span class=\"mw-ref\" id=\"cite_ref-WP_protection_policy_1_82-0\"><a href=\"#cite_note-WP_protection_policy_1-82\" style=\"counter-reset: mw-Ref 79;\"><span class=\"mw-reflink-text\">[79]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-83\"><a href=\"#cite_note-83\" style=\"counter-reset: mw-Ref 80;\"><span class=\"mw-reflink-text\">[80]</span></a></span> A frequently vandalized article can be <a href=\"/wiki/Help:Semi-protection\" title=\"Help:Semi-protection\" class=\"mw-redirect\">semi-protected</a> or <a href=\"/wiki/Wikipedia:ECP\" title=\"Wikipedia:ECP\" class=\"mw-redirect\">extended confirmed protected</a>, meaning that only <a href=\"/wiki/Wikipedia:Autoconfirmed\" title=\"Wikipedia:Autoconfirmed\" class=\"mw-redirect\">autoconfirmed</a> or <a href=\"/wiki/Wikipedia:XCON\" title=\"Wikipedia:XCON\" class=\"mw-redirect\">extended confirmed</a> editors are able to modify it.<span class=\"mw-ref\" id=\"cite_ref-84\"><a href=\"#cite_note-84\" style=\"counter-reset: mw-Ref 81;\"><span class=\"mw-reflink-text\">[81]</span></a></span> A particularly contentious article may be locked so that only <a href=\"/wiki/Wikipedia_administrators\" title=\"Wikipedia administrators\">administrators</a> are able to make changes.<span class=\"mw-ref\" id=\"cite_ref-85\"><a href=\"#cite_note-85\" style=\"counter-reset: mw-Ref 82;\"><span class=\"mw-reflink-text\">[82]</span></a></span></p>\n\n<p>In certain cases, all editors are allowed to submit modifications, but review is required for some editors, depending on certain conditions. For example, the <a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German Wikipedia</a> maintains \"stable versions\" of articles,<span class=\"mw-ref\" id=\"cite_ref-WP_some_sites_stable_versions_1_86-0\"><a href=\"#cite_note-WP_some_sites_stable_versions_1-86\" style=\"counter-reset: mw-Ref 83;\"><span class=\"mw-reflink-text\">[83]</span></a></span> which have passed certain reviews. Following protracted trials and community discussion, the English Wikipedia introduced the \"pending changes\" system in December 2012.<span class=\"mw-ref\" id=\"cite_ref-BInsider_pending_changes_intro_1_87-0\"><a href=\"#cite_note-BInsider_pending_changes_intro_1-87\" style=\"counter-reset: mw-Ref 84;\"><span class=\"mw-reflink-text\">[84]</span></a></span> Under this system, new and unregistered users' edits to certain controversial or vandalism-prone articles are reviewed by established users before they are published.<span class=\"mw-ref\" id=\"cite_ref-88\"><a href=\"#cite_note-88\" style=\"counter-reset: mw-Ref 85;\"><span class=\"mw-reflink-text\">[85]</span></a></span></p>\n<figure class=\"mw-default-size mw-halign-left\"><a href=\"/wiki/File:Wikipedia_editing_interface.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Wikipedia_editing_interface.png/220px-Wikipedia_editing_interface.png\" data-file-width=\"1912\" data-file-height=\"909\" data-file-type=\"bitmap\" height=\"105\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Wikipedia_editing_interface.png/440px-Wikipedia_editing_interface.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Wikipedia_editing_interface.png/330px-Wikipedia_editing_interface.png 1.5x\"></a><figcaption>The editing interface of Wikipedia</figcaption></figure>\n\n","toclevel":2,"line":"Restrictions","anchor":"Restrictions"},{"id":7,"text":"\n\n<p>Although changes are not systematically reviewed, the software that powers Wikipedia provides certain tools allowing anyone to review changes made by others. The \"History\" page of each article links to each revision.<span class=\"mw-ref\" id=\"cite_ref-89\"><a href=\"#cite_note-89\" style=\"counter-reset: mw-Ref 4;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 4]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Torsten_Kleinz_90-0\"><a href=\"#cite_note-Torsten_Kleinz-90\" style=\"counter-reset: mw-Ref 86;\"><span class=\"mw-reflink-text\">[86]</span></a></span> On most articles, anyone can undo others' changes by clicking a link on the article's history page. Anyone can view the <a href=\"/wiki/Help:Recent_changes\" title=\"Help:Recent changes\">latest changes</a> to articles, and anyone may maintain a <a href=\"/wiki/Recent_changes\" title=\"Recent changes\" class=\"mw-redirect\">\"watchlist\"</a> of articles that interest them so they can be notified of any changes. \"New pages patrol\" is a process whereby newly created articles are checked for obvious problems.<span class=\"mw-ref\" id=\"cite_ref-91\"><a href=\"#cite_note-91\" style=\"counter-reset: mw-Ref 87;\"><span class=\"mw-reflink-text\">[87]</span></a></span></p>\n\n<p>In 2003, economics Ph.D. student Andrea Ciffolilli argued that the low <a href=\"/wiki/Transaction_cost\" title=\"Transaction cost\">transaction costs</a> of participating in a <a href=\"/wiki/Wiki\" title=\"Wiki\">wiki</a> create a catalyst for collaborative development, and that features such as allowing easy access to past versions of a page favor \"creative construction\" over \"creative destruction\".<span class=\"mw-ref\" id=\"cite_ref-FMonday_collaborative_effort_1_92-0\"><a href=\"#cite_note-FMonday_collaborative_effort_1-92\" style=\"counter-reset: mw-Ref 88;\"><span class=\"mw-reflink-text\">[88]</span></a></span></p>\n\n","toclevel":2,"line":"Review of changes","anchor":"Review_of_changes"},{"id":8,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt603\">Main article: <a href=\"/wiki/Vandalism_on_Wikipedia\" title=\"Vandalism on Wikipedia\">Vandalism on Wikipedia</a></div>\n\n<p>Any change or edit that manipulates content in a way that purposefully compromises the integrity of Wikipedia is considered vandalism. The most common and obvious types of vandalism include additions of obscenities and crude humor. Vandalism can also include advertising and other types of spam.<span class=\"mw-ref\" id=\"cite_ref-upenn_link_spamming_1_93-0\"><a href=\"#cite_note-upenn_link_spamming_1-93\" style=\"counter-reset: mw-Ref 89;\"><span class=\"mw-reflink-text\">[89]</span></a></span> Sometimes editors commit vandalism by removing content or entirely blanking a given page. Less common types of vandalism, such as the deliberate addition of plausible but false information to an article can be more difficult to detect. Vandals can introduce irrelevant formatting, modify page semantics such as the page's title or categorization, manipulate the underlying code of an article, or use images disruptively.<span class=\"mw-ref\" id=\"cite_ref-WP_vandalism_manipulation_1_94-0\"><a href=\"#cite_note-WP_vandalism_manipulation_1-94\" style=\"counter-reset: mw-Ref 90;\"><span class=\"mw-reflink-text\">[90]</span></a></span></p>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:John_Seigenthaler_Sr._speaking.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/2f/John_Seigenthaler_Sr._speaking.jpg/220px-John_Seigenthaler_Sr._speaking.jpg\" data-file-width=\"800\" data-file-height=\"600\" data-file-type=\"bitmap\" height=\"165\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/2f/John_Seigenthaler_Sr._speaking.jpg/440px-John_Seigenthaler_Sr._speaking.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/2f/John_Seigenthaler_Sr._speaking.jpg/330px-John_Seigenthaler_Sr._speaking.jpg 1.5x\"></a><figcaption>American journalist <a href=\"/wiki/John_Seigenthaler\" title=\"John Seigenthaler\">John Seigenthaler</a> (1927–2014), subject of the <a href=\"/wiki/Seigenthaler_incident\" title=\"Seigenthaler incident\" class=\"mw-redirect\">Seigenthaler incident</a>.</figcaption></figure>\n\n<p>Obvious vandalism is generally easy to remove from Wikipedia articles; the median time to detect and fix vandalism is a few minutes.<span class=\"mw-ref\" id=\"cite_ref-MIT_IBM_study_95-0\"><a href=\"#cite_note-MIT_IBM_study-95\" style=\"counter-reset: mw-Ref 91;\"><span class=\"mw-reflink-text\">[91]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-CreatingDestroyingAndRestoringValue_96-0\"><a href=\"#cite_note-CreatingDestroyingAndRestoringValue-96\" style=\"counter-reset: mw-Ref 92;\"><span class=\"mw-reflink-text\">[92]</span></a></span> However, some vandalism takes much longer to repair.<span class=\"mw-ref\" id=\"cite_ref-Seigenthaler_97-0\"><a href=\"#cite_note-Seigenthaler-97\" style=\"counter-reset: mw-Ref 93;\"><span class=\"mw-reflink-text\">[93]</span></a></span></p>\n\n<p>In the <a href=\"/wiki/Seigenthaler_biography_incident\" title=\"Seigenthaler biography incident\" class=\"mw-redirect\">Seigenthaler biography incident</a>, an anonymous editor introduced false information into the biography of American political figure <a href=\"/wiki/John_Seigenthaler\" title=\"John Seigenthaler\">John Seigenthaler</a> in May 2005. Seigenthaler was falsely presented as a suspect in the assassination of John F. Kennedy.<span class=\"mw-ref\" id=\"cite_ref-Seigenthaler_97-1\"><a href=\"#cite_note-Seigenthaler-97\" style=\"counter-reset: mw-Ref 93;\"><span class=\"mw-reflink-text\">[93]</span></a></span> The article remained uncorrected for four months.<span class=\"mw-ref\" id=\"cite_ref-Seigenthaler_97-2\"><a href=\"#cite_note-Seigenthaler-97\" style=\"counter-reset: mw-Ref 93;\"><span class=\"mw-reflink-text\">[93]</span></a></span> Seigenthaler, the founding editorial director of <i><a href=\"/wiki/USA_Today\" title=\"USA Today\">USA Today</a></i> and founder of the <a href=\"/wiki/Freedom_Forum\" title=\"Freedom Forum\">Freedom Forum</a> <a href=\"/wiki/First_Amendment_Center\" title=\"First Amendment Center\">First Amendment Center</a> at <a href=\"/wiki/Vanderbilt_University\" title=\"Vanderbilt University\">Vanderbilt University</a>, called Wikipedia co-founder Jimmy Wales and asked whether he had any way of knowing who contributed the misinformation. Wales replied that he did not, although the perpetrator was eventually traced.<span class=\"mw-ref\" id=\"cite_ref-book_The_World_is_Flat_1_98-0\"><a href=\"#cite_note-book_The_World_is_Flat_1-98\" style=\"counter-reset: mw-Ref 94;\"><span class=\"mw-reflink-text\">[94]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-99\"><a href=\"#cite_note-99\" style=\"counter-reset: mw-Ref 95;\"><span class=\"mw-reflink-text\">[95]</span></a></span> After the incident, Seigenthaler described Wikipedia as \"a flawed and irresponsible research tool\".<span class=\"mw-ref\" id=\"cite_ref-Seigenthaler_97-3\"><a href=\"#cite_note-Seigenthaler-97\" style=\"counter-reset: mw-Ref 93;\"><span class=\"mw-reflink-text\">[93]</span></a></span> This incident led to policy changes at Wikipedia, specifically targeted at tightening up the verifiability of <a href=\"/wiki/Wikipedia:Biographies_of_living_persons\" title=\"Wikipedia:Biographies of living persons\">biographical articles of living people</a>.<span class=\"mw-ref\" id=\"cite_ref-100\"><a href=\"#cite_note-100\" style=\"counter-reset: mw-Ref 96;\"><span class=\"mw-reflink-text\">[96]</span></a></span></p>\n\n","toclevel":2,"line":"Vandalism","anchor":"Vandalism"},{"id":9,"text":"\n\n<p>Wikipedians often have disputes regarding content, which may result in repeatedly making opposite changes to an article, known as <a href=\"/wiki/Wikipedia:EW\" title=\"Wikipedia:EW\" class=\"mw-redirect\">\"edit warring\"</a>.<span class=\"mw-ref\" id=\"cite_ref-101\"><a href=\"#cite_note-101\" style=\"counter-reset: mw-Ref 97;\"><span class=\"mw-reflink-text\">[97]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-NBC_WP_editorial_warzone_12_102-0\"><a href=\"#cite_note-NBC_WP_editorial_warzone_12-102\" style=\"counter-reset: mw-Ref 98;\"><span class=\"mw-reflink-text\">[98]</span></a></span> The process is a resource-consuming scenario where no useful knowledge is added.<span class=\"mw-ref\" id=\"cite_ref-103\"><a href=\"#cite_note-103\" style=\"counter-reset: mw-Ref 99;\"><span class=\"mw-reflink-text\">[99]</span></a></span> This practice is also criticized as creating a competitive,<span class=\"mw-ref\" id=\"cite_ref-104\"><a href=\"#cite_note-104\" style=\"counter-reset: mw-Ref 100;\"><span class=\"mw-reflink-text\">[100]</span></a></span> conflict based<span class=\"mw-ref\" id=\"cite_ref-105\"><a href=\"#cite_note-105\" style=\"counter-reset: mw-Ref 101;\"><span class=\"mw-reflink-text\">[101]</span></a></span> editing culture associated with traditional masculine <a href=\"/wiki/Gender_role\" title=\"Gender role\">gender roles</a>,<span class=\"mw-ref\" id=\"cite_ref-106\"><a href=\"#cite_note-106\" style=\"counter-reset: mw-Ref 102;\"><span class=\"mw-reflink-text\">[102]</span></a></span> which contributes to the <a href=\"/wiki/Gender_bias_on_Wikipedia\" title=\"Gender bias on Wikipedia\">gender bias on Wikipedia</a>.</p>\n\n<p>Special interest groups have engaged in edit wars to advance their own political interests. Defending Israeli settlements in the West Bank, numerous pro-occupation groups have launched \"Zionist editing\" campaigns.<span class=\"mw-ref\" id=\"cite_ref-107\"><a href=\"#cite_note-107\" style=\"counter-reset: mw-Ref 103;\"><span class=\"mw-reflink-text\">[103]</span></a></span> In 2010, the then-director general of the <a href=\"/wiki/Yesha_Council\" title=\"Yesha Council\">Yesha Council</a> and former Israeli Cabinet Minister <a href=\"/wiki/Naftali_Bennett\" title=\"Naftali Bennett\">Naftali Bennett</a> described their goal \"as not to make Wikipedia rightist but for it to include our point of view\".<span class=\"mw-ref\" id=\"cite_ref-108\"><a href=\"#cite_note-108\" style=\"counter-reset: mw-Ref 104;\"><span class=\"mw-reflink-text\">[104]</span></a></span></p>\n\n","toclevel":2,"line":"Edit warring","anchor":"Edit_warring"},{"id":10,"text":"\n\n<p></p>\n<table class=\"infobox\" style=\"width:22em;width: 220px; float: right; clear: right; margin:0 0 1.5em 1.5em\"><caption>External video</caption><tbody><tr><td colspan=\"2\" style=\"text-align:center\"><figure-inline><a href=\"/wiki/File:Jimbo_at_Fosdem_cropped.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/47/Jimbo_at_Fosdem_cropped.jpg/210px-Jimbo_at_Fosdem_cropped.jpg\" data-file-width=\"1536\" data-file-height=\"1786\" data-file-type=\"bitmap\" height=\"244\" width=\"210\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/47/Jimbo_at_Fosdem_cropped.jpg/420px-Jimbo_at_Fosdem_cropped.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/4/47/Jimbo_at_Fosdem_cropped.jpg/315px-Jimbo_at_Fosdem_cropped.jpg 1.5x\"></a></figure-inline></td></tr><tr><td colspan=\"2\" style=\"text-align:center;text-align: left\"><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/16px-Nuvola_apps_kaboodle.svg.png\" data-file-width=\"128\" data-file-height=\"128\" data-file-type=\"drawing\" height=\"16\" width=\"16\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/32px-Nuvola_apps_kaboodle.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/24px-Nuvola_apps_kaboodle.svg.png 1.5x\"></span></figure-inline> <a rel=\"mw:ExtLink\" href=\"https://www.cbsnews.com/news/wikipedia-jimmy-wales-morley-safer-60-minutes/\" class=\"external text\">Wikimania</a>, <i><a href=\"/wiki/60_Minutes\" title=\"60 Minutes\">60 Minutes</a></i>, <a href=\"/wiki/CBS\" title=\"CBS\">CBS</a>, 20 minutes, April 5, 2015, co-founder Jimmy Wales at <a href=\"/wiki/Fosdem\" title=\"Fosdem\" class=\"mw-redirect\">Fosdem</a></td></tr></tbody></table>\n\n<p>Content in Wikipedia is subject to the laws (in particular, <a href=\"/wiki/Copyright\" title=\"Copyright\">copyright</a> laws) of the United States and of the US state of <a href=\"/wiki/Virginia\" title=\"Virginia\">Virginia</a>, where the majority of Wikipedia's servers are located. Beyond legal matters, the editorial principles of Wikipedia are embodied in the <a href=\"/wiki/Wikipedia:Five_pillars\" title=\"Wikipedia:Five pillars\">\"five pillars\"</a> and in numerous <a href=\"/wiki/Wikipedia:List_of_policies_and_guidelines\" title=\"Wikipedia:List of policies and guidelines\">policies and guidelines</a> intended to appropriately shape content. Even these rules are stored in wiki form, and Wikipedia editors write and revise the website's policies and guidelines.<span class=\"mw-ref\" id=\"cite_ref-pcworld_who's_behind_WP_109-0\"><a href=\"#cite_note-pcworld_who's_behind_WP-109\" style=\"counter-reset: mw-Ref 105;\"><span class=\"mw-reflink-text\">[105]</span></a></span> Editors can <a href=\"/wiki/Wikipedia:Enforcement\" title=\"Wikipedia:Enforcement\" class=\"mw-redirect\">enforce these rules</a> by deleting or modifying non-compliant material. Originally, rules on the non-English editions of Wikipedia were based on a translation of the rules for the English Wikipedia. They have since diverged to some extent.<span class=\"mw-ref\" id=\"cite_ref-WP_some_sites_stable_versions_1_86-1\"><a href=\"#cite_note-WP_some_sites_stable_versions_1-86\" style=\"counter-reset: mw-Ref 83;\"><span class=\"mw-reflink-text\">[83]</span></a></span></p>\n\n","toclevel":1,"line":"<span id=\"Rules_and_laws_governing_content\">Policies and laws</span>","anchor":"Policies_and_laws"},{"id":11,"text":"\n\n<p>According to the rules on the English Wikipedia, each entry in Wikipedia must be about a topic that is <a href=\"https://en.wiktionary.org/wiki/encyclopedic\" title=\"wikt:encyclopedic\">encyclopedic</a> and is not a dictionary entry or dictionary-style.<span class=\"mw-ref\" id=\"cite_ref-WP_content_policy_1_110-0\"><a href=\"#cite_note-WP_content_policy_1-110\" style=\"counter-reset: mw-Ref 106;\"><span class=\"mw-reflink-text\">[106]</span></a></span> A topic should also meet <a href=\"/wiki/Notability_in_the_English_Wikipedia\" title=\"Notability in the English Wikipedia\">Wikipedia's standards of \"notability\"</a>,<span class=\"mw-ref\" id=\"cite_ref-WP_notability_guide_1_111-0\"><a href=\"#cite_note-WP_notability_guide_1-111\" style=\"counter-reset: mw-Ref 107;\"><span class=\"mw-reflink-text\">[107]</span></a></span> which generally means that the topic must have been covered in mainstream media or major academic journal sources that are independent of the article's subject. Further, Wikipedia intends to convey only knowledge that is already established and recognized.<span class=\"mw-ref\" id=\"cite_ref-NOR_112-0\"><a href=\"#cite_note-NOR-112\" style=\"counter-reset: mw-Ref 108;\"><span class=\"mw-reflink-text\">[108]</span></a></span> <a href=\"/wiki/Wikipedia:No_original_research\" title=\"Wikipedia:No original research\">It must not present original research</a>. A claim that is likely to be challenged requires a reference to a <a href=\"/wiki/Wikipedia:Identifying_reliable_sources\" title=\"Wikipedia:Identifying reliable sources\" class=\"mw-redirect\">reliable source</a>. Among Wikipedia editors, this is often phrased as \"verifiability, not truth\" to express the idea that the readers, not the encyclopedia, are ultimately responsible for checking the truthfulness of the articles and making their own interpretations.<span class=\"mw-ref\" id=\"cite_ref-WP_Verifiability_policy_1_113-0\"><a href=\"#cite_note-WP_Verifiability_policy_1-113\" style=\"counter-reset: mw-Ref 109;\"><span class=\"mw-reflink-text\">[109]</span></a></span> This can at times lead to the removal of information that, though valid, is not properly sourced.<span class=\"mw-ref\" id=\"cite_ref-IHT_WP_valid_info_wrong_removable_1_114-0\"><a href=\"#cite_note-IHT_WP_valid_info_wrong_removable_1-114\" style=\"counter-reset: mw-Ref 110;\"><span class=\"mw-reflink-text\">[110]</span></a></span> Finally, Wikipedia must not take sides.<span class=\"mw-ref\" id=\"cite_ref-autogenerated2_115-0\"><a href=\"#cite_note-autogenerated2-115\" style=\"counter-reset: mw-Ref 111;\"><span class=\"mw-reflink-text\">[111]</span></a></span> All opinions and viewpoints, if attributable to external sources, must enjoy an appropriate share of coverage within an article. This is known as neutral point of view (NPOV).</p>\n\n","toclevel":2,"line":"Content policies and guidelines","anchor":"Content_policies_and_guidelines"},{"id":12,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt750\">Further information: <a href=\"/wiki/Wikipedia:Administration\" title=\"Wikipedia:Administration\">Wikipedia:Administration</a></div>\n\n<p>Wikipedia's initial <a href=\"/wiki/Anarchy\" title=\"Anarchy\">anarchy</a> integrated <a href=\"/wiki/Democracy\" title=\"Democracy\">democratic</a> and hierarchical elements over time.<span class=\"mw-ref\" id=\"cite_ref-116\"><a href=\"#cite_note-116\" style=\"counter-reset: mw-Ref 112;\"><span class=\"mw-reflink-text\">[112]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-117\"><a href=\"#cite_note-117\" style=\"counter-reset: mw-Ref 113;\"><span class=\"mw-reflink-text\">[113]</span></a></span> An article is not considered to be owned by its creator or any other editor, nor by the subject of the article.<span class=\"mw-ref\" id=\"cite_ref-118\"><a href=\"#cite_note-118\" style=\"counter-reset: mw-Ref 114;\"><span class=\"mw-reflink-text\">[114]</span></a></span></p>\n\n","toclevel":1,"line":"Governance","anchor":"Governance"},{"id":13,"text":"\n\n<p><a href=\"/wiki/Wikipedia:Wikipedians\" title=\"Wikipedia:Wikipedians\">Editors</a> in good standing in the community can run for one of many levels of volunteer stewardship: this begins with \"<a href=\"/wiki/Administrators_(Wikipedia)\" title=\"Administrators (Wikipedia)\" class=\"mw-redirect\">administrator</a>\",<span class=\"mw-ref\" id=\"cite_ref-119\"><a href=\"#cite_note-119\" style=\"counter-reset: mw-Ref 115;\"><span class=\"mw-reflink-text\">[115]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-David_Mehegan_120-0\"><a href=\"#cite_note-David_Mehegan-120\" style=\"counter-reset: mw-Ref 116;\"><span class=\"mw-reflink-text\">[116]</span></a></span> privileged users who can delete pages, prevent articles from being changed in case of vandalism or editorial disputes (setting protective measures on articles), and try to prevent certain people from editing. Despite the name, administrators are not supposed to enjoy any special privilege in decision-making; instead, their powers are mostly limited to making edits that have project-wide effects and thus are disallowed to ordinary editors, and to implement restrictions intended to prevent certain persons from making disruptive edits (such as vandalism).<span class=\"mw-ref\" id=\"cite_ref-121\"><a href=\"#cite_note-121\" style=\"counter-reset: mw-Ref 117;\"><span class=\"mw-reflink-text\">[117]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-122\"><a href=\"#cite_note-122\" style=\"counter-reset: mw-Ref 118;\"><span class=\"mw-reflink-text\">[118]</span></a></span></p>\n\n<p>Fewer editors become administrators than in years past, in part because the process of vetting potential Wikipedia administrators has become more rigorous.<span class=\"mw-ref\" id=\"cite_ref-123\"><a href=\"#cite_note-123\" style=\"counter-reset: mw-Ref 119;\"><span class=\"mw-reflink-text\">[119]</span></a></span></p>\n\n<p><a href=\"/wiki/Wikipedia:Bureaucrats\" title=\"Wikipedia:Bureaucrats\">Bureaucrats</a> name new administrators solely upon the recommendations from the community.</p>\n\n","toclevel":2,"line":"Administrators","anchor":"Administrators"},{"id":14,"text":"\n\n<p>Over time, Wikipedia has developed a semi-formal dispute resolution process to assist in such circumstances. In order to determine community consensus, editors can raise issues at appropriate community forums,<span class=\"mw-ref\" id=\"cite_ref-124\"><a href=\"#cite_note-124\" style=\"counter-reset: mw-Ref 5;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 5]</span></a></span> or seek outside input through <a href=\"/wiki/Wikipedia:Third_opinion\" title=\"Wikipedia:Third opinion\">third opinion requests</a> or by initiating a more general community discussion known as a <a href=\"/wiki/Wikipedia:RfC\" title=\"Wikipedia:RfC\" class=\"mw-redirect\">\"request for comment\"</a>.</p>\n\n","toclevel":2,"line":"Dispute resolution","anchor":"Dispute_resolution"},{"id":15,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt800\">Main article: <a href=\"/wiki/Arbitration_Committee\" title=\"Arbitration Committee\">Arbitration Committee</a></div>\n\n<p>The Arbitration Committee presides over the ultimate dispute resolution process. Although disputes usually arise from a disagreement between two opposing views on how an article should read, the Arbitration Committee explicitly refuses to directly rule on the specific view that should be adopted. Statistical analyses suggest that the committee ignores the content of disputes and rather focuses on the way disputes are conducted,<span class=\"mw-ref\" id=\"cite_ref-emory_disputes_handled_1_125-0\"><a href=\"#cite_note-emory_disputes_handled_1-125\" style=\"counter-reset: mw-Ref 120;\"><span class=\"mw-reflink-text\">[120]</span></a></span> functioning not so much to resolve disputes and make peace between conflicting editors, but to weed out problematic editors while allowing potentially productive editors back in to participate. Therefore, the committee does not dictate the content of articles, although it sometimes condemns content changes when it deems the new content violates Wikipedia policies (for example, if the new content is considered <a href=\"/wiki/Wikipedia:Neutral_point_of_view\" title=\"Wikipedia:Neutral point of view\">biased</a>). Its remedies include cautions and <a href=\"/wiki/Wikipedia:Probation\" title=\"Wikipedia:Probation\" class=\"mw-redirect\">probations</a> (used in 63% of cases) and <a href=\"/wiki/Wikipedia:BAN\" title=\"Wikipedia:BAN\" class=\"mw-redirect\">banning editors from articles</a> (43%), subject matters (23%), or Wikipedia (16%). Complete bans from Wikipedia are generally limited to instances of impersonation and <a href=\"/wiki/Anti-social_behavior\" title=\"Anti-social behavior\" class=\"mw-redirect\">anti-social behavior</a>. When conduct is not impersonation or anti-social, but rather anti-consensus or in violation of editing policies, remedies tend to be limited to warnings.<span class=\"mw-ref\" id=\"cite_ref-126\"><a href=\"#cite_note-126\" style=\"counter-reset: mw-Ref 121;\"><span class=\"mw-reflink-text\">[121]</span></a></span></p>\n\n","toclevel":3,"line":"Arbitration Committee","anchor":"Arbitration_Committee"},{"id":16,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt811\">Main article: <a href=\"/wiki/Wikipedia_community\" title=\"Wikipedia community\">Wikipedia community</a></div>\n<figure class=\"mw-default-size\"><span><a href=\"/wiki/File:Wikimania_-_the_Wikimentary.webm\" class=\"app_media\"><video poster=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/61/Wikimania_-_the_Wikimentary.webm/220px--Wikimania_-_the_Wikimentary.webm.jpg\" preload=\"none\" height=\"168\" width=\"220\" resource=\"./File:Wikimania_-_the_Wikimentary.webm\"><source src=\"//upload.wikimedia.org/wikipedia/commons/6/61/Wikimania_-_the_Wikimentary.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-file-width=\"627\" data-file-height=\"478\" data-title=\"Original WebM file, 627 × 478 (869 kbps)\" data-shorttitle=\"WebM source\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.120p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"158\" data-height=\"120\" data-title=\"Lowest bandwidth VP9 (120P)\" data-shorttitle=\"VP9 120P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.160p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"210\" data-height=\"160\" data-title=\"Low bandwidth WebM (160P)\" data-shorttitle=\"WebM 160P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.180p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"236\" data-height=\"180\" data-title=\"Low bandwidth VP9 (180P)\" data-shorttitle=\"VP9 180P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.240p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"314\" data-height=\"240\" data-title=\"Small VP9 (240P)\" data-shorttitle=\"VP9 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.240p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"314\" data-height=\"240\" data-title=\"Small WebM (240P)\" data-shorttitle=\"WebM 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.360p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"472\" data-height=\"360\" data-title=\"VP9 (360P)\" data-shorttitle=\"VP9 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/6/61/Wikimania_-_the_Wikimentary.webm/Wikimania_-_the_Wikimentary.webm.360p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"472\" data-height=\"360\" data-title=\"WebM (360P)\" data-shorttitle=\"WebM 360P\"></video></a></span><figcaption>Video of <a href=\"/wiki/Wikimania#2005\" title=\"Wikimania\">Wikimania 2005</a>—an annual conference for users of Wikipedia and other projects operated by the <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a>, was held in <a href=\"/wiki/Frankfurt_am_Main\" title=\"Frankfurt am Main\" class=\"mw-redirect\">Frankfurt am Main</a>, <a href=\"/wiki/Germany\" title=\"Germany\">Germany</a> August 4–8.</figcaption></figure>\n\n<p>Each article and each user of Wikipedia has an associated \"Talk\" page. These form the primary communication channel for editors to discuss, coordinate and debate.<span class=\"mw-ref\" id=\"cite_ref-127\"><a href=\"#cite_note-127\" style=\"counter-reset: mw-Ref 122;\"><span class=\"mw-reflink-text\">[122]</span></a></span></p>\n<figure class=\"mw-default-size mw-halign-right\"><span><a href=\"/wiki/File:Editing_Hoxne_Hoard_at_the_British_Museum.ogv\" class=\"app_media\"><video poster=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/220px--Editing_Hoxne_Hoard_at_the_British_Museum.ogv.jpg\" preload=\"none\" height=\"148\" width=\"220\" resource=\"./File:Editing_Hoxne_Hoard_at_the_British_Museum.ogv\"><source src=\"//upload.wikimedia.org/wikipedia/commons/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv\" type=\"video/ogg; codecs=&quot;theora, vorbis&quot;\" data-file-width=\"1610\" data-file-height=\"1080\" data-title=\"Original Ogg file, 1,610 × 1,080 (5.37 Mbps)\" data-shorttitle=\"Ogg source\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.120p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"178\" data-height=\"120\" data-title=\"Lowest bandwidth VP9 (120P)\" data-shorttitle=\"VP9 120P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.160p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"238\" data-height=\"160\" data-title=\"Low bandwidth WebM (160P)\" data-shorttitle=\"WebM 160P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.180p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"268\" data-height=\"180\" data-title=\"Low bandwidth VP9 (180P)\" data-shorttitle=\"VP9 180P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.240p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"358\" data-height=\"240\" data-title=\"Small VP9 (240P)\" data-shorttitle=\"VP9 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.240p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"358\" data-height=\"240\" data-title=\"Small WebM (240P)\" data-shorttitle=\"WebM 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.360p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"536\" data-height=\"360\" data-title=\"VP9 (360P)\" data-shorttitle=\"VP9 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.360p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"536\" data-height=\"360\" data-title=\"WebM (360P)\" data-shorttitle=\"WebM 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.480p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"716\" data-height=\"480\" data-title=\"SD VP9 (480P)\" data-shorttitle=\"VP9 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.480p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"716\" data-height=\"480\" data-title=\"SD WebM (480P)\" data-shorttitle=\"WebM 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.720p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1074\" data-height=\"720\" data-title=\"HD VP9 (720P)\" data-shorttitle=\"VP9 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.720p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1074\" data-height=\"720\" data-title=\"HD WebM (720P)\" data-shorttitle=\"WebM 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.1080p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1610\" data-height=\"1080\" data-title=\"Full HD VP9 (1080P)\" data-shorttitle=\"VP9 1080P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/2/27/Editing_Hoxne_Hoard_at_the_British_Museum.ogv/Editing_Hoxne_Hoard_at_the_British_Museum.ogv.1080p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1610\" data-height=\"1080\" data-title=\"Full HD WebM (1080P)\" data-shorttitle=\"WebM 1080P\"></video></a></span><figcaption>Wikipedians and <a href=\"/wiki/British_Museum\" title=\"British Museum\">British Museum</a> curators collaborate on the article <a href=\"/wiki/Hoxne_Hoard\" title=\"Hoxne Hoard\">Hoxne Hoard</a> in June 2010</figcaption></figure>\n\n<p>Wikipedia's community has been described as <a href=\"/wiki/Cult\" title=\"Cult\">cultlike</a>,<span class=\"mw-ref\" id=\"cite_ref-128\"><a href=\"#cite_note-128\" style=\"counter-reset: mw-Ref 123;\"><span class=\"mw-reflink-text\">[123]</span></a></span> although not always with entirely negative connotations.<span class=\"mw-ref\" id=\"cite_ref-129\"><a href=\"#cite_note-129\" style=\"counter-reset: mw-Ref 124;\"><span class=\"mw-reflink-text\">[124]</span></a></span> The project's preference for cohesiveness, even if it requires compromise that includes disregard of <a href=\"/wiki/Credential\" title=\"Credential\">credentials</a>, has been referred to as \"<a href=\"/wiki/Anti-elitism\" title=\"Anti-elitism\" class=\"mw-redirect\">anti-elitism</a>\".<span class=\"mw-ref\" id=\"cite_ref-130\"><a href=\"#cite_note-130\" style=\"counter-reset: mw-Ref 125;\"><span class=\"mw-reflink-text\">[125]</span></a></span></p>\n\n<p>Wikipedians sometimes award one another <a href=\"/wiki/Wikipedia:Barnstars\" title=\"Wikipedia:Barnstars\">virtual barnstars</a> for good work. These personalized tokens of appreciation reveal a wide range of valued work extending far beyond simple editing to include social support, administrative actions, and types of articulation work.<span class=\"mw-ref\" id=\"cite_ref-131\"><a href=\"#cite_note-131\" style=\"counter-reset: mw-Ref 126;\"><span class=\"mw-reflink-text\">[126]</span></a></span></p>\n\n<p>Wikipedia does not require that its editors and contributors provide identification.<span class=\"mw-ref\" id=\"cite_ref-user_identification_132-0\"><a href=\"#cite_note-user_identification-132\" style=\"counter-reset: mw-Ref 127;\"><span class=\"mw-reflink-text\">[127]</span></a></span> As Wikipedia grew, \"Who writes Wikipedia?\" became one of the questions frequently asked on the project.<span class=\"mw-ref\" id=\"cite_ref-133\"><a href=\"#cite_note-133\" style=\"counter-reset: mw-Ref 128;\"><span class=\"mw-reflink-text\">[128]</span></a></span> Jimmy Wales once argued that only \"a community<span>&nbsp;</span>... a dedicated group of a few hundred volunteers\" makes the bulk of contributions to Wikipedia and that the project is therefore \"much like any traditional organization\".<span class=\"mw-ref\" id=\"cite_ref-blodget_134-0\"><a href=\"#cite_note-blodget-134\" style=\"counter-reset: mw-Ref 129;\"><span class=\"mw-reflink-text\">[129]</span></a></span> In 2008, a <i>Slate</i> magazine article reported that: \"According to researchers in Palo Alto, one percent of Wikipedia users are responsible for about half of the site's edits.\"<span class=\"mw-ref\" id=\"cite_ref-135\"><a href=\"#cite_note-135\" style=\"counter-reset: mw-Ref 130;\"><span class=\"mw-reflink-text\">[130]</span></a></span> This method of evaluating contributions was later disputed by <a href=\"/wiki/Aaron_Swartz\" title=\"Aaron Swartz\">Aaron Swartz</a>, who noted that several articles he sampled had large portions of their content (measured by number of characters) contributed by users with low edit counts.<span class=\"mw-ref\" id=\"cite_ref-136\"><a href=\"#cite_note-136\" style=\"counter-reset: mw-Ref 131;\"><span class=\"mw-reflink-text\">[131]</span></a></span>\n\n</p>\n\n<p>The English Wikipedia has <a href=\"/wiki/Special:Statistics\" title=\"Special:Statistics\">6,058,659</a> articles, <a href=\"/wiki/Special:ActiveUsers\" title=\"Special:ActiveUsers\">38,788,676</a> registered editors, and <a href=\"/wiki/Special:ActiveUsers\" title=\"Special:ActiveUsers\">132,979</a> active editors. An editor is considered active if they have made one or more edits in the past 30 days.</p>\n\n<p>Editors who fail to comply with Wikipedia cultural rituals, such as <a href=\"/wiki/Wikipedia:SIG\" title=\"Wikipedia:SIG\" class=\"mw-redirect\">signing talk page comments</a>, may implicitly signal that they are Wikipedia outsiders, increasing the odds that Wikipedia insiders may target or discount their contributions. Becoming a Wikipedia insider involves non-trivial costs: the contributor is expected to learn Wikipedia-specific technological codes, submit to a sometimes convoluted dispute resolution process, and learn a \"baffling culture rich with in-jokes and insider references\".<span class=\"mw-ref\" id=\"cite_ref-labor_squeeze_on_WP_1_137-0\"><a href=\"#cite_note-labor_squeeze_on_WP_1-137\" style=\"counter-reset: mw-Ref 132;\"><span class=\"mw-reflink-text\">[132]</span></a></span> Editors who do not log in are in some sense second-class citizens on Wikipedia,<span class=\"mw-ref\" id=\"cite_ref-labor_squeeze_on_WP_1_137-1\"><a href=\"#cite_note-labor_squeeze_on_WP_1-137\" style=\"counter-reset: mw-Ref 132;\"><span class=\"mw-reflink-text\">[132]</span></a></span> as \"participants are accredited by members of the wiki community, who have a vested interest in preserving the quality of the work product, on the basis of their ongoing participation\",<span class=\"mw-ref\" id=\"cite_ref-legal_edu_and_WP_1_138-0\"><a href=\"#cite_note-legal_edu_and_WP_1-138\" style=\"counter-reset: mw-Ref 133;\"><span class=\"mw-reflink-text\">[133]</span></a></span> but the contribution histories of anonymous unregistered editors recognized only by their <a href=\"/wiki/IP_address\" title=\"IP address\">IP addresses</a> cannot be attributed to a particular editor with certainty.</p>\n\n","toclevel":1,"line":"Community","anchor":"Community"},{"id":17,"text":"\n\n<p>A 2007 study by researchers from <a href=\"/wiki/Dartmouth_College\" title=\"Dartmouth College\">Dartmouth College</a> found that \"anonymous and infrequent contributors to Wikipedia [...] are as reliable a source of knowledge as those contributors who register with the site\".<span class=\"mw-ref\" id=\"cite_ref-sciam_good_samaritans_1_139-0\"><a href=\"#cite_note-sciam_good_samaritans_1-139\" style=\"counter-reset: mw-Ref 134;\"><span class=\"mw-reflink-text\">[134]</span></a></span> Jimmy Wales stated in 2009 that \"[I]t turns out over 50% of all the edits are done by just .7% of the users<span class=\"nowrap\"><span>&nbsp;</span></span>... 524 people<span class=\"nowrap\"><span>&nbsp;</span></span>... And in fact, the most active 2%, which is 1400 people, have done 73.4% of all the edits.\"<span class=\"mw-ref\" id=\"cite_ref-blodget_134-1\"><a href=\"#cite_note-blodget-134\" style=\"counter-reset: mw-Ref 129;\"><span class=\"mw-reflink-text\">[129]</span></a></span> However, <i><a href=\"/wiki/Business_Insider\" title=\"Business Insider\">Business Insider</a></i> editor and journalist <a href=\"/wiki/Henry_Blodget\" title=\"Henry Blodget\">Henry Blodget</a> showed in 2009 that in a random sample of articles, most content in Wikipedia (measured by the amount of contributed text that survives to the latest sampled edit) is created by \"outsiders\", while most editing and formatting is done by \"insiders\".<span class=\"mw-ref\" id=\"cite_ref-blodget_134-2\"><a href=\"#cite_note-blodget-134\" style=\"counter-reset: mw-Ref 129;\"><span class=\"mw-reflink-text\">[129]</span></a></span></p>\n\n<p>A 2008 study found that Wikipedians were less agreeable, open, and conscientious than others,<span class=\"mw-ref\" id=\"cite_ref-liebertonline_view_on_WP_users_1_140-0\"><a href=\"#cite_note-liebertonline_view_on_WP_users_1-140\" style=\"counter-reset: mw-Ref 135;\"><span class=\"mw-reflink-text\">[135]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-newscientist_view_on_WP_users_1_141-0\"><a href=\"#cite_note-newscientist_view_on_WP_users_1-141\" style=\"counter-reset: mw-Ref 136;\"><span class=\"mw-reflink-text\">[136]</span></a></span> although a later commentary pointed out serious flaws, including that the data showed higher openness and that the differences with the control group and the samples were small.<span class=\"mw-ref\" id=\"cite_ref-142\"><a href=\"#cite_note-142\" style=\"counter-reset: mw-Ref 137;\"><span class=\"mw-reflink-text\">[137]</span></a></span> According to a 2009 study, there is \"evidence of growing resistance from the Wikipedia community to new content\".<span class=\"mw-ref\" id=\"cite_ref-newscientist_WP_boom_to_bust_1_143-0\"><a href=\"#cite_note-newscientist_WP_boom_to_bust_1-143\" style=\"counter-reset: mw-Ref 138;\"><span class=\"mw-reflink-text\">[138]</span></a></span></p>\n\n","toclevel":2,"line":"Studies","anchor":"Studies"},{"id":18,"text":"\n\n<p>Several studies have shown that most of the Wikipedia contributors are male. Notably, the results of a Wikimedia Foundation survey in 2008 showed that only 13 percent of Wikipedia editors were female.<span class=\"mw-ref\" id=\"cite_ref-144\"><a href=\"#cite_note-144\" style=\"counter-reset: mw-Ref 139;\"><span class=\"mw-reflink-text\">[139]</span></a></span> Because of this, universities throughout the United States tried to encourage females to become Wikipedia contributors. Similarly, many of these universities, including <a href=\"/wiki/Yale\" title=\"Yale\" class=\"mw-redirect\">Yale</a> and <a href=\"/wiki/Brown_University\" title=\"Brown University\">Brown</a>, gave college credit to students who create or edit an article relating to women in science or technology.<span class=\"mw-ref\" id=\"cite_ref-145\"><a href=\"#cite_note-145\" style=\"counter-reset: mw-Ref 140;\"><span class=\"mw-reflink-text\">[140]</span></a></span> <a href=\"/wiki/Andrew_Lih\" title=\"Andrew Lih\">Andrew Lih</a>, a professor and scientist, wrote in <i><a href=\"/wiki/The_New_York_Times\" title=\"The New York Times\">The New York Times</a></i> that the reason he thought the number of male contributors outnumbered the number of females so greatly was because identifying as a woman may expose oneself to \"ugly, intimidating behavior\".<span class=\"mw-ref\" id=\"cite_ref-146\"><a href=\"#cite_note-146\" style=\"counter-reset: mw-Ref 141;\"><span class=\"mw-reflink-text\">[141]</span></a></span> Data has shown that <a href=\"/wiki/Africa\" title=\"Africa\">Africans</a> are underrepresented among Wikipedia editors.<span class=\"mw-ref\" id=\"cite_ref-memeb_147-0\"><a href=\"#cite_note-memeb-147\" style=\"counter-reset: mw-Ref 142;\"><span class=\"mw-reflink-text\">[142]</span></a></span></p>\n\n","toclevel":2,"line":"Diversity","anchor":"Diversity"},{"id":19,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt967\">Main article: <a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">List of Wikipedias</a></div>\n\n<p>There are currently 309 language editions of Wikipedia (also called <i>language versions</i>, or simply <i>Wikipedias</i>). As of <span>April</span> <span>2020</span>, the six largest, in order of article count, are the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English</a>, <a href=\"/wiki/Cebuano_Wikipedia\" title=\"Cebuano Wikipedia\" class=\"mw-redirect\">Cebuano</a>, <a href=\"/wiki/Swedish_Wikipedia\" title=\"Swedish Wikipedia\">Swedish</a>, <a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German</a>, <a href=\"/wiki/French_Wikipedia\" title=\"French Wikipedia\">French</a>, and <a href=\"/wiki/Dutch_Wikipedia\" title=\"Dutch Wikipedia\">Dutch</a> Wikipedias.<span class=\"mw-ref\" id=\"cite_ref-WP_list_of_WPs_by_article_1_148-0\"><a href=\"#cite_note-WP_list_of_WPs_by_article_1-148\" style=\"counter-reset: mw-Ref 143;\"><span class=\"mw-reflink-text\">[143]</span></a></span> The second and third largest Wikipedias owe their position to the article-creating <a href=\"/wiki/Internet_bot\" title=\"Internet bot\">bot</a> <a href=\"/wiki/Lsjbot\" title=\"Lsjbot\">Lsjbot</a>, which as of 2013 had created about half the articles in the <a href=\"/wiki/Swedish_Wikipedia\" title=\"Swedish Wikipedia\">Swedish Wikipedia</a>, and most of the articles in the <a href=\"/wiki/Cebuano_language\" title=\"Cebuano language\">Cebuano</a> and <a href=\"/wiki/Waray_Wikipedia\" title=\"Waray Wikipedia\">Waray Wikipedias</a>. The latter are both languages of the Philippines.</p>\n\n<p>In addition to the top six, eleven other Wikipedias have more than a million articles each (<a href=\"/wiki/Russian_Wikipedia\" title=\"Russian Wikipedia\">Russian</a>, <a href=\"/wiki/Italian_Wikipedia\" title=\"Italian Wikipedia\">Italian</a>, <a href=\"/wiki/Spanish_Wikipedia\" title=\"Spanish Wikipedia\">Spanish</a>, <a href=\"/wiki/Polish_Wikipedia\" title=\"Polish Wikipedia\">Polish</a>, <a href=\"/wiki/Waray-Waray_Wikipedia\" title=\"Waray-Waray Wikipedia\" class=\"mw-redirect\">Waray-Waray</a>, <a href=\"/wiki/Vietnamese_Wikipedia\" title=\"Vietnamese Wikipedia\">Vietnamese</a>, <a href=\"/wiki/Japanese_Wikipedia\" title=\"Japanese Wikipedia\">Japanese</a>, <a href=\"/wiki/Chinese_Wikipedia\" title=\"Chinese Wikipedia\">Chinese</a>, <a href=\"/wiki/Arabic_Wikipedia\" title=\"Arabic Wikipedia\">Arabic</a>, <a href=\"/wiki/Portuguese_Wikipedia\" title=\"Portuguese Wikipedia\">Portuguese</a> and <a href=\"/wiki/Ukrainian_Wikipedia\" title=\"Ukrainian Wikipedia\">Ukrainian</a>), five more have over 500,000 articles (<a href=\"/wiki/Persian_Wikipedia\" title=\"Persian Wikipedia\">Persian</a>, <a href=\"/wiki/Catalan_Wikipedia\" title=\"Catalan Wikipedia\">Catalan</a>, <a href=\"/wiki/Serbian_Wikipedia\" title=\"Serbian Wikipedia\">Serbian</a>, <a href=\"/wiki/Bokmål_Wikipedia\" title=\"Bokmål Wikipedia\" class=\"mw-redirect\">Bokmål</a> and <a href=\"/wiki/Indonesian_Wikipedia\" title=\"Indonesian Wikipedia\">Indonesian</a>), 42 more have over 100,000, and 84 more have over 10,000.<span class=\"mw-ref\" id=\"cite_ref-ListOfWikipedias_149-0\"><a href=\"#cite_note-ListOfWikipedias-149\" style=\"counter-reset: mw-Ref 144;\"><span class=\"mw-reflink-text\">[144]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-WP_list_of_WPs_1_150-0\"><a href=\"#cite_note-WP_list_of_WPs_1-150\" style=\"counter-reset: mw-Ref 145;\"><span class=\"mw-reflink-text\">[145]</span></a></span> The largest, the English Wikipedia, has over <span>6</span> million articles. <span>As of January</span><span>&nbsp;</span><span>2019</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>, according to Alexa, the English <a href=\"/wiki/Subdomain\" title=\"Subdomain\">subdomain</a> (en.wikipedia.org; English Wikipedia) receives approximately 57% of Wikipedia's cumulative traffic, with the remaining split among the other languages (Russian: 9%; Chinese: 6%; Japanese: 6%; Spanish: 5%).<span class=\"mw-ref\" id=\"cite_ref-Alexa_siteinfo_11-2\"><a href=\"#cite_note-Alexa_siteinfo-11\" style=\"counter-reset: mw-Ref 9;\"><span class=\"mw-reflink-text\">[9]</span></a></span></p>\n\n<div class=\"PieChartTemplate thumb tright\" style=\"\" about=\"#mwt998\"><div class=\"thumbinner\" style=\"width:202px\">\n<div style=\"background-color:white;margin:auto;position:relative;width:200px;height:200px;overflow:hidden;border-radius:100px;border:1px solid black\">\n<div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:90.748442454112px 42.008572841181px 0 0;\nborder-top-color:#00FFFF\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#00FFFF\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:85.099448179469px 52.51746299613px 0 0;\nborder-top-color:#483D8B\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#483D8B\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:78.239081057659px 62.278778048811px 0 0;\nborder-top-color:#FFA500\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#FFA500\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:69.816541899347px 71.593648302183px 0 0;\nborder-top-color:#167432\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#167432\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:59.790498305752px 80.156698487088px 0 0;\nborder-top-color:#FF82AA\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#FF82AA\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:47.623820366794px 87.931631019056px 0 0;\nborder-top-color:#A60D14\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#A60D14\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:33.873792024529px 94.088076895423px 0 0;\nborder-top-color:#9A459A\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#9A459A\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:19.354946805086px 98.109051744333px 0 0;\nborder-top-color:#333333\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#333333\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:100px;\nborder-width:3.1410759078128px 99.950656036573px 0 0;\nborder-top-color:#33CC99\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;left:0;top:0;border-width:0 200px 100px 0;border-color:#33CC99\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 631.37515146751px 100px 0;\nborder-right-color:#CC79A7\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#CC79A7\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 277.7606853915px 100px 0;\nborder-right-color:#D55E00\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#D55E00\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 166.69143794028px 100px 0;\nborder-right-color:#0072B2\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#0072B2\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 101.26459941541px 100px 0;\nborder-right-color:#F0E442\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#F0E442\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 58.2948895253px 100px 0;\nborder-right-color:#009E73\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#009E73\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;right:100px;\ntop:0;\nborder-width:0 24.340394514934px 100px 0;\nborder-right-color:#56B4E9\n\"></div>\n<div style=\"position:absolute;line-height:0;border-style:solid;right:0;top:0;border-width:0 100px 100px 0;border-color:#56B4E9\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;left:100px;\ntop:2.1419095674528px;\nborder-width:0 0 97.858090432547px 20.586260876988px;\nborder-bottom-color:#E69F00\n\"></div><div style=\"border:solid transparent;position:absolute;width:100px;line-height:0;left:100px;\ntop:33.868813467635px;\nborder-width:0 0 66.131186532365px 75.011106963046px;\nborder-bottom-color:#666666\n\"></div>\n</div>\n<div class=\"thumbcaption\">\n<p><b>Distribution of the 52,879,445 articles in different language editions (as of April 16, 2020)</b><span class=\"mw-ref\" id=\"cite_ref-meta.wikimedia_151-0\"><a href=\"#cite_note-meta.wikimedia-151\" style=\"counter-reset: mw-Ref 146;\"><span class=\"mw-reflink-text\">[146]</span></a></span></p>\n<div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#666666; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English</a> (11.5%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#E69F00; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Cebuano_Wikipedia\" title=\"Cebuano Wikipedia\" class=\"mw-redirect\">Cebuano</a> (10.2%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#56B4E9; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Swedish_Wikipedia\" title=\"Swedish Wikipedia\">Swedish</a> (7.1%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#009E73; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German</a> (4.6%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#F0E442; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/French_Wikipedia\" title=\"French Wikipedia\">French</a> (4.2%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#0072B2; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Dutch_Wikipedia\" title=\"Dutch Wikipedia\">Dutch</a> (3.8%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#D55E00; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Russian_Wikipedia\" title=\"Russian Wikipedia\">Russian</a> (3.1%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#CC79A7; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Italian_Wikipedia\" title=\"Italian Wikipedia\">Italian</a> (3%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#33CC99; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Spanish_Wikipedia\" title=\"Spanish Wikipedia\">Spanish</a> (3%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#333333; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Polish_Wikipedia\" title=\"Polish Wikipedia\">Polish</a> (2.6%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#9A459A; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Waray_Wikipedia\" title=\"Waray Wikipedia\">Waray</a> (2.4%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#A60D14; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Vietnamese_Wikipedia\" title=\"Vietnamese Wikipedia\">Vietnamese</a> (2.4%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#FF82AA; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Japanese_Wikipedia\" title=\"Japanese Wikipedia\">Japanese</a> (2.3%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#167432; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Chinese_Wikipedia\" title=\"Chinese Wikipedia\">Chinese</a> (2.1%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#FFA500; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Arabic_Wikipedia\" title=\"Arabic Wikipedia\">Arabic</a> (2%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#483D8B; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Portuguese_Wikipedia\" title=\"Portuguese Wikipedia\">Portuguese</a> (1.9%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:\n#00FFFF; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span><a href=\"/wiki/Ukrainian_Wikipedia\" title=\"Ukrainian Wikipedia\">Ukrainian</a> (1.9%)</div><div class=\"legend\" style=\"-webkit-column-break-inside: avoid;page-break-inside: avoid;break-inside: avoid-column\"><span class=\"legend-color\" style=\"display:inline-block; width:1.5em; height:1.5em; margin:1px 0; border:1px solid black; background-color:white; color:black; font-size:100%; text-align:center;\"><span>&nbsp;</span></span><span>&nbsp;</span>Other (31.9%)</div>\n</div>\n</div></div>\n<span>\n</span><table width=\"300px\">\n<caption><b>Logarithmic graph of the 20 largest language editions of Wikipedia</b> <br>\n(as of 16 April 2020)<span class=\"mw-ref\" id=\"cite_ref-152\"><a href=\"#cite_note-152\" style=\"counter-reset: mw-Ref 147;\"><span class=\"mw-reflink-text\">[147]</span></a></span> <br>\n(millions of articles)</caption>\n<tbody><tr style=\"text-align:center;border-style:solid; border-color:black; border-width=1px;\">\n<td colspan=\"2\" style=\"border-right:solid black 1px;\">0.1</td>\n<td colspan=\"2\" style=\"border-right:solid black 1px;\">0.3</td>\n<td colspan=\"2\" style=\"border-right:solid black 1px;\">1</td>\n<td colspan=\"2\" style=\"border-right:solid black 1px;\">3</td></tr>\n<tr>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"></td>\n<td width=\"12.5%\" style=\"border-right:solid black 1px;\"><br></td></tr>\n<tr>\n<td colspan=\"8\">\n<table style=\"text-align:left;\">\n<tbody>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:595.2565448239px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English</a> 6,058,659 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:579.74635246503px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Cebuano_Wikipedia\" title=\"Cebuano Wikipedia\" class=\"mw-redirect\">Cebuano</a> 5,378,682 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:532.17630985658px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Swedish_Wikipedia\" title=\"Swedish Wikipedia\">Swedish</a> 3,733,439 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:475.65438694075px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German</a> 2,419,372 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:463.3020168419px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/French_Wikipedia\" title=\"French Wikipedia\">French</a> 2,200,534 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:451.17991940269px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Dutch_Wikipedia\" title=\"Dutch Wikipedia\">Dutch</a> 2,005,031 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:422.85683989089px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Russian_Wikipedia\" title=\"Russian Wikipedia\">Russian</a> 1,613,284 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:421.54322480265px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Italian_Wikipedia\" title=\"Italian Wikipedia\">Italian</a> 1,597,100 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:420.95945145884px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Spanish_Wikipedia\" title=\"Spanish Wikipedia\">Spanish</a> 1,589,960 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:404.50032512487px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Polish_Wikipedia\" title=\"Polish Wikipedia\">Polish</a> 1,401,272 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:391.08317459801px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Waray_Wikipedia\" title=\"Waray Wikipedia\">Waray</a> 1,264,150 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:388.91605761545px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Vietnamese_Wikipedia\" title=\"Vietnamese Wikipedia\">Vietnamese</a> 1,243,297 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:384.2576786712px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Japanese_Wikipedia\" title=\"Japanese Wikipedia\">Japanese</a> 1,199,629 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:374.23775465541px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Chinese_Wikipedia\" title=\"Chinese Wikipedia\">Chinese</a> 1,110,829 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:365.4642875714px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Arabic_Wikipedia\" title=\"Arabic Wikipedia\">Arabic</a> 1,038,490 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:364.16978616944px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Portuguese_Wikipedia\" title=\"Portuguese Wikipedia\">Portuguese</a> 1,028,223 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:361.39859875474px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Ukrainian_Wikipedia\" title=\"Ukrainian Wikipedia\">Ukrainian</a> 1,006,584 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:317.48032737151px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Persian_Wikipedia\" title=\"Persian Wikipedia\">Persian</a> 718,548 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:303.05915072862px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Catalan_Wikipedia\" title=\"Catalan Wikipedia\">Catalan</a> 643,258 </div>\n</td></tr>\n<tr><td> <div style=\"background-color:rgb(200,200,200); width:300.85289300386px; height:20px; padding-left:1em; text-align:center;\"><a href=\"/wiki/Serbian_Wikipedia\" title=\"Serbian Wikipedia\">Serbian</a> 632,457 </div>\n</td></tr>\n</tbody></table></td></tr>\n</tbody></table><span>\n\n</span><p about=\"#mwt1002\"><b>The unit for the numbers in bars is articles.</b></p>\n<figure class=\"mw-default-size mw-halign-right\"><a href=\"/wiki/File:TurkishWikipedia_block_pageviews_february-may2017.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/6c/TurkishWikipedia_block_pageviews_february-may2017.png/220px-TurkishWikipedia_block_pageviews_february-may2017.png\" data-file-width=\"1218\" data-file-height=\"669\" data-file-type=\"bitmap\" height=\"121\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/6c/TurkishWikipedia_block_pageviews_february-may2017.png/440px-TurkishWikipedia_block_pageviews_february-may2017.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/6/6c/TurkishWikipedia_block_pageviews_february-may2017.png/330px-TurkishWikipedia_block_pageviews_february-may2017.png 1.5x\"></a><figcaption>A graph for pageviews of <a href=\"/wiki/Turkish_Wikipedia\" title=\"Turkish Wikipedia\">Turkish Wikipedia</a> shows a large drop of roughly 80% immediately after the <a href=\"/wiki/Block_of_Wikipedia_in_Turkey\" title=\"Block of Wikipedia in Turkey\">block of Wikipedia in Turkey</a> was imposed in 2017.</figcaption></figure>\n\n<p>Since Wikipedia is based on the <a href=\"/wiki/World_Wide_Web\" title=\"World Wide Web\">Web</a> and therefore worldwide, contributors to the same language edition may use different dialects or may come from different countries (as is the case for the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English edition</a>). These differences may lead to some conflicts over <a href=\"/wiki/American_and_British_English_spelling_differences\" title=\"American and British English spelling differences\">spelling differences</a> (e.g. <i>colour</i> versus <i><a href=\"/wiki/Color\" title=\"Color\">color</a></i>)<span class=\"mw-ref\" id=\"cite_ref-WP_spelling_MOS_1_153-0\"><a href=\"#cite_note-WP_spelling_MOS_1-153\" style=\"counter-reset: mw-Ref 148;\"><span class=\"mw-reflink-text\">[148]</span></a></span> or points of view.<span class=\"mw-ref\" id=\"cite_ref-WP_countering_bias_1_154-0\"><a href=\"#cite_note-WP_countering_bias_1-154\" style=\"counter-reset: mw-Ref 149;\"><span class=\"mw-reflink-text\">[149]</span></a></span></p>\n\n<p>Though the various language editions are held to global policies such as \"neutral point of view\", they diverge on some points of policy and practice, most notably on whether images that are not <a href=\"/wiki/Free_content\" title=\"Free content\">licensed freely</a> may be used under a claim of <a href=\"/wiki/Fair_use\" title=\"Fair use\">fair use</a>.<span class=\"mw-ref\" id=\"cite_ref-WP_meta_fair_use_1_155-0\"><a href=\"#cite_note-WP_meta_fair_use_1-155\" style=\"counter-reset: mw-Ref 150;\"><span class=\"mw-reflink-text\">[150]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-WP_meta_WP_images_1_156-0\"><a href=\"#cite_note-WP_meta_WP_images_1-156\" style=\"counter-reset: mw-Ref 151;\"><span class=\"mw-reflink-text\">[151]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-IBM_visual_WP_1_157-0\"><a href=\"#cite_note-IBM_visual_WP_1-157\" style=\"counter-reset: mw-Ref 152;\"><span class=\"mw-reflink-text\">[152]</span></a></span></p>\n\n<p>Jimmy Wales has described Wikipedia as \"an effort to create and distribute a free encyclopedia of the highest possible quality to every single person on the planet in their own language\".<span class=\"mw-ref\" id=\"cite_ref-WP_Wales_free_multi-lingual_encyclopedia_158-0\"><a href=\"#cite_note-WP_Wales_free_multi-lingual_encyclopedia-158\" style=\"counter-reset: mw-Ref 153;\"><span class=\"mw-reflink-text\">[153]</span></a></span> Though each language edition functions more or less independently, some efforts are made to supervise them all. They are coordinated in part by Meta-Wiki, the Wikimedia Foundation's wiki devoted to maintaining all its projects (Wikipedia and others).<span class=\"mw-ref\" id=\"cite_ref-WP_metawiki_maintenance_1_159-0\"><a href=\"#cite_note-WP_metawiki_maintenance_1-159\" style=\"counter-reset: mw-Ref 154;\"><span class=\"mw-reflink-text\">[154]</span></a></span> For instance, Meta-Wiki provides important statistics on all language editions of Wikipedia,<span class=\"mw-ref\" id=\"cite_ref-WP_meta_stats_1_160-0\"><a href=\"#cite_note-WP_meta_stats_1-160\" style=\"counter-reset: mw-Ref 155;\"><span class=\"mw-reflink-text\">[155]</span></a></span> and it maintains a list of articles every Wikipedia should have.<span class=\"mw-ref\" id=\"cite_ref-WP_meta_articles_on_all_sites_1_161-0\"><a href=\"#cite_note-WP_meta_articles_on_all_sites_1-161\" style=\"counter-reset: mw-Ref 156;\"><span class=\"mw-reflink-text\">[156]</span></a></span> The list concerns basic content by subject: biography, history, geography, society, culture, science, technology, and mathematics. It is not rare for articles strongly related to a particular language not to have counterparts in another edition. For example, articles about small towns in the United States might be available only in English, even when they meet notability criteria of other language Wikipedia projects.</p>\n<figure class=\"mw-default-size mw-halign-left\"><a href=\"/wiki/File:User_-_demography.svg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/20/User_-_demography.svg/500px-User_-_demography.svg.png\" data-file-width=\"700\" data-file-height=\"420\" data-file-type=\"drawing\" height=\"300\" width=\"500\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/20/User_-_demography.svg/1000px-User_-_demography.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/20/User_-_demography.svg/750px-User_-_demography.svg.png 1.5x\"></a><figcaption>Estimation of contributions shares from different regions in the world to different Wikipedia editions</figcaption></figure>\n\n<p>Translated articles represent only a small portion of articles in most editions, in part because those editions do not allow fully automated translation of articles.<span class=\"mw-ref\" id=\"cite_ref-WP_auto-translations_rules_1_162-0\"><a href=\"#cite_note-WP_auto-translations_rules_1-162\" style=\"counter-reset: mw-Ref 157;\"><span class=\"mw-reflink-text\">[157]</span></a></span> Articles available in more than one language may offer \"<a href=\"/wiki/Interwiki_links\" title=\"Interwiki links\">interwiki links</a>\", which link to the counterpart articles in other editions.</p>\n\n<p>A study published by <i><a href=\"/wiki/PLoS_ONE\" title=\"PLoS ONE\" class=\"mw-redirect\">PLoS ONE</a></i> in 2012 also estimated the share of contributions to different editions of Wikipedia from different regions of the world. It reported that the proportion of the edits made from <a href=\"/wiki/North_America\" title=\"North America\">North America</a> was 51% for the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia</a>, and 25% for the <a href=\"/wiki/Simple_English_Wikipedia\" title=\"Simple English Wikipedia\">simple English Wikipedia</a>.<span class=\"mw-ref\" id=\"cite_ref-163\"><a href=\"#cite_note-163\" style=\"counter-reset: mw-Ref 158;\"><span class=\"mw-reflink-text\">[158]</span></a></span> The Wikimedia Foundation hopes to increase the number of editors in the Global South to 37% by 2015.<span class=\"mw-ref\" id=\"cite_ref-WP_global_south_demographic_increase_plan_1_164-0\"><a href=\"#cite_note-WP_global_south_demographic_increase_plan_1-164\" style=\"counter-reset: mw-Ref 159;\"><span class=\"mw-reflink-text\">[159]</span></a></span></p>\n\n","toclevel":1,"line":"Language editions","anchor":"Language_editions"},{"id":20,"text":"\n\n<p>On March 1, 2014, <i><a href=\"/wiki/The_Economist\" title=\"The Economist\">The Economist</a></i>, in an article titled \"The Future of Wikipedia\", cited a trend analysis concerning data published by Wikimedia stating that \"[t]he number of editors for the English-language version has fallen by a third in seven years.\"<span class=\"mw-ref\" id=\"cite_ref-economist1_165-0\"><a href=\"#cite_note-economist1-165\" style=\"counter-reset: mw-Ref 160;\"><span class=\"mw-reflink-text\">[160]</span></a></span> The attrition rate for active editors in English Wikipedia was cited by <i>The Economist</i> as substantially in contrast to statistics for Wikipedia in other languages (non-English Wikipedia). <i>The Economist</i> reported that the number of contributors with an average of five or more edits per month was relatively constant since 2008 for Wikipedia in other languages at approximately 42,000 editors within narrow seasonal variances of about 2,000 editors up or down. The number of active editors in English Wikipedia, by sharp comparison, was cited as peaking in 2007 at approximately 50,000 and dropping to 30,000 by the start of 2014.</p>\n\n<p>Should attrition continue unabated at the quoted trend rate of approximately 20,000 editors lost within a seven-year stretch, by 2021 there will be only 10,000 active editors on English Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-economist1_165-1\"><a href=\"#cite_note-economist1-165\" style=\"counter-reset: mw-Ref 160;\"><span class=\"mw-reflink-text\">[160]</span></a></span> In contrast, the trend analysis published in <i>The Economist</i> presents Wikipedia in other languages (non-English Wikipedia) as successful in retaining their active editors on a renewable and sustained basis, with their numbers remaining relatively constant at approximately 42,000.<span class=\"mw-ref\" id=\"cite_ref-economist1_165-2\"><a href=\"#cite_note-economist1-165\" style=\"counter-reset: mw-Ref 160;\"><span class=\"mw-reflink-text\">[160]</span></a></span> No comment was made concerning which of the differentiated edit policy standards from Wikipedia in other languages (non-English Wikipedia) would provide a possible alternative to English Wikipedia for effectively ameliorating substantial editor attrition rates on the English-language Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-166\"><a href=\"#cite_note-166\" style=\"counter-reset: mw-Ref 161;\"><span class=\"mw-reflink-text\">[161]</span></a></span></p>\n\n","toclevel":2,"line":"English Wikipedia editor decline","anchor":"English_Wikipedia_editor_decline"},{"id":21,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1106\">See also: <a href=\"/wiki/Academic_studies_about_Wikipedia\" title=\"Academic studies about Wikipedia\">Academic studies about Wikipedia</a> and <a href=\"/wiki/Criticism_of_Wikipedia\" title=\"Criticism of Wikipedia\">Criticism of Wikipedia</a></div>\n<table class=\"box-Update plainlinks metadata ambox ambox-content ambox-Update\" role=\"presentation\"><tbody><tr><td class=\"mbox-image\"><div style=\"width:52px\"><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/42px-Ambox_current_red.svg.png\" data-file-width=\"360\" data-file-height=\"290\" data-file-type=\"drawing\" height=\"34\" width=\"42\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/84px-Ambox_current_red.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/63px-Ambox_current_red.svg.png 1.5x\"></span></figure-inline></div></td><td class=\"mbox-text\"><div class=\"mbox-text-span\">This section needs to be <b>updated</b>.  <small class=\"date-container\"><i>(<span class=\"date\">March 2018</span>)</i></small></div></td></tr></tbody></table>\n\n<p>Various Wikipedians have <a href=\"/wiki/Criticism_of_Wikipedia#Excessive_regulation\" title=\"Criticism of Wikipedia\">criticized Wikipedia's large and growing regulation</a>, which includes more than fifty policies and nearly 150,000 words <span>as of 2014</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>.<span class=\"mw-ref\" id=\"cite_ref-bureaucracy_167-0\"><a href=\"#cite_note-bureaucracy-167\" style=\"counter-reset: mw-Ref 162;\"><span class=\"mw-reflink-text\">[162]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-168\"><a href=\"#cite_note-168\" style=\"counter-reset: mw-Ref 163;\"><span class=\"mw-reflink-text\">[163]</span></a></span></p>\n\n<p>Critics have stated that Wikipedia exhibits <a href=\"/wiki/Systemic_bias\" title=\"Systemic bias\">systemic bias</a>. In 2010, columnist and journalist <a href=\"/wiki/Edwin_Black\" title=\"Edwin Black\">Edwin Black</a> criticized Wikipedia for being a mixture of \"truth, half-truth, and some falsehoods\".<span class=\"mw-ref\" id=\"cite_ref-EdwinBlack_27-1\"><a href=\"#cite_note-EdwinBlack-27\" style=\"counter-reset: mw-Ref 25;\"><span class=\"mw-reflink-text\">[25]</span></a></span> Articles in <i><a href=\"/wiki/The_Chronicle_of_Higher_Education\" title=\"The Chronicle of Higher Education\">The Chronicle of Higher Education</a></i> and <i><a href=\"/wiki/The_Journal_of_Academic_Librarianship\" title=\"The Journal of Academic Librarianship\">The Journal of Academic Librarianship</a></i> have criticized Wikipedia's <a href=\"/wiki/Wikipedia:Undue\" title=\"Wikipedia:Undue\" class=\"mw-redirect\">Undue Weight</a> policy, concluding that the fact that Wikipedia explicitly is not designed to provide correct information about a subject, but rather focus on all the major viewpoints on the subject, give less attention to minor ones, and creates omissions that can lead to false beliefs based on incomplete information.<span class=\"mw-ref\" id=\"cite_ref-169\"><a href=\"#cite_note-169\" style=\"counter-reset: mw-Ref 164;\"><span class=\"mw-reflink-text\">[164]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-170\"><a href=\"#cite_note-170\" style=\"counter-reset: mw-Ref 165;\"><span class=\"mw-reflink-text\">[165]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-171\"><a href=\"#cite_note-171\" style=\"counter-reset: mw-Ref 166;\"><span class=\"mw-reflink-text\">[166]</span></a></span></p>\n\n<p>Journalists <a href=\"/wiki/Oliver_Kamm\" title=\"Oliver Kamm\">Oliver Kamm</a> and <a href=\"/wiki/Edwin_Black\" title=\"Edwin Black\">Edwin Black</a> noted (in 2010 and 2011 respectively) how articles are dominated by the loudest and most persistent voices, usually by a group with an \"ax to grind\" on the topic.<span class=\"mw-ref\" id=\"cite_ref-EdwinBlack_27-2\"><a href=\"#cite_note-EdwinBlack-27\" style=\"counter-reset: mw-Ref 25;\"><span class=\"mw-reflink-text\">[25]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-okw_172-0\"><a href=\"#cite_note-okw-172\" style=\"counter-reset: mw-Ref 167;\"><span class=\"mw-reflink-text\">[167]</span></a></span> A 2008 article in <i><a href=\"/wiki/Education_Next\" title=\"Education Next\" class=\"mw-redirect\">Education Next</a></i> Journal concluded that as a resource about controversial topics, Wikipedia is subject to manipulation and <a href=\"/wiki/Spin_(propaganda)\" title=\"Spin (propaganda)\">spin</a>.<span class=\"mw-ref\" id=\"cite_ref-Petrilli_28-1\"><a href=\"#cite_note-Petrilli-28\" style=\"counter-reset: mw-Ref 26;\"><span class=\"mw-reflink-text\">[26]</span></a></span></p>\n\n<p>In 2006, the <i>Wikipedia Watch</i> criticism website listed dozens of examples of <a href=\"/wiki/Plagiarism\" title=\"Plagiarism\">plagiarism</a> in the English Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-wwplagiarism_173-0\"><a href=\"#cite_note-wwplagiarism-173\" style=\"counter-reset: mw-Ref 168;\"><span class=\"mw-reflink-text\">[168]</span></a></span></p>\n\n","toclevel":1,"line":"Reception","anchor":"Reception"},{"id":22,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1151\">Main article: <a href=\"/wiki/Reliability_of_Wikipedia\" title=\"Reliability of Wikipedia\">Reliability of Wikipedia</a></div>\n<table class=\"infobox\" style=\"width:22em;width: 230px; float: right; clear: right; margin:0 0 1.5em 1.5em\"><caption>External audio</caption><tbody><tr><td colspan=\"2\" style=\"text-align:center;text-align: left\"><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Nuvola_apps_arts.svg/16px-Nuvola_apps_arts.svg.png\" data-file-width=\"128\" data-file-height=\"128\" data-file-type=\"drawing\" height=\"16\" width=\"16\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Nuvola_apps_arts.svg/32px-Nuvola_apps_arts.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/e/e2/Nuvola_apps_arts.svg/24px-Nuvola_apps_arts.svg.png 1.5x\"></span></figure-inline> <a rel=\"mw:ExtLink\" href=\"https://www.cbc.ca/radio/ideas/the-great-book-of-knowledge-part-1-1.2497560\" class=\"external text\">The Great Book of Knowledge, Part 1</a>, <i>Ideas with <a href=\"/wiki/Paul_Kennedy_(host)\" title=\"Paul Kennedy (host)\">Paul Kennedy</a></i>, <a href=\"/wiki/Canadian_Broadcasting_Corporation\" title=\"Canadian Broadcasting Corporation\">CBC</a>, January 15, 2014</td></tr></tbody></table>\n\n<p>Articles for traditional encyclopedias such as <i><a href=\"/wiki/Encyclopædia_Britannica\" title=\"Encyclopædia Britannica\">Encyclopædia Britannica</a></i> are carefully and deliberately written by experts, lending such encyclopedias a reputation for accuracy.<span class=\"mw-ref\" id=\"cite_ref-174\"><a href=\"#cite_note-174\" style=\"counter-reset: mw-Ref 169;\"><span class=\"mw-reflink-text\">[169]</span></a></span> However, a peer review in 2005 of forty-two scientific entries on both Wikipedia and <i>Encyclopædia Britannica</i> by the science journal <i>Nature</i> found few differences in accuracy, and concluded that \"the average science entry in Wikipedia contained around four inaccuracies; <i>Britannica</i>, about three.\"<span class=\"mw-ref\" id=\"cite_ref-GilesJ2005Internet_23-1\"><a href=\"#cite_note-GilesJ2005Internet-23\" style=\"counter-reset: mw-Ref 21;\"><span class=\"mw-reflink-text\">[21]</span></a></span> Reagle suggested that while the study reflects \"a topical strength of Wikipedia contributors\" in science articles, \"Wikipedia may not have fared so well using a random sampling of articles or on humanities subjects.\"<span class=\"mw-ref\" id=\"cite_ref-Reagle,_pp._165–166_24-1\"><a href=\"#cite_note-Reagle,_pp._165–166-24\" style=\"counter-reset: mw-Ref 22;\"><span class=\"mw-reflink-text\">[22]</span></a></span> Others raised similar critiques.<span class=\"mw-ref\" id=\"cite_ref-Orlowski2005_25-1\"><a href=\"#cite_note-Orlowski2005-25\" style=\"counter-reset: mw-Ref 23;\"><span class=\"mw-reflink-text\">[23]</span></a></span> The findings by <i>Nature</i> were disputed by <i>Encyclopædia Britannica</i>,<span class=\"mw-ref\" id=\"cite_ref-corporate.britannica.com_175-0\"><a href=\"#cite_note-corporate.britannica.com-175\" style=\"counter-reset: mw-Ref 170;\"><span class=\"mw-reflink-text\">[170]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-nature.com_britannica_response_1_176-0\"><a href=\"#cite_note-nature.com_britannica_response_1-176\" style=\"counter-reset: mw-Ref 171;\"><span class=\"mw-reflink-text\">[171]</span></a></span> and in response, <i>Nature</i> gave a rebuttal of the points raised by <i>Britannica</i>.<span class=\"mw-ref\" id=\"cite_ref-nature.com_177-0\"><a href=\"#cite_note-nature.com-177\" style=\"counter-reset: mw-Ref 172;\"><span class=\"mw-reflink-text\">[172]</span></a></span> In addition to the point-for-point disagreement between these two parties, others have examined the sample size and selection method used in the <i>Nature</i> effort, and suggested a \"flawed study design\" (in <i>Nature</i><span class=\"nowrap\" style=\"padding-left:0.1em;\"><span>'</span></span>s manual selection of articles, in part or in whole, for comparison), absence of statistical analysis (e.g., of reported <a href=\"/wiki/Confidence_interval\" title=\"Confidence interval\">confidence intervals</a>), and a lack of study \"statistical power\" (i.e., owing to small <a href=\"/wiki/Sample_size\" title=\"Sample size\" class=\"mw-redirect\">sample size</a>, 42 or 4<span class=\"nowrap\"><span>&nbsp;</span></span>× 10<sup>1</sup> articles compared, vs &gt;10<sup>5</sup> and &gt;10<sup>6</sup> set sizes for <i>Britannica</i> and the English Wikipedia, respectively).<span class=\"mw-ref\" id=\"cite_ref-178\"><a href=\"#cite_note-178\" style=\"counter-reset: mw-Ref 173;\"><span class=\"mw-reflink-text\">[173]</span></a></span></p>\n\n<p>As a consequence of the open structure, Wikipedia \"makes no guarantee of validity\" of its content, since no one is ultimately responsible for any claims appearing in it.<span class=\"mw-ref\" id=\"cite_ref-WP_general_disclaimer_1_179-0\"><a href=\"#cite_note-WP_general_disclaimer_1-179\" style=\"counter-reset: mw-Ref 174;\"><span class=\"mw-reflink-text\">[174]</span></a></span> Concerns have been raised by <i>PC World</i> in 2009 regarding the lack of <a href=\"/wiki/Accountability\" title=\"Accountability\">accountability</a> that results from users' anonymity,<span class=\"mw-ref\" id=\"cite_ref-WikipediaWatch_180-0\"><a href=\"#cite_note-WikipediaWatch-180\" style=\"counter-reset: mw-Ref 175;\"><span class=\"mw-reflink-text\">[175]</span></a></span> the insertion of false information,<span class=\"mw-ref\" id=\"cite_ref-pcworld_WP_blunders_1_181-0\"><a href=\"#cite_note-pcworld_WP_blunders_1-181\" style=\"counter-reset: mw-Ref 176;\"><span class=\"mw-reflink-text\">[176]</span></a></span> <a href=\"/wiki/Vandalism_on_Wikipedia\" title=\"Vandalism on Wikipedia\">vandalism</a>, and similar problems.</p>\n\n<p>Economist <a href=\"/wiki/Tyler_Cowen\" title=\"Tyler Cowen\">Tyler Cowen</a> wrote: \"If I had to guess whether Wikipedia or the median refereed journal article on economics was more likely to be true after a not so long think I would opt for Wikipedia.\" He comments that some traditional sources of non-fiction suffer from systemic biases and novel results, in his opinion, are over-reported in journal articles and relevant information is omitted from news reports. However, he also cautions that errors are frequently found on Internet sites and that academics and experts must be vigilant in correcting them.<span class=\"mw-ref\" id=\"cite_ref-tnr_experts_vigilant_in_correcting_WP_1_182-0\"><a href=\"#cite_note-tnr_experts_vigilant_in_correcting_WP_1-182\" style=\"counter-reset: mw-Ref 177;\"><span class=\"mw-reflink-text\">[177]</span></a></span></p>\n\n<p>Critics argue that Wikipedia's open nature and a lack of proper sources for most of the information makes it unreliable.<span class=\"mw-ref\" id=\"cite_ref-TNY_reliability_issues_1_183-0\"><a href=\"#cite_note-TNY_reliability_issues_1-183\" style=\"counter-reset: mw-Ref 178;\"><span class=\"mw-reflink-text\">[178]</span></a></span> Some commentators suggest that Wikipedia may be reliable, but that the reliability of any given article is not clear.<span class=\"mw-ref\" id=\"cite_ref-AcademiaAndWikipedia_184-0\"><a href=\"#cite_note-AcademiaAndWikipedia-184\" style=\"counter-reset: mw-Ref 179;\"><span class=\"mw-reflink-text\">[179]</span></a></span> Editors of traditional <a href=\"/wiki/Reference_work\" title=\"Reference work\">reference works</a> such as the <i>Encyclopædia Britannica</i> have questioned the project's <a href=\"/wiki/Utility\" title=\"Utility\">utility</a> and status as an encyclopedia.<span class=\"mw-ref\" id=\"cite_ref-McHenry_2004_185-0\"><a href=\"#cite_note-McHenry_2004-185\" style=\"counter-reset: mw-Ref 180;\"><span class=\"mw-reflink-text\">[180]</span></a></span> Wikipedia co-founder <a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a> has claimed that Wikipedia has largely avoided the problem of \"fake news\" because the Wikipedia community regularly debates the quality of sources in articles.<span class=\"mw-ref\" id=\"cite_ref-186\"><a href=\"#cite_note-186\" style=\"counter-reset: mw-Ref 181;\"><span class=\"mw-reflink-text\">[181]</span></a></span></p>\n\n<table class=\"infobox\" style=\"width:22em;width: 210px; float: right; clear: right; margin:0 0 1.5em 1.5em\"><caption>External video</caption><tbody><tr><td colspan=\"2\" style=\"text-align:center;text-align: left\"><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/16px-Nuvola_apps_kaboodle.svg.png\" data-file-width=\"128\" data-file-height=\"128\" data-file-type=\"drawing\" height=\"16\" width=\"16\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/32px-Nuvola_apps_kaboodle.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Nuvola_apps_kaboodle.svg/24px-Nuvola_apps_kaboodle.svg.png 1.5x\"></span></figure-inline> <a rel=\"mw:ExtLink\" href=\"http://www.dw.de/inside-wikipedia-attack-of-the-pr-industry/av-17745881\" class=\"external text\">Inside Wikipedia—Attack of the PR Industry</a>, <a href=\"/wiki/Deutsche_Welle\" title=\"Deutsche Welle\">Deutsche Welle</a>, 7:13 mins<span class=\"mw-ref\" id=\"cite_ref-dw_187-0\"><a href=\"#cite_note-dw-187\" style=\"counter-reset: mw-Ref 182;\"><span class=\"mw-reflink-text\">[182]</span></a></span></td></tr></tbody></table>\n<p>Wikipedia's open structure inherently makes it an easy target for <a href=\"/wiki/Internet_troll\" title=\"Internet troll\">Internet trolls</a>, <a href=\"/wiki/Spamming\" title=\"Spamming\">spammers</a>, and various forms of paid advocacy seen as counterproductive to the maintenance of a neutral and verifiable online encyclopedia.<span class=\"mw-ref\" id=\"cite_ref-Torsten_Kleinz_90-1\"><a href=\"#cite_note-Torsten_Kleinz-90\" style=\"counter-reset: mw-Ref 86;\"><span class=\"mw-reflink-text\">[86]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-citizendium_WP_trolling_issues_1_188-0\"><a href=\"#cite_note-citizendium_WP_trolling_issues_1-188\" style=\"counter-reset: mw-Ref 183;\"><span class=\"mw-reflink-text\">[183]</span></a></span>\nIn response to <a href=\"/wiki/Conflict-of-interest_editing_on_Wikipedia\" title=\"Conflict-of-interest editing on Wikipedia\">paid advocacy editing</a> and undisclosed editing issues, Wikipedia was reported in an article in <i>The Wall Street Journal</i>, to have strengthened its rules and laws against undisclosed editing.<span class=\"mw-ref\" id=\"cite_ref-ReferenceA_189-0\"><a href=\"#cite_note-ReferenceA-189\" style=\"counter-reset: mw-Ref 184;\"><span class=\"mw-reflink-text\">[184]</span></a></span> The article stated that: \"Beginning Monday [from the date of the article, June 16, 2014], changes in Wikipedia's terms of use will require anyone paid to edit articles to disclose that arrangement. <a href=\"/wiki/Katherine_Maher\" title=\"Katherine Maher\">Katherine Maher</a>, the nonprofit Wikimedia Foundation's chief communications officer, said the changes address a sentiment among volunteer editors that, 'we're not an advertising service; we're an encyclopedia.<span style=\"padding-right:.15em;\">'</span><span>\"</span><span class=\"mw-ref\" id=\"cite_ref-ReferenceA_189-1\"><a href=\"#cite_note-ReferenceA-189\" style=\"counter-reset: mw-Ref 184;\"><span class=\"mw-reflink-text\">[184]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-DeathByWikipedia_190-0\"><a href=\"#cite_note-DeathByWikipedia-190\" style=\"counter-reset: mw-Ref 185;\"><span class=\"mw-reflink-text\">[185]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-cnet_politicians_and_WP_1_191-0\"><a href=\"#cite_note-cnet_politicians_and_WP_1-191\" style=\"counter-reset: mw-Ref 186;\"><span class=\"mw-reflink-text\">[186]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-msnbc_MS_cash_for_WP_edits_1_192-0\"><a href=\"#cite_note-msnbc_MS_cash_for_WP_edits_1-192\" style=\"counter-reset: mw-Ref 187;\"><span class=\"mw-reflink-text\">[187]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Seeing_Corporate_Fingerprints_193-0\"><a href=\"#cite_note-Seeing_Corporate_Fingerprints-193\" style=\"counter-reset: mw-Ref 188;\"><span class=\"mw-reflink-text\">[188]</span></a></span> These issues, among others, had been parodied since the first decade of Wikipedia, notably by <a href=\"/wiki/Stephen_Colbert\" title=\"Stephen Colbert\">Stephen Colbert</a> on <i><a href=\"/wiki/The_Colbert_Report\" title=\"The Colbert Report\">The Colbert Report</a></i>.<span class=\"mw-ref\" id=\"cite_ref-wikiality_194-0\"><a href=\"#cite_note-wikiality-194\" style=\"counter-reset: mw-Ref 189;\"><span class=\"mw-reflink-text\">[189]</span></a></span></p>\n\n<p>A Harvard law textbook, <i>Legal Research in a Nutshell</i> (2011), cites Wikipedia as a \"general source\" that \"can be a real boon\" in \"coming up to speed in the law governing a situation\" and, \"while not authoritative, can provide basic facts as well as leads to more in-depth resources\".<span class=\"mw-ref\" id=\"cite_ref-Nutshell_in-depth_resources_195-0\"><a href=\"#cite_note-Nutshell_in-depth_resources-195\" style=\"counter-reset: mw-Ref 190;\"><span class=\"mw-reflink-text\">[190]</span></a></span></p>\n\n","toclevel":2,"line":"Accuracy of content","anchor":"Accuracy_of_content"},{"id":23,"text":"\n\n<p>Most university <a href=\"/wiki/Lecturer\" title=\"Lecturer\">lecturers</a> discourage students from citing any encyclopedia in <a href=\"/wiki/Academia\" title=\"Academia\" class=\"mw-redirect\">academic work</a>, preferring <a href=\"/wiki/Primary_source\" title=\"Primary source\">primary sources</a>;<span class=\"mw-ref\" id=\"cite_ref-WideWorldOfWikipedia_196-0\"><a href=\"#cite_note-WideWorldOfWikipedia-196\" style=\"counter-reset: mw-Ref 191;\"><span class=\"mw-reflink-text\">[191]</span></a></span> some specifically prohibit Wikipedia citations.<span class=\"mw-ref\" id=\"cite_ref-insidehighered_against_WP_1_197-0\"><a href=\"#cite_note-insidehighered_against_WP_1-197\" style=\"counter-reset: mw-Ref 192;\"><span class=\"mw-reflink-text\">[192]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-insidehighered_wiki_no_cite_198-0\"><a href=\"#cite_note-insidehighered_wiki_no_cite-198\" style=\"counter-reset: mw-Ref 193;\"><span class=\"mw-reflink-text\">[193]</span></a></span> Wales stresses that encyclopedias of any type are not usually appropriate to use as citable sources, and should not be relied upon as authoritative.<span class=\"mw-ref\" id=\"cite_ref-AWorkInProgress_199-0\"><a href=\"#cite_note-AWorkInProgress-199\" style=\"counter-reset: mw-Ref 194;\"><span class=\"mw-reflink-text\">[194]</span></a></span> Wales once (2006 or earlier) said he receives about ten <a href=\"/wiki/Email\" title=\"Email\">emails</a> weekly from students saying they got failing grades on papers because they cited Wikipedia; he told the students they got what they deserved. \"For God's sake, you're in college; don't cite the encyclopedia,\" he said.<span class=\"mw-ref\" id=\"cite_ref-Jimmy_Wales_don't_cite_WP_1_200-0\"><a href=\"#cite_note-Jimmy_Wales_don't_cite_WP_1-200\" style=\"counter-reset: mw-Ref 195;\"><span class=\"mw-reflink-text\">[195]</span></a></span></p>\n\n<p>In February 2007, an article in <i><a href=\"/wiki/The_Harvard_Crimson\" title=\"The Harvard Crimson\">The Harvard Crimson</a></i> newspaper reported that a few of the professors at <a href=\"/wiki/Harvard_University\" title=\"Harvard University\">Harvard University</a> were including Wikipedia articles in their <a href=\"/wiki/Syllabus\" title=\"Syllabus\">syllabi</a>, although without realizing the articles might change.<span class=\"mw-ref\" id=\"cite_ref-thecrimson_wiki_debate_201-0\"><a href=\"#cite_note-thecrimson_wiki_debate-201\" style=\"counter-reset: mw-Ref 196;\"><span class=\"mw-reflink-text\">[196]</span></a></span> In June 2007, former president of the <a href=\"/wiki/American_Library_Association\" title=\"American Library Association\">American Library Association</a> <a href=\"/wiki/Michael_Gorman_(librarian)\" title=\"Michael Gorman (librarian)\">Michael Gorman</a> condemned Wikipedia, along with <a href=\"/wiki/Google\" title=\"Google\">Google</a>,<span class=\"mw-ref\" id=\"cite_ref-stothart_202-0\"><a href=\"#cite_note-stothart-202\" style=\"counter-reset: mw-Ref 197;\"><span class=\"mw-reflink-text\">[197]</span></a></span> stating that academics who endorse the use of Wikipedia are \"the intellectual equivalent of a dietitian who recommends a steady diet of Big Macs with everything\".</p>\n\n<p>In contrast, academic writing in Wikipedia has evolved in recent years and has been found to increase student interest, personal connection to the product, creativity in material processing, and international collaboration in the learning process.<span class=\"mw-ref\" id=\"cite_ref-203\"><a href=\"#cite_note-203\" style=\"counter-reset: mw-Ref 198;\"><span class=\"mw-reflink-text\">[198]</span></a></span> Some academics suggest ‘Verifiability by respected sources’ as an indicator for assessing the quality of Wikipedia articles at the higher education level.<span class=\"mw-ref\" id=\"cite_ref-204\"><a href=\"#cite_note-204\" style=\"counter-reset: mw-Ref 199;\"><span class=\"mw-reflink-text\">[199]</span></a></span></p>\n\n","toclevel":2,"line":"Discouragement in education","anchor":"Discouragement_in_education"},{"id":24,"text":"\n\n<p></p>\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1347\">See also: <a href=\"/wiki/Health_information_on_Wikipedia\" title=\"Health information on Wikipedia\">Health information on Wikipedia</a></div>\n\n<p>On March 5, 2014, Julie Beck writing for <i>The Atlantic</i> magazine in an article titled \"Doctors' #1 Source for Healthcare Information: Wikipedia\", stated that \"Fifty percent of physicians look up conditions on the (Wikipedia) site, and some are editing articles themselves to improve the quality of available information.\"<span class=\"mw-ref\" id=\"cite_ref-Julie_Beck_2014_205-0\"><a href=\"#cite_note-Julie_Beck_2014-205\" style=\"counter-reset: mw-Ref 200;\"><span class=\"mw-reflink-text\">[200]</span></a></span> Beck continued to detail in this article new programs of <a href=\"/wiki/Amin_Azzam\" title=\"Amin Azzam\">Amin Azzam</a> at the University of San Francisco to offer medical school courses to medical students for learning to edit and improve <a href=\"/wiki/Health_information_on_Wikipedia\" title=\"Health information on Wikipedia\">Wikipedia articles on health-related issues</a>, as well as internal quality control programs within Wikipedia organized by <a href=\"/wiki/James_Heilman\" title=\"James Heilman\">James Heilman</a> to improve a group of 200 health-related articles of central medical importance up to Wikipedia's highest standard of articles using its Featured Article and Good Article peer-review evaluation process.<span class=\"mw-ref\" id=\"cite_ref-Julie_Beck_2014_205-1\"><a href=\"#cite_note-Julie_Beck_2014-205\" style=\"counter-reset: mw-Ref 200;\"><span class=\"mw-reflink-text\">[200]</span></a></span> In a May 7, 2014, follow-up article in <i>The Atlantic</i> titled \"Can Wikipedia Ever Be a Definitive Medical Text?\", Julie Beck quotes <a href=\"/wiki/Wikipedia:WikiProject_Medicine\" title=\"Wikipedia:WikiProject Medicine\">WikiProject Medicine</a>'s James Heilman as stating: \"Just because a reference is peer-reviewed doesn't mean it's a high-quality reference.\"<span class=\"mw-ref\" id=\"cite_ref-theatlantic.com_206-0\"><a href=\"#cite_note-theatlantic.com-206\" style=\"counter-reset: mw-Ref 201;\"><span class=\"mw-reflink-text\">[201]</span></a></span> Beck added that: \"Wikipedia has its own peer review process before articles can be classified as 'good' or 'featured'. Heilman, who has participated in that process before, says 'less than one percent' of Wikipedia's medical articles have passed.\"<span class=\"mw-ref\" id=\"cite_ref-theatlantic.com_206-1\"><a href=\"#cite_note-theatlantic.com-206\" style=\"counter-reset: mw-Ref 201;\"><span class=\"mw-reflink-text\">[201]</span></a></span></p>\n\n","toclevel":3,"line":"Medical information","anchor":"Medical_information"},{"id":25,"text":"\n\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Qualitydimensions.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/3/35/Qualitydimensions.png/220px-Qualitydimensions.png\" data-file-width=\"1500\" data-file-height=\"849\" data-file-type=\"bitmap\" height=\"125\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/3/35/Qualitydimensions.png/440px-Qualitydimensions.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/3/35/Qualitydimensions.png/330px-Qualitydimensions.png 1.5x\"></a><figcaption>Quality dimensions of <a href=\"/wiki/Web_2.0\" title=\"Web 2.0\">web 2.0</a> portals, <a href=\"/wiki/Encyclopedia\" title=\"Encyclopedia\">encyclopedias</a> and Wikipedia<span class=\"mw-ref\" id=\"cite_ref-computers2019_207-0\"><a href=\"#cite_note-computers2019-207\" style=\"counter-reset: mw-Ref 202;\"><span class=\"mw-reflink-text\">[202]</span></a></span></figcaption></figure>\n\n<p>In 2008, researchers at <a href=\"/wiki/Carnegie_Mellon_University\" title=\"Carnegie Mellon University\">Carnegie Mellon University</a> found that the quality of a Wikipedia article would suffer rather than gain from adding more writers when the article lacked appropriate explicit or implicit coordination.<span class=\"mw-ref\" id=\"cite_ref-208\"><a href=\"#cite_note-208\" style=\"counter-reset: mw-Ref 203;\"><span class=\"mw-reflink-text\">[203]</span></a></span> For instance, when contributors rewrite small portions of an entry rather than making full-length revisions, high- and low-quality content may be intermingled within an entry. <a href=\"/wiki/Roy_Rosenzweig\" title=\"Roy Rosenzweig\">Roy Rosenzweig</a>, a history professor, stated that <i>American National Biography Online</i> outperformed Wikipedia in terms of its \"clear and engaging prose\", which, he said, was an important aspect of good historical writing.<span class=\"mw-ref\" id=\"cite_ref-Rosenzweig_209-0\"><a href=\"#cite_note-Rosenzweig-209\" style=\"counter-reset: mw-Ref 204;\"><span class=\"mw-reflink-text\">[204]</span></a></span> Contrasting Wikipedia's treatment of <a href=\"/wiki/Abraham_Lincoln\" title=\"Abraham Lincoln\">Abraham Lincoln</a> to that of <a href=\"/wiki/American_Civil_War\" title=\"American Civil War\">Civil War</a> historian <a href=\"/wiki/James_M._McPherson\" title=\"James M. McPherson\">James McPherson</a> in <i>American National Biography Online</i>, he said that both were essentially accurate and covered the major episodes in Lincoln's life, but praised \"McPherson's richer contextualization [...] his artful use of quotations to capture Lincoln's voice [...] and [...] his ability to convey a profound message in a handful of words.\" By contrast, he gives an example of Wikipedia's prose that he finds \"both verbose and dull\". Rosenzweig also criticized the \"waffling—encouraged by the NPOV policy—[which] means that it is hard to discern any overall interpretive stance in Wikipedia history\". While generally praising the article on <a href=\"/wiki/William_Clarke_Quantrill\" title=\"William Clarke Quantrill\" class=\"mw-redirect\">William Clarke Quantrill</a>, he quoted its conclusion as an example of such \"waffling\", which then stated: \"Some historians [...] remember him as an opportunistic, bloodthirsty outlaw, while others continue to view him as a daring soldier and local folk hero.\"<span class=\"mw-ref\" id=\"cite_ref-Rosenzweig_209-1\"><a href=\"#cite_note-Rosenzweig-209\" style=\"counter-reset: mw-Ref 204;\"><span class=\"mw-reflink-text\">[204]</span></a></span></p>\n\n<p>Other critics have made similar charges that, even if Wikipedia articles are factually accurate, they are often written in a poor, almost unreadable style. Frequent Wikipedia critic Andrew Orlowski commented, \"Even when a Wikipedia entry is 100 percent factually correct, and those facts have been carefully chosen, it all too often reads as if it has been translated from one language to another then into a third, passing an illiterate translator at each stage.\"<span class=\"mw-ref\" id=\"cite_ref-theregister_Wales_WP_founder_on_quality_1_210-0\"><a href=\"#cite_note-theregister_Wales_WP_founder_on_quality_1-210\" style=\"counter-reset: mw-Ref 205;\"><span class=\"mw-reflink-text\">[205]</span></a></span> A study of Wikipedia articles on <a href=\"/wiki/Cancer\" title=\"Cancer\">cancer</a> was conducted in 2010 by Yaacov Lawrence of the Kimmel Cancer Center at <a href=\"/wiki/Thomas_Jefferson_University\" title=\"Thomas Jefferson University\">Thomas Jefferson University</a>. The study was limited to those articles that could be found in the <i>Physician Data Query</i> and excluded those written at the \"start\" class or \"stub\" class level. Lawrence found the articles accurate but not very readable, and thought that \"Wikipedia's lack of readability (to non-college readers) may reflect its varied origins and haphazard editing\".<span class=\"mw-ref\" id=\"cite_ref-upi_accuracy_1_211-0\"><a href=\"#cite_note-upi_accuracy_1-211\" style=\"counter-reset: mw-Ref 206;\"><span class=\"mw-reflink-text\">[206]</span></a></span> <i>The Economist</i> argued that better-written articles tend to be more reliable: \"inelegant or ranting prose usually reflects muddled thoughts and incomplete information\".<span class=\"mw-ref\" id=\"cite_ref-economist_incomplete_info_212-0\"><a href=\"#cite_note-economist_incomplete_info-212\" style=\"counter-reset: mw-Ref 207;\"><span class=\"mw-reflink-text\">[207]</span></a></span></p>\n\n<p>To assess Wikipedia articles various quality measures related to <a href=\"/wiki/Credibility\" title=\"Credibility\">credibility</a>, <a href=\"/wiki/Completeness_(knowledge_bases)\" title=\"Completeness (knowledge bases)\">completeness</a>, <a href=\"/wiki/Objectivity_(science)\" title=\"Objectivity (science)\">objectivity</a>, <a href=\"/wiki/Readability\" title=\"Readability\">readability</a>, <a href=\"/wiki/Relevance\" title=\"Relevance\">relevance</a>, <a href=\"/wiki/Writing_style\" title=\"Writing style\">style</a> and <a href=\"/wiki/Timeliness\" title=\"Timeliness\" class=\"mw-redirect\">timeliness</a> can be used.<span class=\"mw-ref\" id=\"cite_ref-measures2019_213-0\"><a href=\"#cite_note-measures2019-213\" style=\"counter-reset: mw-Ref 208;\"><span class=\"mw-reflink-text\">[208]</span></a></span></p>\n\n","toclevel":2,"line":"Quality of writing","anchor":"Quality_of_writing"},{"id":26,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1413\">See also: <a href=\"/wiki/Notability_in_the_English_Wikipedia\" title=\"Notability in the English Wikipedia\">Notability in the English Wikipedia</a> and <a href=\"/wiki/Criticism_of_Wikipedia#Systemic_bias_in_coverage\" title=\"Criticism of Wikipedia\">Criticism of Wikipedia §<span>&nbsp;</span>Systemic bias in coverage</a></div>\n<table class=\"box-Update plainlinks metadata ambox ambox-content ambox-Update\" role=\"presentation\"><tbody><tr><td class=\"mbox-image\"><div style=\"width:52px\"><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/42px-Ambox_current_red.svg.png\" data-file-width=\"360\" data-file-height=\"290\" data-file-type=\"drawing\" height=\"34\" width=\"42\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/84px-Ambox_current_red.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/9/98/Ambox_current_red.svg/63px-Ambox_current_red.svg.png 1.5x\"></span></figure-inline></div></td><td class=\"mbox-text\"><div class=\"mbox-text-span\">Parts of this article (those related to <a href=\"https://www.wikidata.org/wiki/Wikidata:Statistics/Wikipedia\" title=\"d:Wikidata:Statistics/Wikipedia\">d:Wikidata:Statistics/Wikipedia</a>) need to be <b>updated</b>.  <small class=\"date-container\"><i>(<span class=\"date\">March 2017</span>)</i></small></div></td></tr></tbody></table>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:WikipediaTopics.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/66/WikipediaTopics.png/500px-WikipediaTopics.png\" data-file-width=\"1393\" data-file-height=\"438\" data-file-type=\"bitmap\" height=\"157\" width=\"500\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/6/66/WikipediaTopics.png/1000px-WikipediaTopics.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/6/66/WikipediaTopics.png/750px-WikipediaTopics.png 1.5x\"></a><figcaption>Shares of over 39 million Wikipedia articles in main categories in 55 most developed language versions as of April 2019<span class=\"mw-ref\" id=\"cite_ref-computers2019_207-1\"><a href=\"#cite_note-computers2019-207\" style=\"counter-reset: mw-Ref 202;\"><span class=\"mw-reflink-text\">[202]</span></a></span></figcaption></figure>\n\n<p>Wikipedia seeks to create a summary of all human knowledge in the form of an online encyclopedia, with each topic covered encyclopedically in one article. Since it has <a href=\"/wiki/Terabyte\" title=\"Terabyte\">terabytes</a> of disk space, it can have far more topics than can be covered by any printed encyclopedia.<span class=\"mw-ref\" id=\"cite_ref-WP_advantages_over_trad_media_1_214-0\"><a href=\"#cite_note-WP_advantages_over_trad_media_1-214\" style=\"counter-reset: mw-Ref 209;\"><span class=\"mw-reflink-text\">[209]</span></a></span> The exact degree and manner of coverage on Wikipedia is under constant review by its editors, and disagreements are not uncommon (see <a href=\"/wiki/Deletionism_and_inclusionism_in_Wikipedia\" title=\"Deletionism and inclusionism in Wikipedia\">deletionism and inclusionism</a>).<span class=\"mw-ref\" id=\"cite_ref-Economist_disagreements_not_uncommon_215-0\"><a href=\"#cite_note-Economist_disagreements_not_uncommon-215\" style=\"counter-reset: mw-Ref 210;\"><span class=\"mw-reflink-text\">[210]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-telegraph_WP_torn_apart_1_216-0\"><a href=\"#cite_note-telegraph_WP_torn_apart_1-216\" style=\"counter-reset: mw-Ref 211;\"><span class=\"mw-reflink-text\">[211]</span></a></span> Wikipedia contains materials that some people may find objectionable, offensive, or pornographic. The '<a href=\"/wiki/Wikipedia:Wikipedia_is_not#Wikipedia_is_not_censored\" title=\"Wikipedia:Wikipedia is not\" class=\"mw-redirect\">Wikipedia is not censored</a>' policy has sometimes proved controversial: in 2008, Wikipedia rejected an online petition against the inclusion of <a href=\"/wiki/Online_petition_on_Wikipedia_Muhammad_article\" title=\"Online petition on Wikipedia Muhammad article\" class=\"mw-redirect\">images of Muhammad</a> in the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English edition</a> of its <a href=\"/wiki/Muhammad\" title=\"Muhammad\">Muhammad</a> article, citing this policy. The presence of politically, religiously, and pornographically sensitive materials in Wikipedia has led to the <a href=\"/wiki/Censorship_of_Wikipedia\" title=\"Censorship of Wikipedia\">censorship of Wikipedia</a> by national authorities in <a href=\"/wiki/China\" title=\"China\">China</a><span class=\"mw-ref\" id=\"cite_ref-Taylor_217-0\"><a href=\"#cite_note-Taylor-217\" style=\"counter-reset: mw-Ref 212;\"><span class=\"mw-reflink-text\">[212]</span></a></span> and <a href=\"/wiki/Pakistan\" title=\"Pakistan\">Pakistan</a>,<span class=\"mw-ref\" id=\"cite_ref-washington_post_state_censorship_1_218-0\"><a href=\"#cite_note-washington_post_state_censorship_1-218\" style=\"counter-reset: mw-Ref 213;\"><span class=\"mw-reflink-text\">[213]</span></a></span> amongst other countries.</p>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Wikipedia_content_by_subject.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/5/54/Wikipedia_content_by_subject.png/500px-Wikipedia_content_by_subject.png\" data-file-width=\"594\" data-file-height=\"382\" data-file-type=\"bitmap\" height=\"322\" width=\"500\" srcset=\"//upload.wikimedia.org/wikipedia/commons/5/54/Wikipedia_content_by_subject.png 2x, //upload.wikimedia.org/wikipedia/commons/5/54/Wikipedia_content_by_subject.png 1.5x\"></a><figcaption>Pie chart of Wikipedia content by subject as of January 2008<span class=\"mw-ref\" id=\"cite_ref-Kittur2009_219-0\"><a href=\"#cite_note-Kittur2009-219\" style=\"counter-reset: mw-Ref 214;\"><span class=\"mw-reflink-text\">[214]</span></a></span></figcaption></figure>\n\n<p>A 2008 study conducted by researchers at Carnegie Mellon University and Palo Alto Research Center gave a distribution of topics as well as growth (from July 2006 to January 2008) in each field:<span class=\"mw-ref\" id=\"cite_ref-Kittur2009_219-1\"><a href=\"#cite_note-Kittur2009-219\" style=\"counter-reset: mw-Ref 214;\"><span class=\"mw-reflink-text\">[214]</span></a></span></p>\n<ul><li>Culture and the arts: 30% (210%)</li>\n<li>Biographies and persons: 15% (97%)</li>\n<li>Geography and places: 14% (52%)</li>\n<li>Society and social sciences: 12% (83%)</li>\n<li>History and events: 11% (143%)</li>\n<li>Natural and physical sciences: 9% (213%)</li>\n<li>Technology and the applied sciences: 4% (−6%)</li>\n<li>Religions and belief systems: 2% (38%)</li>\n<li>Health: 2% (42%)</li>\n<li>Mathematics and logic: 1% (146%)</li>\n<li>Thought and philosophy: 1% (160%)</li></ul>\n\n<p>These numbers refer only to the quantity of articles: it is possible for one topic to contain a large number of short articles and another to contain a small number of large ones. Through its \"<a href=\"/wiki/Wikipedia:Wikipedia_Loves_Libraries\" title=\"Wikipedia:Wikipedia Loves Libraries\">Wikipedia Loves Libraries</a>\" program, Wikipedia has partnered with major public libraries such as the <a href=\"/wiki/New_York_Public_Library_for_the_Performing_Arts\" title=\"New York Public Library for the Performing Arts\">New York Public Library for the Performing Arts</a> to expand its coverage of underrepresented subjects and articles.<span class=\"mw-ref\" id=\"cite_ref-NYT_subjects_and_articles_220-0\"><a href=\"#cite_note-NYT_subjects_and_articles-220\" style=\"counter-reset: mw-Ref 215;\"><span class=\"mw-reflink-text\">[215]</span></a></span></p>\n\n<p>A 2011 study conducted by researchers at the <a href=\"/wiki/University_of_Minnesota\" title=\"University of Minnesota\">University of Minnesota</a> indicated that male and female editors focus on different coverage topics. There was a greater concentration of females in the People and Arts category, while males focus more on Geography and Science.<span class=\"mw-ref\" id=\"cite_ref-221\"><a href=\"#cite_note-221\" style=\"counter-reset: mw-Ref 216;\"><span class=\"mw-reflink-text\">[216]</span></a></span></p>\n\n","toclevel":2,"line":"Coverage of topics and systemic bias","anchor":"Coverage_of_topics_and_systemic_bias"},{"id":27,"text":"\n\n<p>Research conducted by Mark Graham of the <a href=\"/wiki/Oxford_Internet_Institute\" title=\"Oxford Internet Institute\">Oxford Internet Institute</a> in 2009 indicated that the geographic distribution of article topics is highly uneven. Africa is most underrepresented.<span class=\"mw-ref\" id=\"cite_ref-222\"><a href=\"#cite_note-222\" style=\"counter-reset: mw-Ref 217;\"><span class=\"mw-reflink-text\">[217]</span></a></span> Across 30 language editions of Wikipedia, historical articles and sections are generally Eurocentric and focused on recent events.<span class=\"mw-ref\" id=\"cite_ref-223\"><a href=\"#cite_note-223\" style=\"counter-reset: mw-Ref 218;\"><span class=\"mw-reflink-text\">[218]</span></a></span></p>\n\n<p>An editorial in <i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i> in 2014 claimed that more effort went into providing references for <a href=\"/wiki/List_of_pornographic_performers_by_decade\" title=\"List of pornographic performers by decade\">a list of female porn actors</a> than a <a href=\"/wiki/List_of_women_writers\" title=\"List of women writers\">list of women writers</a>.<span class=\"mw-ref\" id=\"cite_ref-GuardianAugust2014_224-0\"><a href=\"#cite_note-GuardianAugust2014-224\" style=\"counter-reset: mw-Ref 219;\"><span class=\"mw-reflink-text\">[219]</span></a></span> Data has also shown that Africa-related material often faces omission; a knowledge gap that a July 2018 Wikimedia conference in <a href=\"/wiki/Cape_Town\" title=\"Cape Town\">Cape Town</a> sought to address.<span class=\"mw-ref\" id=\"cite_ref-memeb_147-1\"><a href=\"#cite_note-memeb-147\" style=\"counter-reset: mw-Ref 142;\"><span class=\"mw-reflink-text\">[142]</span></a></span></p>\n\n","toclevel":3,"line":"Coverage of topics and selection bias","anchor":"Coverage_of_topics_and_selection_bias"},{"id":28,"text":"\n\n<p>When multiple editors contribute to one topic or set of topics, <a href=\"/wiki/Systemic_bias\" title=\"Systemic bias\">systemic bias</a> may arise, due to the demographic backgrounds of the editors. In 2011, Wales claimed that the unevenness of coverage is a reflection of the demography of the editors, citing for example \"biographies of famous women through history and issues surrounding early childcare\".<span class=\"mw-ref\" id=\"cite_ref-wiki-women_61-1\"><a href=\"#cite_note-wiki-women-61\" style=\"counter-reset: mw-Ref 59;\"><span class=\"mw-reflink-text\">[59]</span></a></span> The October 22, 2013, essay by Tom Simonite in MIT's <i>Technology Review</i> titled \"The Decline of Wikipedia\" discussed the effect of systemic bias and <a href=\"/wiki/Criticism_of_Wikipedia#Excessive_regulation\" title=\"Criticism of Wikipedia\">policy creep</a> on the <a href=\"#Decline_in_participation_since_2009\">downward trend in the number of editors</a>.<span class=\"mw-ref\" id=\"cite_ref-Simonite-2013_62-1\"><a href=\"#cite_note-Simonite-2013-62\" style=\"counter-reset: mw-Ref 60;\"><span class=\"mw-reflink-text\">[60]</span></a></span></p>\n\n<p><a href=\"/wiki/Bias_in_Wikipedia\" title=\"Bias in Wikipedia\">Systemic bias on Wikipedia</a> may follow that of culture generally,<sup class=\"noprint Inline-Template \" style=\"white-space:nowrap;\">[<i><a href=\"/wiki/Wikipedia:Vagueness\" title=\"Wikipedia:Vagueness\"><span>vague</span></a></i>]</sup> for example favoring certain nationalities, ethnicities or majority religions.<span class=\"mw-ref\" id=\"cite_ref-Quilter_225-0\"><a href=\"#cite_note-Quilter-225\" style=\"counter-reset: mw-Ref 220;\"><span class=\"mw-reflink-text\">[220]</span></a></span> It may more specifically follow the biases of <a href=\"/wiki/Internet_culture\" title=\"Internet culture\">Internet culture</a>, inclining to being young, male, English-speaking, educated, technologically aware, and wealthy enough to spare time for editing. Biases of its own may include over-emphasis on topics such as pop culture, technology, and current events.<span class=\"mw-ref\" id=\"cite_ref-Quilter_225-1\"><a href=\"#cite_note-Quilter-225\" style=\"counter-reset: mw-Ref 220;\"><span class=\"mw-reflink-text\">[220]</span></a></span></p>\n\n<p><a href=\"/wiki/Taha_Yasseri\" title=\"Taha Yasseri\">Taha Yasseri</a> of the <a href=\"/wiki/University_of_Oxford\" title=\"University of Oxford\">University of Oxford</a>, in 2013, studied the statistical trends of systemic bias at Wikipedia introduced by editing conflicts and their resolution.<span class=\"mw-ref\" id=\"cite_ref-226\"><a href=\"#cite_note-226\" style=\"counter-reset: mw-Ref 221;\"><span class=\"mw-reflink-text\">[221]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-autogenerated3_227-0\"><a href=\"#cite_note-autogenerated3-227\" style=\"counter-reset: mw-Ref 222;\"><span class=\"mw-reflink-text\">[222]</span></a></span> His research examined the <a href=\"/wiki/Counterproductive_work_behavior\" title=\"Counterproductive work behavior\">counterproductive work behavior</a> of edit warring. Yasseri contended that simple reverts or \"undo\" operations were not the most significant measure of counterproductive behavior at Wikipedia and relied instead on the <span class=\"new\">statistical measurement</span> of detecting \"reverting/reverted pairs\" or \"mutually reverting edit pairs\". Such a \"mutually reverting edit pair\" is defined where one editor reverts the edit of another editor who then, in sequence, returns to revert the first editor in the \"mutually reverting edit pairs\". The results were tabulated for several language versions of Wikipedia. The English Wikipedia's three largest conflict rates belonged to the articles <a href=\"/wiki/George_W._Bush\" title=\"George W. Bush\">George W. Bush</a>, <a href=\"/wiki/Anarchism\" title=\"Anarchism\">Anarchism</a>, and <a href=\"/wiki/Muhammad\" title=\"Muhammad\">Muhammad</a>.<span class=\"mw-ref\" id=\"cite_ref-autogenerated3_227-1\"><a href=\"#cite_note-autogenerated3-227\" style=\"counter-reset: mw-Ref 222;\"><span class=\"mw-reflink-text\">[222]</span></a></span> By comparison, for the German Wikipedia, the three largest conflict rates at the time of the <a href=\"/wiki/Oxford\" title=\"Oxford\">Oxford</a> study were for the articles covering <a href=\"/wiki/Croatia\" title=\"Croatia\">Croatia</a>, <a href=\"/wiki/Scientology\" title=\"Scientology\">Scientology</a>, and <a href=\"/wiki/9/11_conspiracy_theories\" title=\"9/11 conspiracy theories\">9/11 conspiracy theories</a>.<span class=\"mw-ref\" id=\"cite_ref-autogenerated3_227-2\"><a href=\"#cite_note-autogenerated3-227\" style=\"counter-reset: mw-Ref 222;\"><span class=\"mw-reflink-text\">[222]</span></a></span></p>\n\n<p>Researchers from <a href=\"/wiki/Washington_University\" title=\"Washington University\" class=\"mw-redirect\">Washington University</a> developed a statistical model to measure systematic bias in the behavior of Wikipedia's users regarding controversial topics. The authors focused on behavioral changes of the encyclopedia's administrators after assuming the post, writing that systematic bias occurred after the fact.<span class=\"mw-ref\" id=\"cite_ref-228\"><a href=\"#cite_note-228\" style=\"counter-reset: mw-Ref 223;\"><span class=\"mw-reflink-text\">[223]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-229\"><a href=\"#cite_note-229\" style=\"counter-reset: mw-Ref 224;\"><span class=\"mw-reflink-text\">[224]</span></a></span></p>\n\n","toclevel":3,"line":"Systemic bias","anchor":"Systemic_bias"},{"id":29,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1534\">See also: <a href=\"/wiki/Internet_Watch_Foundation_and_Wikipedia\" title=\"Internet Watch Foundation and Wikipedia\">Internet Watch Foundation and Wikipedia</a> and <a href=\"/wiki/Reporting_of_child_pornography_images_on_Wikimedia_Commons\" title=\"Reporting of child pornography images on Wikimedia Commons\">Reporting of child pornography images on Wikimedia Commons</a></div>\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1535\"><div style=\"display:inline;\" class=\"plainlinks selfreference noprint\">\"Wikipedia censorship\" redirects here. For the government censorship of Wikipedia, see <a href=\"/wiki/Censorship_of_Wikipedia\" title=\"Censorship of Wikipedia\">Censorship of Wikipedia</a>. For Wikipedia's policy concerning censorship, see <a href=\"/wiki/Wikipedia:Wikipedia_is_not_censored\" title=\"Wikipedia:Wikipedia is not censored\" class=\"mw-redirect\">Wikipedia:Wikipedia is not censored</a></div></div>\n<p>Wikipedia has been criticized for allowing information of graphic content. Articles depicting what some critics have called objectionable content (such as <a href=\"/wiki/Feces\" title=\"Feces\">Feces</a>, <a href=\"/wiki/Cadaver\" title=\"Cadaver\">Cadaver</a>, <a href=\"/wiki/Human_penis\" title=\"Human penis\">Human penis</a>, <a href=\"/wiki/Vulva\" title=\"Vulva\">Vulva</a>, and <a href=\"/wiki/Nudity\" title=\"Nudity\">Nudity</a>) contain graphic pictures and detailed information easily available to anyone with access to the internet, including children.</p>\n\n<p>The site also includes <a href=\"/wiki/Sexual_content\" title=\"Sexual content\">sexual content</a> such as images and videos of <a href=\"/wiki/Masturbation\" title=\"Masturbation\">masturbation</a> and <a href=\"/wiki/Ejaculation\" title=\"Ejaculation\">ejaculation</a>, <a href=\"/wiki/Zoophilia\" title=\"Zoophilia\">illustrations of zoophilia</a>, and photos from <a href=\"/wiki/Hardcore_pornography\" title=\"Hardcore pornography\">hardcore pornographic</a> films in its articles. It also has non-sexual <a href=\"/wiki/Child_nudity\" title=\"Child nudity\" class=\"mw-redirect\">photographs of nude children</a>.</p>\n\n<p>The Wikipedia article about <i><a href=\"/wiki/Virgin_Killer\" title=\"Virgin Killer\">Virgin Killer</a>—</i>a 1976 album from the <a href=\"/wiki/Music_of_Germany\" title=\"Music of Germany\">German</a> <a href=\"/wiki/Rock_music\" title=\"Rock music\">rock</a> <a href=\"/wiki/Rock_band\" title=\"Rock band\" class=\"mw-redirect\">band</a> <a href=\"/wiki/Scorpions_(band)\" title=\"Scorpions (band)\">Scorpions</a>—features a picture of the album's original cover, which depicts a naked <a href=\"/wiki/Prepubescent\" title=\"Prepubescent\" class=\"mw-redirect\">prepubescent</a> girl. The original release cover caused controversy and was replaced in some countries. In December 2008, access to the Wikipedia article <i>Virgin Killer</i> was blocked for four days by most <a href=\"/wiki/Internet_service_provider\" title=\"Internet service provider\">Internet service providers</a> in the United Kingdom after the <a href=\"/wiki/Internet_Watch_Foundation\" title=\"Internet Watch Foundation\">Internet Watch Foundation</a> (IWF) decided the album cover was a potentially illegal indecent image and added the article's URL to a \"blacklist\" it supplies to British internet service providers.<span class=\"mw-ref\" id=\"cite_ref-Register_ISP_censorship_230-0\"><a href=\"#cite_note-Register_ISP_censorship-230\" style=\"counter-reset: mw-Ref 225;\"><span class=\"mw-reflink-text\">[225]</span></a></span></p>\n\n<p>In April 2010, Sanger wrote a letter to the Federal Bureau of Investigation, outlining his concerns that two categories of images on <a href=\"/wiki/Wikimedia_Commons\" title=\"Wikimedia Commons\">Wikimedia Commons</a> contained child pornography, and were in violation of <a href=\"/wiki/United_States_obscenity_law\" title=\"United States obscenity law\">US federal obscenity law</a>.<span class=\"mw-ref\" id=\"cite_ref-231\"><a href=\"#cite_note-231\" style=\"counter-reset: mw-Ref 226;\"><span class=\"mw-reflink-text\">[226]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Inquirer_child_abuse_allegations_232-0\"><a href=\"#cite_note-Inquirer_child_abuse_allegations-232\" style=\"counter-reset: mw-Ref 227;\"><span class=\"mw-reflink-text\">[227]</span></a></span> Sanger later clarified that the images, which were related to <a href=\"/wiki/Pedophilia\" title=\"Pedophilia\">pedophilia</a> and one about <a href=\"/wiki/Lolicon\" title=\"Lolicon\">lolicon</a>, were not of real children, but said that they constituted \"obscene visual representations of the sexual abuse of children\", under the <a href=\"/wiki/Child_pornography_laws_in_the_United_States#Section_1466A\" title=\"Child pornography laws in the United States\">PROTECT Act of 2003</a>.<span class=\"mw-ref\" id=\"cite_ref-The_Register-April_233-0\"><a href=\"#cite_note-The_Register-April-233\" style=\"counter-reset: mw-Ref 228;\"><span class=\"mw-reflink-text\">[228]</span></a></span> That law bans photographic child pornography and cartoon images and drawings of children that are <a href=\"/wiki/Obscenity#United_States_obscenity_law\" title=\"Obscenity\">obscene under American law</a>.<span class=\"mw-ref\" id=\"cite_ref-The_Register-April_233-1\"><a href=\"#cite_note-The_Register-April-233\" style=\"counter-reset: mw-Ref 228;\"><span class=\"mw-reflink-text\">[228]</span></a></span> Sanger also expressed concerns about access to the images on Wikipedia in schools.<span class=\"mw-ref\" id=\"cite_ref-TET_child_porn_accusations_234-0\"><a href=\"#cite_note-TET_child_porn_accusations-234\" style=\"counter-reset: mw-Ref 229;\"><span class=\"mw-reflink-text\">[229]</span></a></span> <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a> spokesman Jay Walsh strongly rejected Sanger's accusation,<span class=\"mw-ref\" id=\"cite_ref-AFP_235-0\"><a href=\"#cite_note-AFP-235\" style=\"counter-reset: mw-Ref 230;\"><span class=\"mw-reflink-text\">[230]</span></a></span> saying that Wikipedia did not have \"material we would deem to be illegal. If we did, we would remove it.\"<span class=\"mw-ref\" id=\"cite_ref-AFP_235-1\"><a href=\"#cite_note-AFP-235\" style=\"counter-reset: mw-Ref 230;\"><span class=\"mw-reflink-text\">[230]</span></a></span> Following the complaint by Sanger, Wales deleted sexual images without consulting the community. After some editors who volunteer to maintain the site argued that the decision to delete had been made hastily, Wales voluntarily gave up some of the powers he had held up to that time as part of his co-founder status. He wrote in a message to the Wikimedia Foundation mailing-list that this action was \"in the interest of encouraging this discussion to be about real philosophical/content issues, rather than be about me and how quickly I acted\".<span class=\"mw-ref\" id=\"cite_ref-BBC_News_Wales_cedes_rights_236-0\"><a href=\"#cite_note-BBC_News_Wales_cedes_rights-236\" style=\"counter-reset: mw-Ref 231;\"><span class=\"mw-reflink-text\">[231]</span></a></span> Critics, including <a href=\"/wiki/Wikipediocracy\" title=\"Wikipediocracy\">Wikipediocracy</a>, noticed that many of the pornographic images deleted from Wikipedia since 2010 have reappeared.<span class=\"mw-ref\" id=\"cite_ref-XBIZ_237-0\"><a href=\"#cite_note-XBIZ-237\" style=\"counter-reset: mw-Ref 232;\"><span class=\"mw-reflink-text\">[232]</span></a></span></p>\n\n","toclevel":2,"line":"Explicit content","anchor":"Explicit_content"},{"id":30,"text":"\n\n<p>One <a href=\"/wiki/Privacy\" title=\"Privacy\">privacy</a> concern in the case of Wikipedia is the right of a private citizen to remain a \"private citizen\" rather than a \"<a href=\"/wiki/Public_figure\" title=\"Public figure\">public figure</a>\" in the eyes of the law.<span class=\"mw-ref\" id=\"cite_ref-238\"><a href=\"#cite_note-238\" style=\"counter-reset: mw-Ref 233;\"><span class=\"mw-reflink-text\">[233]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-239\"><a href=\"#cite_note-239\" style=\"counter-reset: mw-Ref 6;\" data-mw-group=\"note\"><span class=\"mw-reflink-text\">[note 6]</span></a></span> It is a battle between the right to be anonymous in <a href=\"/wiki/Cyberspace\" title=\"Cyberspace\">cyberspace</a> and the right to be anonymous in <a href=\"/wiki/Real_life\" title=\"Real life\">real life</a> (\"<a href=\"/wiki/Meatspace\" title=\"Meatspace\" class=\"mw-redirect\">meatspace</a>\"). A particular problem occurs in the case of an individual who is relatively unimportant and for whom there exists a Wikipedia page against her or his wishes.</p>\n\n<p>In January 2006, a German court ordered the <a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German Wikipedia</a> shut down within Germany because it stated the full name of <a href=\"/wiki/Tron_(hacker)\" title=\"Tron (hacker)\">Boris Floricic</a>, aka \"Tron\", a deceased hacker. On February 9, 2006, the injunction against Wikimedia Deutschland was overturned, with the court rejecting the notion that Tron's <a href=\"/wiki/Right_to_privacy\" title=\"Right to privacy\">right to privacy</a> or that of his parents was being violated.<span class=\"mw-ref\" id=\"cite_ref-heise_Tron_public_issue_1_240-0\"><a href=\"#cite_note-heise_Tron_public_issue_1-240\" style=\"counter-reset: mw-Ref 234;\"><span class=\"mw-reflink-text\">[234]</span></a></span></p>\n\n<p>Wikipedia has a \"<span id=\"Volunteer_Response_Team\">Volunteer Response Team</span>\" that uses the <a href=\"/wiki/OTRS\" title=\"OTRS\">OTRS</a> system to handle queries without having to reveal the identities of the involved parties. This is used, for example, in confirming the permission for using individual images and other media in the project.<span class=\"mw-ref\" id=\"cite_ref-241\"><a href=\"#cite_note-241\" style=\"counter-reset: mw-Ref 235;\"><span class=\"mw-reflink-text\">[235]</span></a></span></p>\n\n","toclevel":2,"line":"Privacy","anchor":"Privacy"},{"id":31,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1610\">Main article: <a href=\"/wiki/Gender_bias_on_Wikipedia\" title=\"Gender bias on Wikipedia\">Gender bias on Wikipedia</a></div>\n\n<p>Wikipedia has been described as harboring a battleground culture of <a href=\"/wiki/Sexism\" title=\"Sexism\">sexism</a> and <a href=\"/wiki/Harassment\" title=\"Harassment\">harassment</a>.<span class=\"mw-ref\" id=\"cite_ref-Paling_242-0\"><a href=\"#cite_note-Paling-242\" style=\"counter-reset: mw-Ref 236;\"><span class=\"mw-reflink-text\">[236]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-243\"><a href=\"#cite_note-243\" style=\"counter-reset: mw-Ref 237;\"><span class=\"mw-reflink-text\">[237]</span></a></span> The perceived toxic attitudes and tolerance of violent and abusive language are also reasons put forth for the gender gap in Wikipedia editors.<span class=\"mw-ref\" id=\"cite_ref-CSM-misogyny_244-0\"><a href=\"#cite_note-CSM-misogyny-244\" style=\"counter-reset: mw-Ref 238;\"><span class=\"mw-reflink-text\">[238]</span></a></span> In 2014, a female editor who requested a separate space on Wikipedia to discuss improving civility had her proposal referred to by a male editor using the words \"the easiest way to avoid being called a <a href=\"/wiki/Cunt\" title=\"Cunt\">cunt</a> is not to act like one\".<span class=\"mw-ref\" id=\"cite_ref-Paling_242-1\"><a href=\"#cite_note-Paling-242\" style=\"counter-reset: mw-Ref 236;\"><span class=\"mw-reflink-text\">[236]</span></a></span></p>\n\n","toclevel":2,"line":"Sexism","anchor":"Sexism"},{"id":32,"text":"\n","toclevel":1,"line":"Operation","anchor":"Operation"},{"id":33,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1636\">Main article: <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a></div>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Katherine_Maher.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/25/Katherine_Maher.jpg/220px-Katherine_Maher.jpg\" data-file-width=\"5430\" data-file-height=\"3620\" data-file-type=\"bitmap\" height=\"147\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/25/Katherine_Maher.jpg/440px-Katherine_Maher.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/25/Katherine_Maher.jpg/330px-Katherine_Maher.jpg 1.5x\"></a><figcaption><a href=\"/wiki/Katherine_Maher\" title=\"Katherine Maher\">Katherine Maher</a> is the third executive director at Wikimedia, following the departure of <a href=\"/wiki/Lila_Tretikov\" title=\"Lila Tretikov\">Lila Tretikov</a> in 2016.</figcaption></figure>\n\n<p>Wikipedia is hosted and funded by the <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a>, a non-profit organization which also operates Wikipedia-related projects such as <a href=\"/wiki/Wiktionary\" title=\"Wiktionary\">Wiktionary</a> and <a href=\"/wiki/Wikibooks\" title=\"Wikibooks\">Wikibooks</a>. The foundation relies on public contributions and grants to fund its mission.<span class=\"mw-ref\" id=\"cite_ref-financialstatements_245-0\"><a href=\"#cite_note-financialstatements-245\" style=\"counter-reset: mw-Ref 239;\"><span class=\"mw-reflink-text\">[239]</span></a></span> The foundation's 2013 IRS Form 990 shows revenue of $39.7<span>&nbsp;</span>million and expenses of almost $29<span>&nbsp;</span>million, with assets of $37.2<span>&nbsp;</span>million and liabilities of about $2.3<span>&nbsp;</span>million.<span class=\"mw-ref\" id=\"cite_ref-246\"><a href=\"#cite_note-246\" style=\"counter-reset: mw-Ref 240;\"><span class=\"mw-reflink-text\">[240]</span></a></span></p>\n\n<p>In May 2014, Wikimedia Foundation named <a href=\"/wiki/Lila_Tretikov\" title=\"Lila Tretikov\">Lila Tretikov</a> as its second executive director, taking over for Sue Gardner.<span class=\"mw-ref\" id=\"cite_ref-247\"><a href=\"#cite_note-247\" style=\"counter-reset: mw-Ref 241;\"><span class=\"mw-reflink-text\">[241]</span></a></span> The <i>Wall Street Journal</i> reported on May 1, 2014, that Tretikov's information technology background from her years at University of California offers Wikipedia an opportunity to develop in more concentrated directions guided by her often repeated position statement that, \"Information, like air, wants to be free.\"<span class=\"mw-ref\" id=\"cite_ref-Jeff_Elder_2014_248-0\"><a href=\"#cite_note-Jeff_Elder_2014-248\" style=\"counter-reset: mw-Ref 242;\"><span class=\"mw-reflink-text\">[242]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-nytimes.com_249-0\"><a href=\"#cite_note-nytimes.com-249\" style=\"counter-reset: mw-Ref 243;\"><span class=\"mw-reflink-text\">[243]</span></a></span> The same <i>Wall Street Journal</i> article reported these directions of development according to an interview with spokesman Jay Walsh of Wikimedia, who \"said Tretikov would address that issue (<a href=\"/wiki/Conflict-of-interest_editing_on_Wikipedia\" title=\"Conflict-of-interest editing on Wikipedia\">paid advocacy</a>) as a priority. 'We are really pushing toward more transparency<span class=\"nowrap\"><span>&nbsp;</span></span>... We are reinforcing that paid advocacy is not welcome.' Initiatives to involve greater diversity of contributors, better mobile support of Wikipedia, new geo-location tools to find local content more easily, and more tools for users in the second and third world are also priorities,\" Walsh said.<span class=\"mw-ref\" id=\"cite_ref-Jeff_Elder_2014_248-1\"><a href=\"#cite_note-Jeff_Elder_2014-248\" style=\"counter-reset: mw-Ref 242;\"><span class=\"mw-reflink-text\">[242]</span></a></span></p>\n\n<p>Following the departure of Tretikov from Wikipedia due to issues concerning the use of the \"superprotection\" feature which some language versions of Wikipedia have adopted, Katherine Maher became the third executive director the Wikimedia Foundation in June 2016.<span class=\"mw-ref\" id=\"cite_ref-250\"><a href=\"#cite_note-250\" style=\"counter-reset: mw-Ref 244;\"><span class=\"mw-reflink-text\">[244]</span></a></span> Maher has stated that one of her priorities would be the issue of editor harassment endemic to Wikipedia as identified by the Wikipedia board in December. Maher stated regarding the harassment issue that: \"It establishes a sense within the community that this is a priority<span class=\"nowrap\"><span>&nbsp;</span></span>... (and that correction requires that) it has to be more than words.\"<span class=\"mw-ref\" id=\"cite_ref-251\"><a href=\"#cite_note-251\" style=\"counter-reset: mw-Ref 245;\"><span class=\"mw-reflink-text\">[245]</span></a></span></p>\n\n<p>Wikipedia is also supported by many organizations and groups that are affiliated with the Wikimedia Foundation but independently run, called <a href=\"/wiki/Wikimedia_movement_affiliates\" title=\"Wikimedia movement affiliates\" class=\"mw-redirect\">Wikimedia movement affiliates</a>. These include <a href=\"/wiki/List_of_Wikimedia_chapters\" title=\"List of Wikimedia chapters\">Wikimedia chapters</a> (which are national or sub-national organizations, such as Wikimedia Deutschland and Wikimédia France), thematic organizations (such as Amical Wikimedia for the <a href=\"/wiki/Catalan_language\" title=\"Catalan language\">Catalan language</a> community), and user groups. These affiliates participate in the promotion, development, and funding of Wikipedia.</p>\n\n","toclevel":2,"line":"Wikimedia Foundation and Wikimedia movement affiliates","anchor":"Wikimedia_Foundation_and_Wikimedia_movement_affiliates"},{"id":34,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1679\">See also: <a href=\"/wiki/MediaWiki\" title=\"MediaWiki\">MediaWiki</a></div>\n\n<p>The operation of Wikipedia depends on <a href=\"/wiki/MediaWiki\" title=\"MediaWiki\">MediaWiki</a>, a custom-made, <a href=\"/wiki/Free_software\" title=\"Free software\">free</a> and <a href=\"/wiki/Open-source_software\" title=\"Open-source software\">open source</a> <a href=\"/wiki/Wiki_software\" title=\"Wiki software\">wiki software</a> platform written in <a href=\"/wiki/PHP\" title=\"PHP\">PHP</a> and built upon the <a href=\"/wiki/MySQL\" title=\"MySQL\">MySQL</a> database system.<span class=\"mw-ref\" id=\"cite_ref-nedworks_database_system_252-0\"><a href=\"#cite_note-nedworks_database_system-252\" style=\"counter-reset: mw-Ref 246;\"><span class=\"mw-reflink-text\">[246]</span></a></span> The software incorporates programming features such as a <a href=\"/wiki/Macro_(computer_science)\" title=\"Macro (computer science)\">macro language</a>, <a href=\"/wiki/Variable_(programming)\" title=\"Variable (programming)\" class=\"mw-redirect\">variables</a>, a <a href=\"/wiki/Transclusion\" title=\"Transclusion\">transclusion</a> system for <a href=\"/wiki/Web_template\" title=\"Web template\" class=\"mw-redirect\">templates</a>, and <a href=\"/wiki/URL_redirection\" title=\"URL redirection\">URL redirection</a>. MediaWiki is licensed under the <a href=\"/wiki/GNU_General_Public_License\" title=\"GNU General Public License\">GNU General Public License</a> and it is used by all Wikimedia projects, as well as many other wiki projects. Originally, Wikipedia ran on <a href=\"/wiki/UseModWiki\" title=\"UseModWiki\">UseModWiki</a> written in <a href=\"/wiki/Perl\" title=\"Perl\">Perl</a> by Clifford Adams (Phase I), which initially required <a href=\"/wiki/CamelCase\" title=\"CamelCase\" class=\"mw-redirect\">CamelCase</a> for article hyperlinks; the present double bracket style was incorporated later. Starting in January 2002 (Phase II), Wikipedia began running on a <a href=\"/wiki/PhpWiki\" title=\"PhpWiki\">PHP wiki</a> engine with a MySQL database; this software was custom-made for Wikipedia by <a href=\"/wiki/Magnus_Manske\" title=\"Magnus Manske\">Magnus Manske</a>. The Phase II software was repeatedly modified to accommodate the <a href=\"/wiki/Exponential_growth\" title=\"Exponential growth\">exponentially increasing</a> demand. In July 2002 (Phase III), Wikipedia shifted to the third-generation software, MediaWiki, originally written by <a href=\"/wiki/Lee_Daniel_Crocker\" title=\"Lee Daniel Crocker\">Lee Daniel Crocker</a>.</p>\n\n<p>Several MediaWiki extensions are installed<span class=\"mw-ref\" id=\"cite_ref-WP_extensions_installed_253-0\"><a href=\"#cite_note-WP_extensions_installed-253\" style=\"counter-reset: mw-Ref 247;\"><span class=\"mw-reflink-text\">[247]</span></a></span> to extend the functionality of the MediaWiki software.</p>\n\n<p>In April 2005, a <a href=\"/wiki/Lucene\" title=\"Lucene\" class=\"mw-redirect\">Lucene</a> extension<span class=\"mw-ref\" id=\"cite_ref-254\"><a href=\"#cite_note-254\" style=\"counter-reset: mw-Ref 248;\"><span class=\"mw-reflink-text\">[248]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-255\"><a href=\"#cite_note-255\" style=\"counter-reset: mw-Ref 249;\"><span class=\"mw-reflink-text\">[249]</span></a></span> was added to MediaWiki's built-in search and Wikipedia switched from <a href=\"/wiki/MySQL\" title=\"MySQL\">MySQL</a> to Lucene for searching. The site currently uses Lucene Search 2.1,<span class=\"mw-ref\" id=\"cite_ref-256\"><a href=\"#cite_note-256\" style=\"counter-reset: mw-Ref 250;\"><span class=\"mw-reflink-text\">[250]</span></a></span><sup class=\"noprint Inline-Template \" style=\"white-space:nowrap;\">[<i><a href=\"/wiki/Wikipedia:Manual_of_Style/Dates_and_numbers#Chronological_items\" title=\"Wikipedia:Manual of Style/Dates and numbers\"><span>needs update</span></a></i>]</sup> which is written in <a href=\"/wiki/Java_(programming_language)\" title=\"Java (programming language)\">Java</a> and based on Lucene library 2.3.<span class=\"mw-ref\" id=\"cite_ref-257\"><a href=\"#cite_note-257\" style=\"counter-reset: mw-Ref 251;\"><span class=\"mw-reflink-text\">[251]</span></a></span></p>\n\n<p>In July 2013, after extensive beta testing, a WYSIWYG (What You See Is What You Get) extension, <a href=\"/wiki/VisualEditor\" title=\"VisualEditor\">VisualEditor</a>, was opened to public use.<span class=\"mw-ref\" id=\"cite_ref-thenextwebve_258-0\"><a href=\"#cite_note-thenextwebve-258\" style=\"counter-reset: mw-Ref 252;\"><span class=\"mw-reflink-text\">[252]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-259\"><a href=\"#cite_note-259\" style=\"counter-reset: mw-Ref 253;\"><span class=\"mw-reflink-text\">[253]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-TheEconomistVE_260-0\"><a href=\"#cite_note-TheEconomistVE-260\" style=\"counter-reset: mw-Ref 254;\"><span class=\"mw-reflink-text\">[254]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-softpedia-best_261-0\"><a href=\"#cite_note-softpedia-best-261\" style=\"counter-reset: mw-Ref 255;\"><span class=\"mw-reflink-text\">[255]</span></a></span> It was met with much rejection and criticism, and was described as \"slow and buggy\".<span class=\"mw-ref\" id=\"cite_ref-Orlowski,_Andrew_262-0\"><a href=\"#cite_note-Orlowski,_Andrew-262\" style=\"counter-reset: mw-Ref 256;\"><span class=\"mw-reflink-text\">[256]</span></a></span> The feature was changed from opt-out to opt-in afterward.</p>\n\n","toclevel":2,"line":"Software operations and support","anchor":"Software_operations_and_support"},{"id":35,"text":"\n\n<p>Computer programs called <a href=\"/wiki/Internet_bot\" title=\"Internet bot\">bots</a> have often been used to perform simple and repetitive tasks, such as correcting common misspellings and stylistic issues, or to start articles such as geography entries in a standard format from statistical data.<span class=\"mw-ref\" id=\"cite_ref-263\"><a href=\"#cite_note-263\" style=\"counter-reset: mw-Ref 257;\"><span class=\"mw-reflink-text\">[257]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-meetbots_264-0\"><a href=\"#cite_note-meetbots-264\" style=\"counter-reset: mw-Ref 258;\"><span class=\"mw-reflink-text\">[258]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-265\"><a href=\"#cite_note-265\" style=\"counter-reset: mw-Ref 259;\"><span class=\"mw-reflink-text\">[259]</span></a></span> One controversial contributor creating articles with his bot was reported to create up to 10,000 articles on the Swedish Wikipedia on certain days.<span class=\"mw-ref\" id=\"cite_ref-266\"><a href=\"#cite_note-266\" style=\"counter-reset: mw-Ref 260;\"><span class=\"mw-reflink-text\">[260]</span></a></span> Additionally, there are bots designed to automatically notify editors when they make common editing errors (such as unmatched quotes or unmatched parentheses).<span class=\"mw-ref\" id=\"cite_ref-267\"><a href=\"#cite_note-267\" style=\"counter-reset: mw-Ref 261;\"><span class=\"mw-reflink-text\">[261]</span></a></span> Edits falsely identified by bots as the work of a banned editor can be restored by other editors. <a href=\"/wiki/User:ClueBot_NG\" title=\"User:ClueBot NG\">An anti-vandal bot</a> is programmed to detect and revert vandalism quickly.<span class=\"mw-ref\" id=\"cite_ref-meetbots_264-1\"><a href=\"#cite_note-meetbots-264\" style=\"counter-reset: mw-Ref 258;\"><span class=\"mw-reflink-text\">[258]</span></a></span> Bots are able to indicate edits from particular accounts or <a href=\"/wiki/IP_address\" title=\"IP address\">IP address</a> ranges, as occurred at the time of the shooting down of the <a href=\"/wiki/Malaysia_Airlines_Flight_17\" title=\"Malaysia Airlines Flight 17\">MH17 jet</a> incident in July 2014 when it was reported edits were made via IPs controlled by the Russian government.<span class=\"mw-ref\" id=\"cite_ref-268\"><a href=\"#cite_note-268\" style=\"counter-reset: mw-Ref 262;\"><span class=\"mw-reflink-text\">[262]</span></a></span> Bots on Wikipedia must be approved before activation.<span class=\"mw-ref\" id=\"cite_ref-269\"><a href=\"#cite_note-269\" style=\"counter-reset: mw-Ref 263;\"><span class=\"mw-reflink-text\">[263]</span></a></span></p>\n\n<p>According to <a href=\"/wiki/Andrew_Lih\" title=\"Andrew Lih\">Andrew Lih</a>, the current expansion of Wikipedia to millions of articles would be difficult to envision without the use of such bots.<span class=\"mw-ref\" id=\"cite_ref-270\"><a href=\"#cite_note-270\" style=\"counter-reset: mw-Ref 264;\"><span class=\"mw-reflink-text\">[264]</span></a></span></p>\n\n","toclevel":2,"line":"Automated editing","anchor":"Automated_editing"},{"id":36,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt1809\">See also: <a href=\"/wiki/Wikimedia_Foundation#Hardware\" title=\"Wikimedia Foundation\">Wikimedia Foundation §<span>&nbsp;</span>Hardware</a></div>\n\n<p>Wikipedia receives between 25,000 and 60,000 page requests per second, depending on time of day.<span class=\"mw-ref\" id=\"cite_ref-WP_tools_requests_per_day_271-0\"><a href=\"#cite_note-WP_tools_requests_per_day-271\" style=\"counter-reset: mw-Ref 265;\"><span class=\"mw-reflink-text\">[265]</span></a></span><sup class=\"noprint Inline-Template \" style=\"white-space:nowrap;\">[<i><a href=\"/wiki/Wikipedia:Manual_of_Style/Dates_and_numbers#Chronological_items\" title=\"Wikipedia:Manual of Style/Dates and numbers\"><span>needs update</span></a></i>]</sup> <span>As of 2019</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>, page requests are first passed to a front-end layer of <a href=\"/wiki/Varnish_(software)\" title=\"Varnish (software)\">Varnish</a> caching servers.<span class=\"mw-ref\" id=\"cite_ref-272\"><a href=\"#cite_note-272\" style=\"counter-reset: mw-Ref 266;\"><span class=\"mw-reflink-text\">[266]</span></a></span> Further statistics, based on a publicly available 3-month Wikipedia access trace, are available.<span class=\"mw-ref\" id=\"cite_ref-globule_access_trace_273-0\"><a href=\"#cite_note-globule_access_trace-273\" style=\"counter-reset: mw-Ref 267;\"><span class=\"mw-reflink-text\">[267]</span></a></span> Requests that cannot be served from the Varnish cache are sent to load-balancing servers running the <a href=\"/wiki/Linux_Virtual_Server\" title=\"Linux Virtual Server\">Linux Virtual Server</a> software, which in turn pass them to one of the Apache web servers for page rendering from the database. The web servers deliver pages as requested, performing page rendering for all the language editions of Wikipedia. To increase speed further, rendered pages are cached in a distributed memory cache until invalidated, allowing page rendering to be skipped entirely for most common page accesses.</p>\n<figure class=\"mw-default-size mw-halign-center\"><a href=\"/wiki/File:Wikipedia_webrequest_flow_2015-10.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/5/51/Wikipedia_webrequest_flow_2015-10.png/220px-Wikipedia_webrequest_flow_2015-10.png\" data-file-width=\"1303\" data-file-height=\"1672\" data-file-type=\"bitmap\" height=\"282\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/5/51/Wikipedia_webrequest_flow_2015-10.png/440px-Wikipedia_webrequest_flow_2015-10.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/5/51/Wikipedia_webrequest_flow_2015-10.png/330px-Wikipedia_webrequest_flow_2015-10.png 1.5x\"></a><figcaption>Overview of system architecture <span>as of October</span><span>&nbsp;</span><span>2015</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup></figcaption></figure>\n\n<p>Wikipedia currently runs on dedicated <a href=\"/wiki/Computer_cluster\" title=\"Computer cluster\">clusters</a> of <a href=\"/wiki/Linux\" title=\"Linux\">Linux</a> servers (mainly <a href=\"/wiki/Ubuntu_(operating_system)\" title=\"Ubuntu (operating system)\" class=\"mw-redirect\">Ubuntu</a>).<span class=\"mw-ref\" id=\"cite_ref-CW_WP_simplifies_infrastructure_274-0\"><a href=\"#cite_note-CW_WP_simplifies_infrastructure-274\" style=\"counter-reset: mw-Ref 268;\"><span class=\"mw-reflink-text\">[268]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-ars_tech_Ubuntu_server_infra_275-0\"><a href=\"#cite_note-ars_tech_Ubuntu_server_infra-275\" style=\"counter-reset: mw-Ref 269;\"><span class=\"mw-reflink-text\">[269]</span></a></span> <span>As of December</span><span>&nbsp;</span><span>2009</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup>, there were 300 in Florida and 44 in <a href=\"/wiki/Amsterdam\" title=\"Amsterdam\">Amsterdam</a>.<span class=\"mw-ref\" id=\"cite_ref-servers_276-0\"><a href=\"#cite_note-servers-276\" style=\"counter-reset: mw-Ref 270;\"><span class=\"mw-reflink-text\">[270]</span></a></span> By January 22, 2013, Wikipedia had migrated its primary data center to an <a href=\"/wiki/Equinix\" title=\"Equinix\">Equinix</a> facility in <a href=\"/wiki/Ashburn,_Virginia\" title=\"Ashburn, Virginia\">Ashburn, Virginia</a>.<span class=\"mw-ref\" id=\"cite_ref-277\"><a href=\"#cite_note-277\" style=\"counter-reset: mw-Ref 271;\"><span class=\"mw-reflink-text\">[271]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-278\"><a href=\"#cite_note-278\" style=\"counter-reset: mw-Ref 272;\"><span class=\"mw-reflink-text\">[272]</span></a></span> in 2017, Wikipedia had installed a caching cluster in an Equinix facility in <a href=\"/wiki/Singapore\" title=\"Singapore\">Singapore</a>, the first of its kind in Asia.<span class=\"mw-ref\" id=\"cite_ref-279\"><a href=\"#cite_note-279\" style=\"counter-reset: mw-Ref 273;\"><span class=\"mw-reflink-text\">[273]</span></a></span></p>\n\n","toclevel":2,"line":"Hardware operations and support","anchor":"Hardware_operations_and_support"},{"id":37,"text":"\n\n<p>In accordance with growing amounts of incoming donations exceeding seven digits in 2013 as recently reported,<span class=\"mw-ref\" id=\"cite_ref-Simonite-2013_62-2\"><a href=\"#cite_note-Simonite-2013-62\" style=\"counter-reset: mw-Ref 60;\"><span class=\"mw-reflink-text\">[60]</span></a></span> the Foundation has reached a threshold of assets which qualify its consideration under the principles of <a href=\"/wiki/Industrial_organization\" title=\"Industrial organization\">industrial organization</a> economics to indicate the need for the re-investment of donations into the internal research and development of the Foundation.<span class=\"mw-ref\" id=\"cite_ref-autogenerated5_280-0\"><a href=\"#cite_note-autogenerated5-280\" style=\"counter-reset: mw-Ref 274;\"><span class=\"mw-reflink-text\">[274]</span></a></span> Two of the recent projects of such internal research and development have been the creation of a Visual Editor and a largely under-utilized \"Thank\" tab which were developed for the purpose of ameliorating issues of editor attrition, which have met with limited success.<span class=\"mw-ref\" id=\"cite_ref-Simonite-2013_62-3\"><a href=\"#cite_note-Simonite-2013-62\" style=\"counter-reset: mw-Ref 60;\"><span class=\"mw-reflink-text\">[60]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Orlowski,_Andrew_262-1\"><a href=\"#cite_note-Orlowski,_Andrew-262\" style=\"counter-reset: mw-Ref 256;\"><span class=\"mw-reflink-text\">[256]</span></a></span> The estimates for reinvestment by industrial organizations into internal research and development was studied by Adam Jaffe, who recorded that the range of 4% to 25% annually was to be recommended, with high end technology requiring the higher level of support for internal reinvestment.<span class=\"mw-ref\" id=\"cite_ref-Patents,_Citations_pp_89-153_281-0\"><a href=\"#cite_note-Patents,_Citations_pp_89-153-281\" style=\"counter-reset: mw-Ref 275;\"><span class=\"mw-reflink-text\">[275]</span></a></span> At the 2013 level of contributions for Wikimedia presently documented as 45<span>&nbsp;</span>million dollars, the computed budget level recommended by Jaffe and Caballero for reinvestment into internal research and development is between 1.8<span>&nbsp;</span>million and 11.3<span>&nbsp;</span>million dollars annually.<span class=\"mw-ref\" id=\"cite_ref-Patents,_Citations_pp_89-153_281-1\"><a href=\"#cite_note-Patents,_Citations_pp_89-153-281\" style=\"counter-reset: mw-Ref 275;\"><span class=\"mw-reflink-text\">[275]</span></a></span> In 2016, the level of contributions were reported by<i> Bloomberg News</i> as being at $77<span>&nbsp;</span>million annually, updating the Jaffe estimates for the higher level of support to between $3.08<span>&nbsp;</span>million and $19.2<span>&nbsp;</span>million annually.<span class=\"mw-ref\" id=\"cite_ref-Patents,_Citations_pp_89-153_281-2\"><a href=\"#cite_note-Patents,_Citations_pp_89-153-281\" style=\"counter-reset: mw-Ref 275;\"><span class=\"mw-reflink-text\">[275]</span></a></span></p>\n\n","toclevel":2,"line":"Internal research and operational development","anchor":"Internal_research_and_operational_development"},{"id":38,"text":"\n\n<p>Community-produced news publications include the <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia's</a> <a href=\"/wiki/Wikipedia:Signpost\" title=\"Wikipedia:Signpost\" class=\"mw-redirect\"><i>The Signpost</i></a>, founded in 2005 by Michael Snow, an attorney, Wikipedia administrator and former chair of the <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a> board of trustees.<span class=\"mw-ref\" id=\"cite_ref-282\"><a href=\"#cite_note-282\" style=\"counter-reset: mw-Ref 276;\"><span class=\"mw-reflink-text\">[276]</span></a></span> It covers news and events from the site, as well as major events from other <a href=\"/wiki/Wikimedia_project\" title=\"Wikimedia project\" class=\"mw-redirect\">Wikimedia projects</a>, such as <a href=\"/wiki/Wikimedia_Commons\" title=\"Wikimedia Commons\">Wikimedia Commons</a>. Similar publications are the German-language <a href=\"https://de.wikipedia.org/wiki/WP:Kurier\" title=\"de:WP:Kurier\"><i>Kurier</i></a>, and the Portuguese-language <a href=\"https://pt.wikipedia.org/wiki/wp:Correio%20da%20Wikipédia\" title=\"pt:wp:Correio da Wikipédia\"><i>Correio da Wikipédia</i></a>. Other past and present community news publications on English Wikipedia include the <i>Wikiworld</i> webcomic, the <a href=\"/wiki/Wikipedia:Wikipedia_Weekly\" title=\"Wikipedia:Wikipedia Weekly\" class=\"mw-redirect\">Wikipedia Weekly</a> podcast, and newsletters of specific WikiProjects like <a href=\"/wiki/Wikipedia:BUGLE\" title=\"Wikipedia:BUGLE\" class=\"mw-redirect\"><i>The Bugle</i></a> from <a href=\"/wiki/Wikipedia:Milhist\" title=\"Wikipedia:Milhist\" class=\"mw-redirect\">WikiProject Military History</a> and the monthly newsletter from <a href=\"/wiki/Wikipedia:GOCE\" title=\"Wikipedia:GOCE\" class=\"mw-redirect\">The Guild of Copy Editors</a>. There are also a number of publications from the Wikimedia Foundation and multilingual publications such as the <a rel=\"mw:ExtLink\" href=\"http://blog.wikimedia.org/\" class=\"external text\">Wikimedia Blog</a> and <i><a href=\"https://outreach.wikimedia.org/wiki/This%20Month%20in%20Education\" title=\"outreach:This Month in Education\">This Month in Education</a></i>.</p>\n\n","toclevel":2,"line":"Internal news publications","anchor":"Internal_news_publications"},{"id":39,"text":"\n","toclevel":1,"line":"Access to content","anchor":"Access_to_content"},{"id":40,"text":"\n\n<p>When the project was started in 2001, all text in Wikipedia was covered by the <a href=\"/wiki/GNU_Free_Documentation_License\" title=\"GNU Free Documentation License\">GNU Free Documentation License</a> (GFDL), a <a href=\"/wiki/Copyleft\" title=\"Copyleft\">copyleft</a> license permitting the redistribution, creation of derivative works, and commercial use of content while authors retain copyright of their work.<span class=\"mw-ref\" id=\"cite_ref-WP_copyright_and_commerciality_1_283-0\"><a href=\"#cite_note-WP_copyright_and_commerciality_1-283\" style=\"counter-reset: mw-Ref 277;\"><span class=\"mw-reflink-text\">[277]</span></a></span> The GFDL was created for software manuals that come with <a href=\"/wiki/Free_software\" title=\"Free software\">free software</a> programs licensed under the <a href=\"/wiki/GPL\" title=\"GPL\" class=\"mw-redirect\">GPL</a>. This made it a poor choice for a general reference work: for example, the GFDL requires the reprints of materials from Wikipedia to come with a full copy of the GFDL text. In December 2002, the <a href=\"/wiki/Creative_Commons_license\" title=\"Creative Commons license\">Creative Commons license</a> was released: it was specifically designed for creative works in general, not just for software manuals. The license gained popularity among bloggers and others distributing creative works on the Web. The Wikipedia project sought the switch to the Creative Commons.<span class=\"mw-ref\" id=\"cite_ref-WPF_switch_to_CC_284-0\"><a href=\"#cite_note-WPF_switch_to_CC-284\" style=\"counter-reset: mw-Ref 278;\"><span class=\"mw-reflink-text\">[278]</span></a></span> Because the two licenses, GFDL and Creative Commons, were incompatible, in November 2008, following the request of the project, the <a href=\"/wiki/Free_Software_Foundation\" title=\"Free Software Foundation\">Free Software Foundation</a> (FSF) released a new version of the GFDL designed specifically to allow Wikipedia to <a href=\"/wiki/Wikipedia:Licensing_update\" title=\"Wikipedia:Licensing update\">relicense its content to CC BY-SA</a> by August 1, 2009. (A new version of the GFDL automatically covers Wikipedia contents.) In April 2009, Wikipedia and its sister projects held a community-wide referendum which decided the switch in June 2009.<span class=\"mw-ref\" id=\"cite_ref-voteresult_285-0\"><a href=\"#cite_note-voteresult-285\" style=\"counter-reset: mw-Ref 279;\"><span class=\"mw-reflink-text\">[279]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-MW_licensing_QA_286-0\"><a href=\"#cite_note-MW_licensing_QA-286\" style=\"counter-reset: mw-Ref 280;\"><span class=\"mw-reflink-text\">[280]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-MW_licensing_timeline_1_287-0\"><a href=\"#cite_note-MW_licensing_timeline_1-287\" style=\"counter-reset: mw-Ref 281;\"><span class=\"mw-reflink-text\">[281]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-WP_blog_license_migration_288-0\"><a href=\"#cite_note-WP_blog_license_migration-288\" style=\"counter-reset: mw-Ref 282;\"><span class=\"mw-reflink-text\">[282]</span></a></span></p>\n\n<p>The handling of media files (e.g. image files) varies across language editions. Some language editions, such as the English Wikipedia, include non-free image files under <a href=\"/wiki/Fair_use\" title=\"Fair use\">fair use</a> doctrine, while the others have opted not to, in part because of the lack of fair use doctrines in their home countries (e.g. in <a href=\"/wiki/Copyright_law_of_Japan\" title=\"Copyright law of Japan\">Japanese copyright law</a>). Media files covered by <a href=\"/wiki/Free_content\" title=\"Free content\">free content</a> licenses (e.g. <a href=\"/wiki/Creative_Commons\" title=\"Creative Commons\">Creative Commons</a>' CC BY-SA) are shared across language editions via <a href=\"/wiki/Wikimedia_Commons\" title=\"Wikimedia Commons\">Wikimedia Commons</a> repository, a project operated by the Wikimedia Foundation. Wikipedia's accommodation of varying international copyright laws regarding images has led some to observe that its photographic coverage of topics lags behind the quality of the encyclopedic text.<span class=\"mw-ref\" id=\"cite_ref-NYT_photos_on_WP_289-0\"><a href=\"#cite_note-NYT_photos_on_WP-289\" style=\"counter-reset: mw-Ref 283;\"><span class=\"mw-reflink-text\">[283]</span></a></span></p>\n\n<p>The Wikimedia Foundation is not a licensor of content, but merely a hosting service for the contributors (and licensors) of the Wikipedia. This position has been successfully defended in court.<span class=\"mw-ref\" id=\"cite_ref-reuters_French_defamation_case_290-0\"><a href=\"#cite_note-reuters_French_defamation_case-290\" style=\"counter-reset: mw-Ref 284;\"><span class=\"mw-reflink-text\">[284]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-ars_tech_WP_dumb_suing_case_291-0\"><a href=\"#cite_note-ars_tech_WP_dumb_suing_case-291\" style=\"counter-reset: mw-Ref 285;\"><span class=\"mw-reflink-text\">[285]</span></a></span></p>\n\n","toclevel":2,"line":"Content licensing","anchor":"Content_licensing"},{"id":41,"text":"\n\n<p>Because Wikipedia content is distributed under an open license, anyone can reuse or re-distribute it at no charge. The content of Wikipedia has been published in many forms, both online and offline, outside the Wikipedia website.</p>\n<ul><li><b>Websites</b>: Thousands of \"<a href=\"/wiki/Mirror_website\" title=\"Mirror website\" class=\"mw-redirect\">mirror sites</a>\" exist that republish content from Wikipedia: two prominent ones, that also include content from other reference sources, are <a href=\"/wiki/Reference.com\" title=\"Reference.com\">Reference.com</a> and <a href=\"/wiki/Answers.com\" title=\"Answers.com\">Answers.com</a>. Another example is <a href=\"/wiki/Wapedia\" title=\"Wapedia\">Wapedia</a>, which began to display Wikipedia content in a mobile-device-friendly format before Wikipedia itself did.</li>\n<li><b>Mobile apps</b>: A variety of mobile apps provide access to Wikipedia on <a href=\"/wiki/Hand-held_device\" title=\"Hand-held device\" class=\"mw-redirect\">hand-held devices</a>, including both <a href=\"/wiki/Android_(operating_system)\" title=\"Android (operating system)\">Android</a> and <a href=\"/wiki/IOS\" title=\"IOS\">iOS</a> devices (see <a href=\"/wiki/Wikipedia_App\" title=\"Wikipedia App\" class=\"mw-redirect\">Wikipedia apps</a>). (See also <a href=\"#Mobile_access\">Mobile access</a>.)</li>\n<li><b>Search engines</b>: Some <a href=\"/wiki/Web_search_engine\" title=\"Web search engine\">web search engines</a> make special use of Wikipedia content when displaying search results: examples include <a href=\"/wiki/Bing_(search_engine)\" title=\"Bing (search engine)\">Bing</a> (via technology gained from <a href=\"/wiki/Powerset_(company)\" title=\"Powerset (company)\">Powerset</a>)<span class=\"mw-ref\" id=\"cite_ref-bing_WP_research_and_referencing_292-0\"><a href=\"#cite_note-bing_WP_research_and_referencing-292\" style=\"counter-reset: mw-Ref 286;\"><span class=\"mw-reflink-text\">[286]</span></a></span> and <a href=\"/wiki/DuckDuckGo\" title=\"DuckDuckGo\">DuckDuckGo</a>.</li>\n<li><b>Compact discs, DVDs</b>: Collections of Wikipedia articles have been published on <a href=\"/wiki/Optical_disc\" title=\"Optical disc\">optical discs</a>. An English version, <a href=\"/wiki/Wikipedia_CD_Selection\" title=\"Wikipedia CD Selection\" class=\"mw-redirect\">2006 Wikipedia CD Selection</a>, contained about 2,000 articles.<span class=\"mw-ref\" id=\"cite_ref-wikipediaondvd_authorized_1_293-0\"><a href=\"#cite_note-wikipediaondvd_authorized_1-293\" style=\"counter-reset: mw-Ref 287;\"><span class=\"mw-reflink-text\">[287]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-wikipediaondvd_commercially_available_1_294-0\"><a href=\"#cite_note-wikipediaondvd_commercially_available_1-294\" style=\"counter-reset: mw-Ref 288;\"><span class=\"mw-reflink-text\">[288]</span></a></span> The Polish-language version contains nearly 240,000 articles.<span class=\"mw-ref\" id=\"cite_ref-WM_polish_WP_on_dvd_295-0\"><a href=\"#cite_note-WM_polish_WP_on_dvd-295\" style=\"counter-reset: mw-Ref 289;\"><span class=\"mw-reflink-text\">[289]</span></a></span> There are German- and Spanish-language versions as well.<span class=\"mw-ref\" id=\"cite_ref-WP_german_on_dvd_1_296-0\"><a href=\"#cite_note-WP_german_on_dvd_1-296\" style=\"counter-reset: mw-Ref 290;\"><span class=\"mw-reflink-text\">[290]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-python.org_CDPedia_Argentina_1_297-0\"><a href=\"#cite_note-python.org_CDPedia_Argentina_1-297\" style=\"counter-reset: mw-Ref 291;\"><span class=\"mw-reflink-text\">[291]</span></a></span> Also, \"Wikipedia for Schools\", the Wikipedia series of CDs / DVDs produced by Wikipedians and <a href=\"/wiki/SOS_Children's_Villages_UK\" title=\"SOS Children's Villages UK\">SOS Children</a>, is a free, hand-checked, non-commercial selection from Wikipedia targeted around the <a href=\"/wiki/National_Curriculum_(UK)\" title=\"National Curriculum (UK)\" class=\"mw-redirect\">UK National Curriculum</a> and intended to be useful for much of the English-speaking world.<span class=\"mw-ref\" id=\"cite_ref-WP_CD_selection_1_298-0\"><a href=\"#cite_note-WP_CD_selection_1-298\" style=\"counter-reset: mw-Ref 292;\"><span class=\"mw-reflink-text\">[292]</span></a></span> The project is available online; an equivalent print encyclopedia would require roughly 20 volumes.</li>\n<li><b>Printed books</b>: There are efforts to put a select subset of Wikipedia's articles into printed book form.<span class=\"mw-ref\" id=\"cite_ref-WP_into_books_1_299-0\"><a href=\"#cite_note-WP_into_books_1-299\" style=\"counter-reset: mw-Ref 293;\"><span class=\"mw-reflink-text\">[293]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-WP_schools_selection_1_300-0\"><a href=\"#cite_note-WP_schools_selection_1-300\" style=\"counter-reset: mw-Ref 294;\"><span class=\"mw-reflink-text\">[294]</span></a></span> Since 2009, tens of thousands of <a href=\"/wiki/Print_on_demand\" title=\"Print on demand\">print-on-demand</a> books that reproduced English, German, Russian and French Wikipedia articles have been produced by the American company <a href=\"/wiki/Books_LLC\" title=\"Books LLC\">Books LLC</a> and by three <a href=\"/wiki/Mauritius\" title=\"Mauritius\">Mauritian</a> subsidiaries of the German publisher <a href=\"/wiki/VDM_Publishing\" title=\"VDM Publishing\" class=\"mw-redirect\">VDM</a>.<span class=\"mw-ref\" id=\"cite_ref-FAZ_301-0\"><a href=\"#cite_note-FAZ-301\" style=\"counter-reset: mw-Ref 295;\"><span class=\"mw-reflink-text\">[295]</span></a></span></li>\n<li><b>Semantic Web</b>: The website <a href=\"/wiki/DBpedia\" title=\"DBpedia\">DBpedia</a>, begun in 2007, extracts data from the infoboxes and category declarations of the English-language Wikipedia. Wikimedia has created the <a href=\"/wiki/Wikidata\" title=\"Wikidata\">Wikidata</a> project with a similar objective of storing the basic facts from each page of Wikipedia and the other WMF wikis and make it available in a queriable <a href=\"/wiki/Semantic_Web\" title=\"Semantic Web\">semantic</a> format, <a href=\"/wiki/Resource_Description_Framework\" title=\"Resource Description Framework\">RDF</a>. This is still under development. As of February 2014 it has 15,000,000 items and 1,000 properties for describing them.</li></ul>\n\n<p>Obtaining the full contents of Wikipedia for reuse presents challenges, since direct cloning via a <a href=\"/wiki/Web_crawler\" title=\"Web crawler\">web crawler</a> is discouraged.<span class=\"mw-ref\" id=\"cite_ref-WP_DB_usage_policy_1_302-0\"><a href=\"#cite_note-WP_DB_usage_policy_1-302\" style=\"counter-reset: mw-Ref 296;\"><span class=\"mw-reflink-text\">[296]</span></a></span> Wikipedia publishes <a href=\"/wiki/Wikipedia:Database_download\" title=\"Wikipedia:Database download\">\"dumps\"</a> of its contents, but these are text-only; <span>as of 2007</span><sup class=\"plainlinks noexcerpt noprint asof-tag update\" style=\"display:none;\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Wikipedia&amp;action=edit\" class=\"external text\">[update]</a></sup> there was no dump available of Wikipedia's images.<span class=\"mw-ref\" id=\"cite_ref-WP_image_data_dumps_1_303-0\"><a href=\"#cite_note-WP_image_data_dumps_1-303\" style=\"counter-reset: mw-Ref 297;\"><span class=\"mw-reflink-text\">[297]</span></a></span></p>\n\n<p>Several languages of Wikipedia also maintain a <a href=\"/wiki/Wikipedia:REFDESK\" title=\"Wikipedia:REFDESK\" class=\"mw-redirect\">reference desk</a>, where volunteers answer questions from the general public. According to a study by Pnina Shachaf in the <i><a href=\"/wiki/Journal_of_Documentation\" title=\"Journal of Documentation\">Journal of Documentation</a></i>, the quality of the Wikipedia reference desk is comparable to a standard <a href=\"/wiki/Library_reference_desk\" title=\"Library reference desk\" class=\"mw-redirect\">library reference desk</a>, with an accuracy of 55 percent.<span class=\"mw-ref\" id=\"cite_ref-slis_WP_reference_desk_1_304-0\"><a href=\"#cite_note-slis_WP_reference_desk_1-304\" style=\"counter-reset: mw-Ref 298;\"><span class=\"mw-reflink-text\">[298]</span></a></span></p>\n\n","toclevel":2,"line":"Methods of access","anchor":"Methods_of_access"},{"id":42,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt2034\">See also: <a href=\"/wiki/Help:Mobile_access\" title=\"Help:Mobile access\">Help:Mobile access</a></div>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Wikipedia_on_Mobile_screenshot_2019.png\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Wikipedia_on_Mobile_screenshot_2019.png/220px-Wikipedia_on_Mobile_screenshot_2019.png\" data-file-width=\"1080\" data-file-height=\"1618\" data-file-type=\"bitmap\" height=\"330\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Wikipedia_on_Mobile_screenshot_2019.png/440px-Wikipedia_on_Mobile_screenshot_2019.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/4/4a/Wikipedia_on_Mobile_screenshot_2019.png/330px-Wikipedia_on_Mobile_screenshot_2019.png 1.5x\"></a><figcaption>The mobile version of the English Wikipedia's main page</figcaption></figure>\n\n<p>Wikipedia's original medium was for users to read and edit content using any standard <a href=\"/wiki/Web_browser\" title=\"Web browser\">web browser</a> through a fixed <a href=\"/wiki/Internet_access\" title=\"Internet access\">Internet connection</a>. Although Wikipedia content has been accessible through the <a href=\"/wiki/Mobile_web\" title=\"Mobile web\">mobile web</a> since July 2013, <i>The New York Times</i> on February 9, 2014, quoted Erik Möller, deputy director of the Wikimedia Foundation, stating that the transition of internet traffic from desktops to mobile devices was significant and a cause for concern and worry.<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-2\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span> The article in <i>The New York Times</i> reported the comparison statistics for mobile edits stating that, \"Only 20 percent of the readership of the English-language Wikipedia comes via mobile devices, a figure substantially lower than the percentage of mobile traffic for other media sites, many of which approach 50 percent. And the shift to mobile editing has lagged even more.\"<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-3\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span> <i>The New York Times</i> reports that Möller has assigned \"a team of 10 software developers focused on mobile\", out of a total of approximately 200 employees working at the Wikimedia Foundation. One principal concern cited by <i>The New York Times</i> for the \"worry\" is for Wikipedia to effectively address attrition issues with the number of editors which the online encyclopedia attracts to edit and maintain its content in a mobile access environment.<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-4\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span></p>\n\n<p><i><a href=\"/wiki/Bloomberg_Businessweek\" title=\"Bloomberg Businessweek\">Bloomberg Businessweek</a></i> reported in July 2014 that Google's Android mobile apps have dominated the largest share of global smartphone shipments for 2013 with 78.6% of market share over their next closest competitor in iOS with 15.2% of the market.<span class=\"mw-ref\" id=\"cite_ref-305\"><a href=\"#cite_note-305\" style=\"counter-reset: mw-Ref 299;\"><span class=\"mw-reflink-text\">[299]</span></a></span> At the time of the Tretikov appointment and her posted web interview with <a href=\"/wiki/Sue_Gardner\" title=\"Sue Gardner\">Sue Gardner</a> in May 2014, Wikimedia representatives made a technical announcement concerning the number of mobile access systems in the market seeking access to Wikipedia. Directly after the posted web interview, the representatives stated that Wikimedia would be applying an all-inclusive approach to accommodate as many mobile access systems as possible in its efforts for expanding general mobile access, including BlackBerry and the Windows Phone system, making market share a secondary issue.<span class=\"mw-ref\" id=\"cite_ref-nytimes.com_249-1\"><a href=\"#cite_note-nytimes.com-249\" style=\"counter-reset: mw-Ref 243;\"><span class=\"mw-reflink-text\">[243]</span></a></span> The latest version of the Android app for Wikipedia was released on July 23, 2014, to generally positive reviews, scoring over four of a possible five in a poll of approximately 200,000 users downloading from Google.<span class=\"mw-ref\" id=\"cite_ref-306\"><a href=\"#cite_note-306\" style=\"counter-reset: mw-Ref 300;\"><span class=\"mw-reflink-text\">[300]</span></a></span> The latest version for iOS was released on April 3, 2013, to similar reviews.<span class=\"mw-ref\" id=\"cite_ref-307\"><a href=\"#cite_note-307\" style=\"counter-reset: mw-Ref 301;\"><span class=\"mw-reflink-text\">[301]</span></a></span></p>\n\n<p>Access to Wikipedia from mobile phones was possible as early as 2004, through the <a href=\"/wiki/Wireless_Application_Protocol\" title=\"Wireless Application Protocol\">Wireless Application Protocol</a> (WAP), via the <a href=\"/wiki/Wapedia\" title=\"Wapedia\">Wapedia</a> service. In June 2007 Wikipedia launched <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20090112031222/http://en.mobile.wikipedia.org/\" class=\"external text\">en.mobile.wikipedia.org</a>, an official website for wireless devices. In 2009 a newer mobile service was officially released,<span class=\"mw-ref\" id=\"cite_ref-WM_mobile_added_1_308-0\"><a href=\"#cite_note-WM_mobile_added_1-308\" style=\"counter-reset: mw-Ref 302;\"><span class=\"mw-reflink-text\">[302]</span></a></span> located at <a rel=\"mw:ExtLink\" href=\"https://en.m.wikipedia.org/\" class=\"external text\">en.m.wikipedia.org</a>, which caters to more advanced mobile devices such as the <a href=\"/wiki/IPhone\" title=\"IPhone\">iPhone</a>, <a href=\"/wiki/Android_(operating_system)\" title=\"Android (operating system)\">Android</a>-based devices or <a href=\"/wiki/WebOS\" title=\"WebOS\">WebOS</a>-based devices. Several other methods of mobile access to Wikipedia have emerged. Many devices and applications optimize or enhance the display of Wikipedia content for mobile devices, while some also incorporate additional features such as use of Wikipedia <a href=\"/wiki/Metadata\" title=\"Metadata\">metadata</a> (See <a href=\"/wiki/Wikipedia:Metadata\" title=\"Wikipedia:Metadata\" class=\"mw-disambig\">Wikipedia:Metadata</a>), such as <a href=\"/wiki/Geoinformation\" title=\"Geoinformation\" class=\"mw-redirect\">geoinformation</a>.<span class=\"mw-ref\" id=\"cite_ref-androgeoid.com_LPOI_WP_1_309-0\"><a href=\"#cite_note-androgeoid.com_LPOI_WP_1-309\" style=\"counter-reset: mw-Ref 303;\"><span class=\"mw-reflink-text\">[303]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-ilounge_iphone_gems_WP_310-0\"><a href=\"#cite_note-ilounge_iphone_gems_WP-310\" style=\"counter-reset: mw-Ref 304;\"><span class=\"mw-reflink-text\">[304]</span></a></span></p>\n\n<p><a href=\"/wiki/Wikipedia_Zero\" title=\"Wikipedia Zero\">Wikipedia Zero</a> was an initiative of the Wikimedia Foundation to expand the reach of the encyclopedia to the developing countries.<span class=\"mw-ref\" id=\"cite_ref-311\"><a href=\"#cite_note-311\" style=\"counter-reset: mw-Ref 305;\"><span class=\"mw-reflink-text\">[305]</span></a></span> It was discontinued in February 2018.<span class=\"mw-ref\" id=\"cite_ref-312\"><a href=\"#cite_note-312\" style=\"counter-reset: mw-Ref 306;\"><span class=\"mw-reflink-text\">[306]</span></a></span></p>\n\n<p><a href=\"/wiki/Andrew_Lih\" title=\"Andrew Lih\">Andrew Lih</a> and <a href=\"/wiki/Andrew_Brown_(writer)\" title=\"Andrew Brown (writer)\">Andrew Brown</a> both maintain editing Wikipedia with <a href=\"/wiki/Smartphone\" title=\"Smartphone\">smartphones</a> is difficult and this discourages new potential contributors. Several years running the number of Wikipedia editors has been falling and Tom Simonite of <i><a href=\"/wiki/MIT_Technology_Review\" title=\"MIT Technology Review\">MIT Technology Review</a></i> claims the bureaucratic structure and rules are a factor in this. Simonite alleges some <a href=\"/wiki/Wikipedian\" title=\"Wikipedian\" class=\"mw-redirect\">Wikipedians</a> use the labyrinthine rules and guidelines to dominate others and those editors have a vested interest in keeping the <a href=\"/wiki/Status_quo\" title=\"Status quo\">status quo</a>.<span class=\"mw-ref\" id=\"cite_ref-Simonite-2013_62-4\"><a href=\"#cite_note-Simonite-2013-62\" style=\"counter-reset: mw-Ref 60;\"><span class=\"mw-reflink-text\">[60]</span></a></span> Lih alleges there is a serious disagreement among existing contributors on how to resolve this. Lih fears for Wikipedia's long-term future while Brown fears problems with Wikipedia will remain and rival encyclopedias will not replace it.<span class=\"mw-ref\" id=\"cite_ref-313\"><a href=\"#cite_note-313\" style=\"counter-reset: mw-Ref 307;\"><span class=\"mw-reflink-text\">[307]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-314\"><a href=\"#cite_note-314\" style=\"counter-reset: mw-Ref 308;\"><span class=\"mw-reflink-text\">[308]</span></a></span></p>\n\n","toclevel":3,"line":"Mobile access","anchor":"Mobile_access"},{"id":43,"text":"\n","toclevel":1,"line":"Cultural impact","anchor":"Cultural_impact"},{"id":44,"text":"\n\n<p>In 2017–18, after a barrage of false news reports, both Facebook and YouTube announced they would rely on Wikipedia to help their users evaluate reports and reject false news. <a href=\"/wiki/Noam_Cohen\" title=\"Noam Cohen\">Noam Cohen</a>, writing in <i>The Washington Post</i> states, \"YouTube's reliance on Wikipedia to set the record straight builds on the thinking of another fact-challenged platform, the Facebook social network, which announced last year that Wikipedia would help its users root out 'fake news'.\"<span class=\"mw-ref\" id=\"cite_ref-auto_31-1\"><a href=\"#cite_note-auto-31\" style=\"counter-reset: mw-Ref 29;\"><span class=\"mw-reflink-text\">[29]</span></a></span> In answer to the question of 'how engaged are visitors to the site?' Alexa records the daily pageviews per visitor as 3.04 and the daily time on site as 4.01 minutes.<span class=\"mw-ref\" id=\"cite_ref-Alexa_siteinfo_11-3\"><a href=\"#cite_note-Alexa_siteinfo-11\" style=\"counter-reset: mw-Ref 9;\"><span class=\"mw-reflink-text\">[9]</span></a></span></p>\n\n","toclevel":2,"line":"Trusted source to combat fake news","anchor":"Trusted_source_to_combat_fake_news"},{"id":45,"text":"\n\n<p>In February 2014, <i>The New York Times</i> reported that Wikipedia is ranked fifth globally among all websites, stating \"With 18 billion page views and nearly 500 million unique visitors a month [...] Wikipedia trails just Yahoo, Facebook, Microsoft and Google, the largest with 1.2 billion unique visitors.\"<span class=\"mw-ref\" id=\"cite_ref-small_screen_21-5\"><a href=\"#cite_note-small_screen-21\" style=\"counter-reset: mw-Ref 19;\"><span class=\"mw-reflink-text\">[19]</span></a></span></p>\n\n<p>In addition to <a href=\"/wiki/Logistic_function\" title=\"Logistic function\">logistic growth</a> in the number of its articles,<span class=\"mw-ref\" id=\"cite_ref-modelling_315-0\"><a href=\"#cite_note-modelling-315\" style=\"counter-reset: mw-Ref 309;\"><span class=\"mw-reflink-text\">[309]</span></a></span> Wikipedia has steadily gained status as a general reference website since its inception in 2001.<span class=\"mw-ref\" id=\"cite_ref-comscore_316-0\"><a href=\"#cite_note-comscore-316\" style=\"counter-reset: mw-Ref 310;\"><span class=\"mw-reflink-text\">[310]</span></a></span> About 50 percent of search engine traffic to Wikipedia comes from Google,<span class=\"mw-ref\" id=\"cite_ref-hitwisegoogle_317-0\"><a href=\"#cite_note-hitwisegoogle-317\" style=\"counter-reset: mw-Ref 311;\"><span class=\"mw-reflink-text\">[311]</span></a></span> a good portion of which is related to academic research.<span class=\"mw-ref\" id=\"cite_ref-hitwiseAcademic_318-0\"><a href=\"#cite_note-hitwiseAcademic-318\" style=\"counter-reset: mw-Ref 312;\"><span class=\"mw-reflink-text\">[312]</span></a></span> The number of readers of Wikipedia worldwide reached 365<span>&nbsp;</span>million at the end of 2009.<span class=\"mw-ref\" id=\"cite_ref-365M_319-0\"><a href=\"#cite_note-365M-319\" style=\"counter-reset: mw-Ref 313;\"><span class=\"mw-reflink-text\">[313]</span></a></span> The <a href=\"/wiki/Pew_Research_Center\" title=\"Pew Research Center\">Pew</a> Internet and American Life project found that one third of US Internet users consulted Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-Wikipedia_users_320-0\"><a href=\"#cite_note-Wikipedia_users-320\" style=\"counter-reset: mw-Ref 314;\"><span class=\"mw-reflink-text\">[314]</span></a></span> In 2011 <i>Business Insider</i> gave Wikipedia a valuation of $4<span>&nbsp;</span>billion if it ran advertisements.<span class=\"mw-ref\" id=\"cite_ref-321\"><a href=\"#cite_note-321\" style=\"counter-reset: mw-Ref 315;\"><span class=\"mw-reflink-text\">[315]</span></a></span></p>\n\n<p>According to \"Wikipedia Readership Survey 2011\", the average age of Wikipedia readers is 36, with a rough parity between genders. Almost half of Wikipedia readers visit the site more than five times a month, and a similar number of readers specifically look for Wikipedia in search engine results. About 47 percent of Wikipedia readers do not realize that Wikipedia is a non-profit organization.<span class=\"mw-ref\" id=\"cite_ref-322\"><a href=\"#cite_note-322\" style=\"counter-reset: mw-Ref 316;\"><span class=\"mw-reflink-text\">[316]</span></a></span></p>\n\n","toclevel":2,"line":"Readership","anchor":"Readership"},{"id":46,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt2160\">Main article: <a href=\"/wiki/Wikipedia_in_culture\" title=\"Wikipedia in culture\">Wikipedia in culture</a></div>\n\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Wikipedia_Monument_in_Słubice_-_detail.JPG\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/40/Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG/220px-Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG\" data-file-width=\"3264\" data-file-height=\"2448\" data-file-type=\"bitmap\" height=\"165\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/40/Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG/440px-Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG 2x, //upload.wikimedia.org/wikipedia/commons/thumb/4/40/Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG/330px-Wikipedia_Monument_in_S%C5%82ubice_-_detail.JPG 1.5x\"></a><figcaption><i><a href=\"/wiki/Wikipedia_Monument\" title=\"Wikipedia Monument\">Wikipedia Monument</a></i> in <a href=\"/wiki/Słubice\" title=\"Słubice\">Słubice</a>, Poland (2014, by <a href=\"/wiki/Mihran_Hakobyan\" title=\"Mihran Hakobyan\">Mihran Hakobyan</a>)</figcaption></figure>\n\n<p>Wikipedia's content has also been used in academic studies, books, conferences, and court cases.<span class=\"mw-ref\" id=\"cite_ref-Wikipedia_in_media_323-0\"><a href=\"#cite_note-Wikipedia_in_media-323\" style=\"counter-reset: mw-Ref 317;\"><span class=\"mw-reflink-text\">[317]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-Bourgeois_324-0\"><a href=\"#cite_note-Bourgeois-324\" style=\"counter-reset: mw-Ref 318;\"><span class=\"mw-reflink-text\">[318]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-ssrn.com_Wikipedian_Justice_1_325-0\"><a href=\"#cite_note-ssrn.com_Wikipedian_Justice_1-325\" style=\"counter-reset: mw-Ref 319;\"><span class=\"mw-reflink-text\">[319]</span></a></span> The <a href=\"/wiki/Parliament_of_Canada\" title=\"Parliament of Canada\">Parliament of Canada</a>'s website refers to Wikipedia's article on <a href=\"/wiki/Same-sex_marriage\" title=\"Same-sex marriage\">same-sex marriage</a> in the \"related links\" section of its \"further reading\" list for the <i><a href=\"/wiki/Civil_Marriage_Act\" title=\"Civil Marriage Act\">Civil Marriage Act</a></i>.<span class=\"mw-ref\" id=\"cite_ref-parl.gc.ca_same-sex_marriage_326-0\"><a href=\"#cite_note-parl.gc.ca_same-sex_marriage-326\" style=\"counter-reset: mw-Ref 320;\"><span class=\"mw-reflink-text\">[320]</span></a></span> The encyclopedia's assertions are increasingly used as a source by organizations such as the US federal courts and the <a href=\"/wiki/World_Intellectual_Property_Organization\" title=\"World Intellectual Property Organization\">World Intellectual Property Organization</a><span class=\"mw-ref\" id=\"cite_ref-WP_court_source_327-0\"><a href=\"#cite_note-WP_court_source-327\" style=\"counter-reset: mw-Ref 321;\"><span class=\"mw-reflink-text\">[321]</span></a></span>—though mainly for <i>supporting information</i> rather than information decisive to a case.<span class=\"mw-ref\" id=\"cite_ref-Courts_turn_to_Wikipedia_328-0\"><a href=\"#cite_note-Courts_turn_to_Wikipedia-328\" style=\"counter-reset: mw-Ref 322;\"><span class=\"mw-reflink-text\">[322]</span></a></span> Content appearing on Wikipedia has also been cited as a source and referenced in some <a href=\"/wiki/United_States_Intelligence_Community\" title=\"United States Intelligence Community\">US intelligence agency</a> reports.<span class=\"mw-ref\" id=\"cite_ref-US_Intelligence_329-0\"><a href=\"#cite_note-US_Intelligence-329\" style=\"counter-reset: mw-Ref 323;\"><span class=\"mw-reflink-text\">[323]</span></a></span> In December 2008, the scientific journal <i><a href=\"/wiki/RNA_Biology\" title=\"RNA Biology\">RNA Biology</a></i> launched a new section for descriptions of families of RNA molecules and requires authors who contribute to the section to also submit a draft article on the <a href=\"/wiki/Rfam\" title=\"Rfam\">RNA family</a> for publication in Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-Declan_330-0\"><a href=\"#cite_note-Declan-330\" style=\"counter-reset: mw-Ref 324;\"><span class=\"mw-reflink-text\">[324]</span></a></span></p>\n\n<p>Wikipedia has also been used as a source in journalism,<span class=\"mw-ref\" id=\"cite_ref-ajr.org_WP_in_the_newsroom_331-0\"><a href=\"#cite_note-ajr.org_WP_in_the_newsroom-331\" style=\"counter-reset: mw-Ref 325;\"><span class=\"mw-reflink-text\">[325]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-twsY23_332-0\"><a href=\"#cite_note-twsY23-332\" style=\"counter-reset: mw-Ref 326;\"><span class=\"mw-reflink-text\">[326]</span></a></span> often without attribution, and several reporters have been dismissed for <a href=\"/wiki/Plagiarism_from_Wikipedia\" title=\"Plagiarism from Wikipedia\">plagiarizing from Wikipedia</a>.<span class=\"mw-ref\" id=\"cite_ref-shizuoka_plagiarized_WP_1_333-0\"><a href=\"#cite_note-shizuoka_plagiarized_WP_1-333\" style=\"counter-reset: mw-Ref 327;\"><span class=\"mw-reflink-text\">[327]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-WA_Express-News_staffer_resigns_334-0\"><a href=\"#cite_note-WA_Express-News_staffer_resigns-334\" style=\"counter-reset: mw-Ref 328;\"><span class=\"mw-reflink-text\">[328]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-starbulletin.com_Inquiry_prompts_dismissal_335-0\"><a href=\"#cite_note-starbulletin.com_Inquiry_prompts_dismissal-335\" style=\"counter-reset: mw-Ref 329;\"><span class=\"mw-reflink-text\">[329]</span></a></span></p>\n\n<p>In 2006, <a href=\"/wiki/Time_(magazine)\" title=\"Time (magazine)\"><i>Time</i> magazine</a> recognized Wikipedia's participation (along with <a href=\"/wiki/YouTube\" title=\"YouTube\">YouTube</a>, <a href=\"/wiki/Reddit\" title=\"Reddit\">Reddit</a>, <a href=\"/wiki/MySpace\" title=\"MySpace\" class=\"mw-redirect\">MySpace</a>, and <a href=\"/wiki/Facebook\" title=\"Facebook\">Facebook</a>)<span class=\"mw-ref\" id=\"cite_ref-Time2006_336-0\"><a href=\"#cite_note-Time2006-336\" style=\"counter-reset: mw-Ref 330;\"><span class=\"mw-reflink-text\">[330]</span></a></span> in the rapid growth of online collaboration and interaction by millions of people worldwide.</p>\n\n<p>In July 2007, Wikipedia was the focus of a 30-minute documentary on <a href=\"/wiki/BBC_Radio_4\" title=\"BBC Radio 4\">BBC Radio 4</a><span class=\"mw-ref\" id=\"cite_ref-337\"><a href=\"#cite_note-337\" style=\"counter-reset: mw-Ref 331;\"><span class=\"mw-reflink-text\">[331]</span></a></span> which argued that, with increased usage and awareness, the number of references to Wikipedia in popular culture is such that the word is one of a select band of 21st-century nouns that are so familiar (<a href=\"/wiki/Google\" title=\"Google\">Google</a>, <a href=\"/wiki/Facebook\" title=\"Facebook\">Facebook</a>, <a href=\"/wiki/YouTube\" title=\"YouTube\">YouTube</a>) that they no longer need explanation.</p>\n\n<p>On September 28, 2007, <a href=\"/wiki/Italy\" title=\"Italy\">Italian</a> politician <a href=\"/wiki/Franco_Grillini\" title=\"Franco Grillini\">Franco Grillini</a> raised a parliamentary question with the minister of cultural resources and activities about the necessity of <a href=\"/wiki/Freedom_of_panorama\" title=\"Freedom of panorama\">freedom of panorama</a>. He said that the lack of such freedom forced Wikipedia, \"the seventh most consulted website\", to forbid all images of modern Italian buildings and art, and claimed this was hugely damaging to tourist revenues.<span class=\"mw-ref\" id=\"cite_ref-338\"><a href=\"#cite_note-338\" style=\"counter-reset: mw-Ref 332;\"><span class=\"mw-reflink-text\">[332]</span></a></span></p>\n<figure class=\"mw-default-size\" data-mw=\"{&quot;attribs&quot;:[[&quot;thumbtime&quot;,{&quot;txt&quot;:&quot;00:36.00&quot;}]]}\"><span><a href=\"/wiki/File:Wikipedia,_an_introduction_-_Erasmus_Prize_2015.webm\" class=\"app_media\"><video poster=\"//upload.wikimedia.org/wikipedia/commons/thumb/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/220px-seek%3D36-Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.jpg\" preload=\"none\" height=\"124\" width=\"220\" resource=\"./File:Wikipedia,_an_introduction_-_Erasmus_Prize_2015.webm\"><source src=\"//upload.wikimedia.org/wikipedia/commons/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-file-width=\"1920\" data-file-height=\"1080\" data-title=\"Original WebM file, 1,920 × 1,080 (2.22 Mbps)\" data-shorttitle=\"WebM source\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.120p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"214\" data-height=\"120\" data-title=\"Lowest bandwidth VP9 (120P)\" data-shorttitle=\"VP9 120P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.160p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"284\" data-height=\"160\" data-title=\"Low bandwidth WebM (160P)\" data-shorttitle=\"WebM 160P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.180p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"320\" data-height=\"180\" data-title=\"Low bandwidth VP9 (180P)\" data-shorttitle=\"VP9 180P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.240p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"426\" data-height=\"240\" data-title=\"Small VP9 (240P)\" data-shorttitle=\"VP9 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.240p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"426\" data-height=\"240\" data-title=\"Small WebM (240P)\" data-shorttitle=\"WebM 240P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.360p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"640\" data-height=\"360\" data-title=\"VP9 (360P)\" data-shorttitle=\"VP9 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.360p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"640\" data-height=\"360\" data-title=\"WebM (360P)\" data-shorttitle=\"WebM 360P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.480p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"854\" data-height=\"480\" data-title=\"SD VP9 (480P)\" data-shorttitle=\"VP9 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.480p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"854\" data-height=\"480\" data-title=\"SD WebM (480P)\" data-shorttitle=\"WebM 480P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.720p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1280\" data-height=\"720\" data-title=\"HD VP9 (720P)\" data-shorttitle=\"VP9 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.720p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1280\" data-height=\"720\" data-title=\"HD WebM (720P)\" data-shorttitle=\"WebM 720P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.1080p.vp9.webm\" type=\"video/webm; codecs=&quot;vp9, opus&quot;\" data-width=\"1920\" data-height=\"1080\" data-title=\"Full HD VP9 (1080P)\" data-shorttitle=\"VP9 1080P\"><source src=\"//upload.wikimedia.org/wikipedia/commons/transcoded/3/33/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm/Wikipedia%2C_an_introduction_-_Erasmus_Prize_2015.webm.1080p.webm\" type=\"video/webm; codecs=&quot;vp8, vorbis&quot;\" data-width=\"1920\" data-height=\"1080\" data-title=\"Full HD WebM (1080P)\" data-shorttitle=\"WebM 1080P\"></video></a></span><figcaption>Wikipedia, an introduction—<a href=\"/wiki/Erasmus_Prize\" title=\"Erasmus Prize\">Erasmus Prize</a> 2015</figcaption></figure>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Quadriga-verleihung-rr-02.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Quadriga-verleihung-rr-02.jpg/220px-Quadriga-verleihung-rr-02.jpg\" data-file-width=\"2623\" data-file-height=\"2107\" data-file-type=\"bitmap\" height=\"177\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Quadriga-verleihung-rr-02.jpg/440px-Quadriga-verleihung-rr-02.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/1/1c/Quadriga-verleihung-rr-02.jpg/330px-Quadriga-verleihung-rr-02.jpg 1.5x\"></a><figcaption><a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a> accepts the 2008 <a href=\"/wiki/Quadriga_(award)\" title=\"Quadriga (award)\">Quadriga</a> <i>A Mission of Enlightenment</i> award on behalf of Wikipedia</figcaption></figure>\n\n<p>On September 16, 2007, <i><a href=\"/wiki/The_Washington_Post\" title=\"The Washington Post\">The Washington Post</a></i> reported that Wikipedia had become a focal point in the <a href=\"/wiki/2008_United_States_presidential_election\" title=\"2008 United States presidential election\">2008 US election campaign</a>, saying: \"Type a candidate's name into Google, and among the first results is a Wikipedia page, making those entries arguably as important as any ad in defining a candidate. Already, the presidential entries are being edited, dissected and debated countless times each day.\"<span class=\"mw-ref\" id=\"cite_ref-WP.com_WP_election_usage_339-0\"><a href=\"#cite_note-WP.com_WP_election_usage-339\" style=\"counter-reset: mw-Ref 333;\"><span class=\"mw-reflink-text\">[333]</span></a></span> An October 2007 <a href=\"/wiki/Reuters\" title=\"Reuters\">Reuters</a> article, titled \"Wikipedia page the latest status symbol\", reported the recent phenomenon of how having a Wikipedia article vindicates one's notability.<span class=\"mw-ref\" id=\"cite_ref-340\"><a href=\"#cite_note-340\" style=\"counter-reset: mw-Ref 334;\"><span class=\"mw-reflink-text\">[334]</span></a></span></p>\n\n<p>Active participation also has an impact. Law students have been assigned to write Wikipedia articles as an exercise in clear and succinct writing for an uninitiated audience.<span class=\"mw-ref\" id=\"cite_ref-LER_students_write_for_WP_1_341-0\"><a href=\"#cite_note-LER_students_write_for_WP_1-341\" style=\"counter-reset: mw-Ref 335;\"><span class=\"mw-reflink-text\">[335]</span></a></span></p>\n\n<p>A working group led by <a href=\"/wiki/Peter_Stone_(professor)\" title=\"Peter Stone (professor)\">Peter Stone</a> (formed as a part of the <a href=\"/wiki/Stanford\" title=\"Stanford\" class=\"mw-redirect\">Stanford</a>-based project <a href=\"/wiki/One_Hundred_Year_Study_on_Artificial_Intelligence\" title=\"One Hundred Year Study on Artificial Intelligence\" class=\"mw-redirect\">One Hundred Year Study on Artificial Intelligence</a>) in its report called Wikipedia \"the best-known example of crowdsourcing<span class=\"nowrap\"><span>&nbsp;</span></span>... that far exceeds traditionally-compiled information sources, such as encyclopedias and dictionaries, in scale and depth.\"<span class=\"mw-ref\" id=\"cite_ref-342\"><a href=\"#cite_note-342\" style=\"counter-reset: mw-Ref 336;\"><span class=\"mw-reflink-text\">[336]</span></a></span></p>\n\n<p>In a 2017 opinion piece for <i><a href=\"/wiki/Wired_(magazine)\" title=\"Wired (magazine)\">Wired</a></i>, <a href=\"/wiki/Hossein_Derakhshan\" title=\"Hossein Derakhshan\">Hossein Derakhshan</a> describes Wikipedia as \"one of the last remaining pillars of the <a href=\"/wiki/Openness\" title=\"Openness\">open</a> and <a href=\"/wiki/Decentralization#Centralization_and_redecentralization_of_the_Internet\" title=\"Decentralization\">decentralized web</a>\" and contrasted its existence as a text-based source of knowledge with <a href=\"/wiki/Social_media\" title=\"Social media\">social media</a> and <a href=\"/wiki/Social_networking_service\" title=\"Social networking service\">social networking services</a>, the latter having \"since colonized the web for television's values\". For Derakhshan, Wikipedia's goal as an encyclopedia represents the <a href=\"/wiki/Age_of_Enlightenment\" title=\"Age of Enlightenment\">Age of Enlightenment</a> tradition of <a href=\"/wiki/Rationality\" title=\"Rationality\">rationality</a> triumphing over emotions, a trend which he considers \"endangered\" due to the \"gradual shift from a <a href=\"/wiki/Typographic\" title=\"Typographic\" class=\"mw-redirect\">typographic</a> culture to a photographic one, which in turn mean[s] a shift from rationality to emotions, exposition to entertainment.\" Rather than \"<i lang=\"la\" title=\"Latin language text\"><a href=\"/wiki/Sapere_aude\" title=\"Sapere aude\">sapere aude</a></i>\" (<a href=\"/wiki/Literal_translation\" title=\"Literal translation\">lit.</a><span style=\"white-space:nowrap;\"><span> </span>''dare to know''</span>), social networks have led to a culture of \"[d]are not to care to know\". This is while Wikipedia faces \"a more concerning problem\" than funding, namely \"a flattening growth rate in the number of contributors to the website\". Consequently, the challenge for Wikipedia and those who use it is to \"save Wikipedia and its promise of a free and open collection of all human knowledge amid the conquest of new and old television—how to collect and preserve knowledge when nobody cares to know.\"<span class=\"mw-ref\" id=\"cite_ref-343\"><a href=\"#cite_note-343\" style=\"counter-reset: mw-Ref 337;\"><span class=\"mw-reflink-text\">[337]</span></a></span></p>\n\n","toclevel":2,"line":"Cultural significance","anchor":"Cultural_significance"},{"id":47,"text":"\n\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8d/Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG/220px-Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG\" data-file-width=\"6016\" data-file-height=\"4000\" data-file-type=\"bitmap\" height=\"146\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/8/8d/Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG/440px-Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG 2x, //upload.wikimedia.org/wikipedia/commons/thumb/8/8d/Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG/330px-Wikipedia_team_visiting_to_Parliament_of_Oviedo_Spain_2015.JPG 1.5x\"></a><figcaption>Wikipedia team visiting the Parliament of Asturias</figcaption></figure>\n<figure class=\"mw-default-size\"><a href=\"/wiki/File:Spanish_Wikipedians_meetup.jpg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/25/Spanish_Wikipedians_meetup.jpg/220px-Spanish_Wikipedians_meetup.jpg\" data-file-width=\"6016\" data-file-height=\"4000\" data-file-type=\"bitmap\" height=\"146\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/25/Spanish_Wikipedians_meetup.jpg/440px-Spanish_Wikipedians_meetup.jpg 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/25/Spanish_Wikipedians_meetup.jpg/330px-Spanish_Wikipedians_meetup.jpg 1.5x\"></a><figcaption>Wikipedians meeting after the 2015 Asturias awards ceremony</figcaption></figure>\n\n<p>Wikipedia won two major awards in May 2004.<span class=\"mw-ref\" id=\"cite_ref-WP_awards_for_WP_1_344-0\"><a href=\"#cite_note-WP_awards_for_WP_1-344\" style=\"counter-reset: mw-Ref 338;\"><span class=\"mw-reflink-text\">[338]</span></a></span> The first was a Golden Nica for Digital Communities of the annual <a href=\"/wiki/Prix_Ars_Electronica\" title=\"Prix Ars Electronica\">Prix Ars Electronica</a> contest; this came with a €10,000 (£6,588; $12,700) grant and an invitation to present at the PAE Cyberarts Festival in <a href=\"/wiki/Austria\" title=\"Austria\">Austria</a> later that year. The second was a Judges' <a href=\"/wiki/Webby_Award\" title=\"Webby Award\">Webby Award</a> for the \"community\" category.<span class=\"mw-ref\" id=\"cite_ref-webbyawards_WP_awards_1_345-0\"><a href=\"#cite_note-webbyawards_WP_awards_1-345\" style=\"counter-reset: mw-Ref 339;\"><span class=\"mw-reflink-text\">[339]</span></a></span> Wikipedia was also nominated for a \"Best Practices\" Webby award.</p>\n\n<p>In 2007, readers of brandchannel.com voted Wikipedia as the fourth-highest brand ranking, receiving 15 percent of the votes in answer to the question \"Which brand had the most impact on our lives in 2006?\"<span class=\"mw-ref\" id=\"cite_ref-brandchannel.com_awards_1_346-0\"><a href=\"#cite_note-brandchannel.com_awards_1-346\" style=\"counter-reset: mw-Ref 340;\"><span class=\"mw-reflink-text\">[340]</span></a></span></p>\n\n<p>In September 2008, Wikipedia received <a href=\"/wiki/Quadriga_(award)\" title=\"Quadriga (award)\">Quadriga</a> <i>A Mission of Enlightenment</i> award of Werkstatt Deutschland along with <a href=\"/wiki/Boris_Tadić\" title=\"Boris Tadić\">Boris Tadić</a>, <a href=\"/wiki/Eckart_Höfling\" title=\"Eckart Höfling\">Eckart Höfling</a>, and <a href=\"/wiki/Peter_Gabriel\" title=\"Peter Gabriel\">Peter Gabriel</a>. The award was presented to Wales by <a href=\"/wiki/David_Weinberger\" title=\"David Weinberger\">David Weinberger</a>.<span class=\"mw-ref\" id=\"cite_ref-loomarea.com_WP_award_1_347-0\"><a href=\"#cite_note-loomarea.com_WP_award_1-347\" style=\"counter-reset: mw-Ref 341;\"><span class=\"mw-reflink-text\">[341]</span></a></span></p>\n\n<p>In 2015, Wikipedia was awarded both the annual <a href=\"/wiki/Erasmus_Prize\" title=\"Erasmus Prize\">Erasmus Prize</a>, which recognizes exceptional contributions to culture, society or social sciences,<span class=\"mw-ref\" id=\"cite_ref-EP2015_348-0\"><a href=\"#cite_note-EP2015-348\" style=\"counter-reset: mw-Ref 342;\"><span class=\"mw-reflink-text\">[342]</span></a></span> and the <a href=\"/wiki/Spain\" title=\"Spain\">Spanish</a> <a href=\"/wiki/Princess_of_Asturias_Award\" title=\"Princess of Asturias Award\" class=\"mw-redirect\">Princess of Asturias Award</a> on International Cooperation.<span class=\"mw-ref\" id=\"cite_ref-349\"><a href=\"#cite_note-349\" style=\"counter-reset: mw-Ref 343;\"><span class=\"mw-reflink-text\">[343]</span></a></span> Speaking at the Asturian Parliament in Oviedo, the city that hosts the awards ceremony, <a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a> praised the work of the <a href=\"/wiki/Asturian_language\" title=\"Asturian language\">Asturian language</a> Wikipedia users.<span class=\"mw-ref\" id=\"cite_ref-350\"><a href=\"#cite_note-350\" style=\"counter-reset: mw-Ref 344;\"><span class=\"mw-reflink-text\">[344]</span></a></span> The night of the ceremony, members of the Wikimedia Foundation held a meeting with Wikipedians from all parts of Spain, including the local <a href=\"/wiki/Asturian_Wikipedia\" title=\"Asturian Wikipedia\">Asturian community</a>.</p>\n\n","toclevel":3,"line":"Awards","anchor":"Awards"},{"id":48,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable selfref\" about=\"#mwt2329\">See also: <a href=\"/wiki/Category:Parodies_of_Wikipedia\" title=\"Category:Parodies of Wikipedia\">Category:Parodies of Wikipedia</a>.</div>\n\n<p>Many parodies target Wikipedia's openness and susceptibility to inserted inaccuracies, with characters vandalizing or modifying the online encyclopedia project's articles.</p>\n\n<p>Comedian <a href=\"/wiki/Stephen_Colbert\" title=\"Stephen Colbert\">Stephen Colbert</a> has parodied or referenced Wikipedia on numerous episodes of his show <i><a href=\"/wiki/The_Colbert_Report\" title=\"The Colbert Report\">The Colbert Report</a></i> and coined the related term <i><a href=\"/wiki/Wikiality\" title=\"Wikiality\" class=\"mw-redirect\">wikiality</a></i>, meaning \"together we can create a reality that we all agree on—the reality we just agreed on\".<span class=\"mw-ref\" id=\"cite_ref-wikiality_194-1\"><a href=\"#cite_note-wikiality-194\" style=\"counter-reset: mw-Ref 189;\"><span class=\"mw-reflink-text\">[189]</span></a></span> Another example can be found in \"Wikipedia Celebrates 750 Years of American Independence\", a July 2006 front-page article in <i><a href=\"/wiki/The_Onion\" title=\"The Onion\">The Onion</a></i>,<span class=\"mw-ref\" id=\"cite_ref-onion_WP_750_years_1_351-0\"><a href=\"#cite_note-onion_WP_750_years_1-351\" style=\"counter-reset: mw-Ref 345;\"><span class=\"mw-reflink-text\">[345]</span></a></span> as well as the 2010 <i>The Onion</i> article \"'L.A. Law' Wikipedia Page Viewed 874 Times Today\".<span class=\"mw-ref\" id=\"cite_ref-352\"><a href=\"#cite_note-352\" style=\"counter-reset: mw-Ref 346;\"><span class=\"mw-reflink-text\">[346]</span></a></span></p>\n\n<p>In an episode of the television comedy <a href=\"/wiki/The_Office_(American_TV_series)\" title=\"The Office (American TV series)\"><i>The Office</i> U.S.</a>, which aired in April 2007, an incompetent office manager (<a href=\"/wiki/Michael_Scott_(The_Office)\" title=\"Michael Scott (The Office)\">Michael Scott</a>) is shown relying on a hypothetical Wikipedia article for information on <a href=\"/wiki/Negotiation\" title=\"Negotiation\">negotiation</a> tactics in order to assist him in negotiating lesser pay for an employee.<span class=\"mw-ref\" id=\"cite_ref-353\"><a href=\"#cite_note-353\" style=\"counter-reset: mw-Ref 347;\"><span class=\"mw-reflink-text\">[347]</span></a></span> Viewers of the show tried to add the episode's mention of the page as a section of the actual Wikipedia article on negotiation, but this effort was prevented by other users on the article's talk page.<span class=\"mw-ref\" id=\"cite_ref-354\"><a href=\"#cite_note-354\" style=\"counter-reset: mw-Ref 348;\"><span class=\"mw-reflink-text\">[348]</span></a></span></p>\n\n<p>\"<a href=\"/wiki/My_Number_One_Doctor\" title=\"My Number One Doctor\" class=\"mw-redirect\">My Number One Doctor</a>\", a 2007 episode of the television show <i><a href=\"/wiki/Scrubs_(TV_series)\" title=\"Scrubs (TV series)\">Scrubs</a></i>, played on the perception that Wikipedia is an unreliable reference tool with a scene in which <a href=\"/wiki/Perry_Cox\" title=\"Perry Cox\">Dr. Perry Cox</a> reacts to a patient who says that a Wikipedia article indicates that the <a href=\"/wiki/Raw_food_diet\" title=\"Raw food diet\" class=\"mw-redirect\">raw food diet</a> reverses the effects of <a href=\"/wiki/Bone_cancer\" title=\"Bone cancer\" class=\"mw-redirect\">bone cancer</a> by retorting that the same editor who wrote that article also wrote the <a href=\"/wiki/List_of_Battlestar_Galactica_(2004_TV_series)_episodes\" title=\"List of Battlestar Galactica (2004 TV series) episodes\"><i>Battlestar Galactica</i> episode guide</a>.<span class=\"mw-ref\" id=\"cite_ref-Bakken_one_doctor_1_355-0\"><a href=\"#cite_note-Bakken_one_doctor_1-355\" style=\"counter-reset: mw-Ref 349;\"><span class=\"mw-reflink-text\">[349]</span></a></span></p>\n\n<p>In 2008, the comedic website <i><a href=\"/wiki/CollegeHumor\" title=\"CollegeHumor\">CollegeHumor</a></i> produced a video sketch named \"Professor Wikipedia\", in which the fictitious Professor Wikipedia instructs a class with a medley of unverifiable and occasionally absurd statements.<span class=\"mw-ref\" id=\"cite_ref-collegehumor.com_WP_funny_1_356-0\"><a href=\"#cite_note-collegehumor.com_WP_funny_1-356\" style=\"counter-reset: mw-Ref 350;\"><span class=\"mw-reflink-text\">[350]</span></a></span></p>\n\n<p>The <i><a href=\"/wiki/Dilbert\" title=\"Dilbert\">Dilbert</a></i> comic strip from May 8, 2009, features a character supporting an improbable claim by saying \"Give me ten minutes and then check Wikipedia.\"<span class=\"mw-ref\" id=\"cite_ref-dilbert_WP_funny_1_357-0\"><a href=\"#cite_note-dilbert_WP_funny_1-357\" style=\"counter-reset: mw-Ref 351;\"><span class=\"mw-reflink-text\">[351]</span></a></span></p>\n\n<p>In July 2009, <a href=\"/wiki/BBC_Radio_4\" title=\"BBC Radio 4\">BBC Radio 4</a> broadcast a comedy series called <i><a href=\"/wiki/Bigipedia\" title=\"Bigipedia\">Bigipedia</a></i>, which was set on a website which was a parody of Wikipedia. Some of the sketches were directly inspired by Wikipedia and its articles.<span class=\"mw-ref\" id=\"cite_ref-comedy.org.uk_WP_funny_1_358-0\"><a href=\"#cite_note-comedy.org.uk_WP_funny_1-358\" style=\"counter-reset: mw-Ref 352;\"><span class=\"mw-reflink-text\">[352]</span></a></span></p>\n\n<p>In 2010, comedian Daniel Tosh encouraged viewers of his show, <i><a href=\"/wiki/Tosh.0\" title=\"Tosh.0\">Tosh.0</a></i>, to visit the show's Wikipedia article and edit it at will. On a later episode, he commented on the edits to the article, most of them offensive, which had been made by the audience and had prompted the article to be locked from editing.<span class=\"mw-ref\" id=\"cite_ref-tosh_CC_WP_funny_1_359-0\"><a href=\"#cite_note-tosh_CC_WP_funny_1-359\" style=\"counter-reset: mw-Ref 353;\"><span class=\"mw-reflink-text\">[353]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-tosh_CC_WP_funny_2_360-0\"><a href=\"#cite_note-tosh_CC_WP_funny_2-360\" style=\"counter-reset: mw-Ref 354;\"><span class=\"mw-reflink-text\">[354]</span></a></span></p>\n\n<p>On August 23, 2013, the <i><a href=\"/wiki/The_New_Yorker\" title=\"The New Yorker\">New Yorker</a></i> <a href=\"/wiki/Website\" title=\"Website\">website</a> published a cartoon with this caption: \"Dammit, <a href=\"/wiki/Chelsea_Manning\" title=\"Chelsea Manning\">Manning,</a> have you considered the pronoun war that this is going to start on your Wikipedia page?\"<span class=\"mw-ref\" id=\"cite_ref-361\"><a href=\"#cite_note-361\" style=\"counter-reset: mw-Ref 355;\"><span class=\"mw-reflink-text\">[355]</span></a></span> The cartoon referred to Chelsea Elizabeth Manning (born Bradley Edward Manning), an American activist, politician, and former United States Army soldier and a trans woman.</p>\n\n<p>In December 2015, <a href=\"/wiki/John_Julius_Norwich\" title=\"John Julius Norwich\">John Julius Norwich</a> stated, in a letter published in <i><a href=\"/wiki/The_Times\" title=\"The Times\">The Times</a></i> newspaper, that as a historian he resorted to Wikipedia \"at least a dozen times a day\", and had never yet caught it out. He described it as \"a work of reference as useful as any in existence\", with so wide a range that it is almost impossible to find a person, place or thing that it has left uncovered, and that he could never have written his last two books without it.<span class=\"mw-ref\" id=\"cite_ref-362\"><a href=\"#cite_note-362\" style=\"counter-reset: mw-Ref 356;\"><span class=\"mw-reflink-text\">[356]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-363\"><a href=\"#cite_note-363\" style=\"counter-reset: mw-Ref 357;\"><span class=\"mw-reflink-text\">[357]</span></a></span></p>\n\n","toclevel":3,"line":"Satire","anchor":"Satire"},{"id":49,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt2420\">Main article: <a href=\"/wiki/Wikimedia_project\" title=\"Wikimedia project\" class=\"mw-redirect\">Wikimedia project</a></div>\n<p>Wikipedia has also spawned several sister projects, which are also wikis run by the <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a>. These other <a href=\"/wiki/Wikimedia_projects\" title=\"Wikimedia projects\" class=\"mw-redirect\">Wikimedia projects</a> include <a href=\"/wiki/Wiktionary\" title=\"Wiktionary\">Wiktionary</a>, a dictionary project launched in December 2002,<span class=\"mw-ref\" id=\"cite_ref-WM_dictionary_1_364-0\"><a href=\"#cite_note-WM_dictionary_1-364\" style=\"counter-reset: mw-Ref 358;\"><span class=\"mw-reflink-text\">[358]</span></a></span> <a href=\"/wiki/Wikiquote\" title=\"Wikiquote\">Wikiquote</a>, a collection of quotations created a week after Wikimedia launched, <a href=\"/wiki/Wikibooks\" title=\"Wikibooks\">Wikibooks</a>, a collection of collaboratively written free textbooks and annotated texts, <a href=\"/wiki/Wikimedia_Commons\" title=\"Wikimedia Commons\">Wikimedia Commons</a>, a site devoted to free-knowledge multimedia, <a href=\"/wiki/Wikinews\" title=\"Wikinews\">Wikinews</a>, for citizen journalism, and <a href=\"/wiki/Wikiversity\" title=\"Wikiversity\">Wikiversity</a>, a project for the creation of free learning materials and the provision of online learning activities.<span class=\"mw-ref\" id=\"cite_ref-OurProjects_365-0\"><a href=\"#cite_note-OurProjects-365\" style=\"counter-reset: mw-Ref 359;\"><span class=\"mw-reflink-text\">[359]</span></a></span> Another sister project of Wikipedia, <a href=\"/wiki/Wikispecies\" title=\"Wikispecies\">Wikispecies</a>, is a catalogue of species. In 2012 <a href=\"/wiki/Wikivoyage\" title=\"Wikivoyage\">Wikivoyage</a>, an editable travel guide, and <a href=\"/wiki/Wikidata\" title=\"Wikidata\">Wikidata</a>, an editable knowledge base, launched.</p>\n\n","toclevel":2,"line":"Sister projects—Wikimedia","anchor":"Sister_projects—Wikimedia"},{"id":50,"text":"\n\n<figure class=\"mw-default-size mw-halign-right\"><a href=\"/wiki/File:WikiMedia_DC_2013_Annual_Meeting_08.JPG\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/28/WikiMedia_DC_2013_Annual_Meeting_08.JPG/220px-WikiMedia_DC_2013_Annual_Meeting_08.JPG\" data-file-width=\"4836\" data-file-height=\"2948\" data-file-type=\"bitmap\" height=\"134\" width=\"220\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/28/WikiMedia_DC_2013_Annual_Meeting_08.JPG/440px-WikiMedia_DC_2013_Annual_Meeting_08.JPG 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/28/WikiMedia_DC_2013_Annual_Meeting_08.JPG/330px-WikiMedia_DC_2013_Annual_Meeting_08.JPG 1.5x\"></a><figcaption>A group of Wikimedians of the <a rel=\"mw:ExtLink\" href=\"http://wikimediadc.org/wiki/Home\" class=\"external text\">Wikimedia DC chapter</a> at the 2013 DC Wikimedia annual meeting standing in front of the <i>Encyclopædia Britannica</i> <i>(back left)</i> at the US National Archives</figcaption></figure>\n\n<p>The most obvious economic effect of Wikipedia has been the death of commercial encyclopedias, especially the printed versions, e.g. <i><a href=\"/wiki/Encyclopædia_Britannica\" title=\"Encyclopædia Britannica\">Encyclopædia Britannica</a></i>, which were unable to compete with a product that is essentially free.<span class=\"mw-ref\" id=\"cite_ref-366\"><a href=\"#cite_note-366\" style=\"counter-reset: mw-Ref 360;\"><span class=\"mw-reflink-text\">[360]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-367\"><a href=\"#cite_note-367\" style=\"counter-reset: mw-Ref 361;\"><span class=\"mw-reflink-text\">[361]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-FT_impact_on_traditional_media_368-0\"><a href=\"#cite_note-FT_impact_on_traditional_media-368\" style=\"counter-reset: mw-Ref 362;\"><span class=\"mw-reflink-text\">[362]</span></a></span> <a href=\"/wiki/Nicholas_G._Carr\" title=\"Nicholas G. Carr\">Nicholas Carr</a> wrote a 2005 essay, \"The amorality of <a href=\"/wiki/Web_2.0\" title=\"Web 2.0\">Web 2.0</a>\", that criticized websites with <a href=\"/wiki/User-generated_content\" title=\"User-generated content\">user-generated content</a>, like Wikipedia, for possibly leading to professional (and, in his view, superior) content producers' going out of business, because \"free trumps quality all the time\". Carr wrote: \"Implicit in the ecstatic visions of Web 2.0 is the hegemony of the amateur. I for one can't imagine anything more frightening.\"<span class=\"mw-ref\" id=\"cite_ref-RType_WP_traditional_media_impact_1_369-0\"><a href=\"#cite_note-RType_WP_traditional_media_impact_1-369\" style=\"counter-reset: mw-Ref 363;\"><span class=\"mw-reflink-text\">[363]</span></a></span> Others dispute the notion that Wikipedia, or similar efforts, will entirely displace traditional publications. For instance, <a href=\"/wiki/Chris_Anderson_(writer)\" title=\"Chris Anderson (writer)\">Chris Anderson</a>, the editor-in-chief of <i><a href=\"/wiki/Wired_(magazine)\" title=\"Wired (magazine)\">Wired Magazine</a></i>, wrote in <i><a href=\"/wiki/Nature_(journal)\" title=\"Nature (journal)\">Nature</a></i> that the \"<a href=\"/wiki/Wisdom_of_crowds\" title=\"Wisdom of crowds\" class=\"mw-redirect\">wisdom of crowds</a>\" approach of Wikipedia will not displace top <a href=\"/wiki/Scientific_journal\" title=\"Scientific journal\">scientific journals</a>, with their rigorous <a href=\"/wiki/Peer_review\" title=\"Peer review\">peer review</a> process.<span class=\"mw-ref\" id=\"cite_ref-nature.com_crowds_wisdom_370-0\"><a href=\"#cite_note-nature.com_crowds_wisdom-370\" style=\"counter-reset: mw-Ref 364;\"><span class=\"mw-reflink-text\">[364]</span></a></span></p>\n\n<p>There is also an ongoing debate about the influence of Wikipedia on the biography publishing business. \"The worry is that, if you can get all that information from Wikipedia, what's left for biography?\" said <a href=\"/wiki/Kathryn_Hughes\" title=\"Kathryn Hughes\">Kathryn Hughes</a>, professor of life writing at the University of East Anglia and author of <i>The Short Life and Long Times of Mrs Beeton</i> and <i>George Eliot: the Last Victorian</i>.<span class=\"mw-ref\" id=\"cite_ref-371\"><a href=\"#cite_note-371\" style=\"counter-reset: mw-Ref 365;\"><span class=\"mw-reflink-text\">[365]</span></a></span></p>\n\n","toclevel":2,"line":"Publishing","anchor":"Publishing"},{"id":51,"text":"\n\n<p>Wikipedia has been widely used as a <a href=\"/wiki/Text_corpus\" title=\"Text corpus\">corpus</a> for linguistic research in <a href=\"/wiki/Computational_linguistics\" title=\"Computational linguistics\">computational linguistics</a>, <a href=\"/wiki/Information_retrieval\" title=\"Information retrieval\">information retrieval</a> and <a href=\"/wiki/Natural_language_processing\" title=\"Natural language processing\">natural language processing</a>. In particular, it commonly serves as a target knowledge base for the <a href=\"/wiki/Entity_linking\" title=\"Entity linking\">entity linking</a> problem, which is then called \"wikification\",<span class=\"mw-ref\" id=\"cite_ref-wikify_372-0\"><a href=\"#cite_note-wikify-372\" style=\"counter-reset: mw-Ref 366;\"><span class=\"mw-reflink-text\">[366]</span></a></span> and to the related problem of <a href=\"/wiki/Word_sense_disambiguation\" title=\"Word sense disambiguation\" class=\"mw-redirect\">word sense disambiguation</a>.<span class=\"mw-ref\" id=\"cite_ref-milne_witten_WP_usage_1_373-0\"><a href=\"#cite_note-milne_witten_WP_usage_1-373\" style=\"counter-reset: mw-Ref 367;\"><span class=\"mw-reflink-text\">[367]</span></a></span> Methods similar to wikification can in turn be used to find \"missing\" links in Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-discovering_missing_WP_links_1_374-0\"><a href=\"#cite_note-discovering_missing_WP_links_1-374\" style=\"counter-reset: mw-Ref 368;\"><span class=\"mw-reflink-text\">[368]</span></a></span></p>\n\n<p>In 2015, French researchers Dr José Lages of the <a href=\"/wiki/University_of_Franche-Comté\" title=\"University of Franche-Comté\">University of Franche-Comté</a> in <a href=\"/wiki/Besançon\" title=\"Besançon\">Besançon</a> and Dima Shepelyansky of <a href=\"/wiki/Paul_Sabatier_University\" title=\"Paul Sabatier University\">Paul Sabatier University</a> in <a href=\"/wiki/Toulouse\" title=\"Toulouse\">Toulouse</a> published a global university ranking based on Wikipedia scholarly citations.<span class=\"mw-ref\" id=\"cite_ref-mitmining_375-0\"><a href=\"#cite_note-mitmining-375\" style=\"counter-reset: mw-Ref 369;\"><span class=\"mw-reflink-text\">[369]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-harvardisonlymarmow_376-0\"><a href=\"#cite_note-harvardisonlymarmow-376\" style=\"counter-reset: mw-Ref 370;\"><span class=\"mw-reflink-text\">[370]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-wikipediarankingtimesworldunifranche_377-0\"><a href=\"#cite_note-wikipediarankingtimesworldunifranche-377\" style=\"counter-reset: mw-Ref 371;\"><span class=\"mw-reflink-text\">[371]</span></a></span> They used <a href=\"/wiki/PageRank\" title=\"PageRank\">PageRank</a> \"followed by the number of appearances in the 24 different language editions of Wikipedia (descending order) and the century in which they were founded (ascending order).\"<span class=\"mw-ref\" id=\"cite_ref-wikipediarankingtimesworldunifranche_377-1\"><a href=\"#cite_note-wikipediarankingtimesworldunifranche-377\" style=\"counter-reset: mw-Ref 371;\"><span class=\"mw-reflink-text\">[371]</span></a></span></p>\n\n<p>A 2017 <a href=\"/wiki/Massachusetts_Institute_of_Technology\" title=\"Massachusetts Institute of Technology\">MIT</a> study suggests that words used on Wikipedia articles end up in scientific publications.<span class=\"mw-ref\" id=\"cite_ref-378\"><a href=\"#cite_note-378\" style=\"counter-reset: mw-Ref 372;\"><span class=\"mw-reflink-text\">[372]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-379\"><a href=\"#cite_note-379\" style=\"counter-reset: mw-Ref 373;\"><span class=\"mw-reflink-text\">[373]</span></a></span></p>\n\n<p>A 2018 <a href=\"/wiki/Charles_University\" title=\"Charles University\">Charles University</a> study concluded that Wikipedia is the most used <a href=\"/wiki/Open_educational_resources\" title=\"Open educational resources\">OER</a> for students of environmental studies (used by 95% of students) and argued that educational institutions should focus their attention on it (for example by supporting <a href=\"/wiki/Wikipedian_in_residence\" title=\"Wikipedian in residence\">Wikipedians in residence</a>).<span class=\"mw-ref\" id=\"cite_ref-380\"><a href=\"#cite_note-380\" style=\"counter-reset: mw-Ref 374;\"><span class=\"mw-reflink-text\">[374]</span></a></span></p>\n\n<p>Studies related to Wikipedia have been using <a href=\"/wiki/Machine_learning\" title=\"Machine learning\">machine learning</a> and <a href=\"/wiki/Artificial_intelligence\" title=\"Artificial intelligence\">artificial intelligence</a> to support various operations. One of the most important areas—automatic detection of vandalism<span class=\"mw-ref\" id=\"cite_ref-381\"><a href=\"#cite_note-381\" style=\"counter-reset: mw-Ref 375;\"><span class=\"mw-reflink-text\">[375]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-382\"><a href=\"#cite_note-382\" style=\"counter-reset: mw-Ref 376;\"><span class=\"mw-reflink-text\">[376]</span></a></span> and <a href=\"/wiki/Data_quality\" title=\"Data quality\">data quality</a> assessment in Wikipedia,<span class=\"mw-ref\" id=\"cite_ref-383\"><a href=\"#cite_note-383\" style=\"counter-reset: mw-Ref 377;\"><span class=\"mw-reflink-text\">[377]</span></a></span> may include different measures for articles and infoboxes.<span class=\"mw-ref\" id=\"cite_ref-measures2019_213-1\"><a href=\"#cite_note-measures2019-213\" style=\"counter-reset: mw-Ref 208;\"><span class=\"mw-reflink-text\">[208]</span></a></span></p>\n\n","toclevel":2,"line":"Research use","anchor":"Research_use"},{"id":52,"text":"\n\n<p>A number of interactive multimedia encyclopedias incorporating entries written by the public existed long before Wikipedia was founded. The first of these was the 1986 <a href=\"/wiki/BBC_Domesday_Project\" title=\"BBC Domesday Project\">BBC Domesday Project</a>, which included text (entered on <a href=\"/wiki/BBC_Micro\" title=\"BBC Micro\">BBC Micro</a> computers) and photographs from more than a million contributors in the UK, and covered the geography, art, and culture of the UK. This was the first interactive multimedia encyclopedia (and was also the first major multimedia document connected through internal links), with the majority of articles being accessible through an interactive map of the UK. The user interface and part of the content of the Domesday Project were emulated on a website until 2008.<span class=\"mw-ref\" id=\"cite_ref-Domesday_Project_384-0\"><a href=\"#cite_note-Domesday_Project-384\" style=\"counter-reset: mw-Ref 378;\"><span class=\"mw-reflink-text\">[378]</span></a></span></p>\n\n<p>Several free-content, collaborative encyclopedias were created around the same period as Wikipedia (e.g. <a href=\"/wiki/Everything2\" title=\"Everything2\">Everything2</a>),<span class=\"mw-ref\" id=\"cite_ref-385\"><a href=\"#cite_note-385\" style=\"counter-reset: mw-Ref 379;\"><span class=\"mw-reflink-text\">[379]</span></a></span> with many later being merged into the project (e.g. <a href=\"/wiki/GNE_(encyclopedia)\" title=\"GNE (encyclopedia)\">GNE</a>).<span class=\"mw-ref\" id=\"cite_ref-gnu.org_386-0\"><a href=\"#cite_note-gnu.org-386\" style=\"counter-reset: mw-Ref 380;\"><span class=\"mw-reflink-text\">[380]</span></a></span> One of the most successful early online encyclopedias incorporating entries by the public was <a href=\"/wiki/H2g2\" title=\"H2g2\">h2g2</a>, which was created by <a href=\"/wiki/Douglas_Adams\" title=\"Douglas Adams\">Douglas Adams</a> in 1999. The h2g2 encyclopedia is relatively lighthearted, focusing on articles which are both witty and informative.</p>\n\n<p>Subsequent collaborative <a href=\"/wiki/Knowledge_base\" title=\"Knowledge base\">knowledge</a> websites have drawn inspiration from Wikipedia. Some, such as <a href=\"/wiki/Susning.nu\" title=\"Susning.nu\">Susning.nu</a>, <a href=\"/wiki/Enciclopedia_Libre_Universal_en_Español\" title=\"Enciclopedia Libre Universal en Español\">Enciclopedia Libre</a>, <a href=\"/wiki/Hudong\" title=\"Hudong\" class=\"mw-redirect\">Hudong</a>, and <a href=\"/wiki/Baidu_Baike\" title=\"Baidu Baike\">Baidu Baike</a> likewise employ no formal review process, although some like <a href=\"/wiki/Conservapedia\" title=\"Conservapedia\">Conservapedia</a> are not as open. Others use more traditional <a href=\"/wiki/Peer_review\" title=\"Peer review\">peer review</a>, such as <i><a href=\"/wiki/Encyclopedia_of_Life\" title=\"Encyclopedia of Life\">Encyclopedia of Life</a></i> and the online wiki encyclopedias <i><a href=\"/wiki/Scholarpedia\" title=\"Scholarpedia\">Scholarpedia</a></i> and <a href=\"/wiki/Citizendium\" title=\"Citizendium\">Citizendium</a>. The latter was started by Sanger in an attempt to create a reliable alternative to Wikipedia.<span class=\"mw-ref\" id=\"cite_ref-Orlowski18_387-0\"><a href=\"#cite_note-Orlowski18-387\" style=\"counter-reset: mw-Ref 381;\"><span class=\"mw-reflink-text\">[381]</span></a></span><span class=\"mw-ref\" id=\"cite_ref-JayLyman_388-0\"><a href=\"#cite_note-JayLyman-388\" style=\"counter-reset: mw-Ref 382;\"><span class=\"mw-reflink-text\">[382]</span></a></span></p>\n\n","toclevel":1,"line":"Related projects","anchor":"Related_projects"},{"id":53,"text":"\n\n<style data-mw-deduplicate=\"TemplateStyles:r936637989\" typeof=\"mw:Extension/templatestyles mw:Transclusion\">.mw-parser-output .portal{border:solid #aaa 1px;padding:0}.mw-parser-output .portal.tleft{margin:0.5em 1em 0.5em 0}.mw-parser-output .portal.tright{margin:0.5em 0 0.5em 1em}.mw-parser-output .portal>ul{display:table;box-sizing:border-box;padding:0.1em;max-width:175px;background:#f9f9f9;font-size:85%;line-height:110%;font-style:italic;font-weight:bold}.mw-parser-output .portal>ul>li{display:table-row}.mw-parser-output .portal>ul>li>span:first-child{display:table-cell;padding:0.2em;vertical-align:middle;text-align:center}.mw-parser-output .portal>ul>li>span:last-child{display:table-cell;padding:0.2em 0.2em 0.2em 0.3em;vertical-align:middle}</style><div role=\"navigation\" aria-label=\"Portals\" class=\"noprint portal plainlist tright\" about=\"#mwt2551\">\n<ul>\n<li><span><figure-inline class=\"noviewer\"><a href=\"/wiki/File:Crystal_Clear_app_linneighborhood.svg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/f9/Crystal_Clear_app_linneighborhood.svg/28px-Crystal_Clear_app_linneighborhood.svg.png\" data-file-width=\"407\" data-file-height=\"407\" data-file-type=\"drawing\" height=\"28\" width=\"28\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/f9/Crystal_Clear_app_linneighborhood.svg/56px-Crystal_Clear_app_linneighborhood.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/f/f9/Crystal_Clear_app_linneighborhood.svg/42px-Crystal_Clear_app_linneighborhood.svg.png 1.5x\"></a></figure-inline></span><span><a href=\"/wiki/Portal:Internet\" title=\"Portal:Internet\">Internet portal</a></span></li>\n<li><span><figure-inline class=\"noviewer\"><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/31px-Wikipedia-logo-v2.svg.png\" data-file-width=\"103\" data-file-height=\"94\" data-file-type=\"drawing\" height=\"28\" width=\"31\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/61px-Wikipedia-logo-v2.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/8/80/Wikipedia-logo-v2.svg/46px-Wikipedia-logo-v2.svg.png 1.5x\"></span></figure-inline></span><span><a href=\"/wiki/Portal:Wikipedia\" title=\"Portal:Wikipedia\" class=\"mw-redirect\">Wikipedia portal</a></span></li></ul></div>\n<div class=\"div-col columns column-width\" style=\"-moz-column-width: 20em; -webkit-column-width: 20em; column-width: 20em;   \" about=\"#mwt2555\">\n<ul><li><a href=\"/wiki/Conflict-of-interest_editing_on_Wikipedia\" title=\"Conflict-of-interest editing on Wikipedia\">Conflict-of-interest editing on Wikipedia</a></li>\n<li><a href=\"/wiki/Democratization_of_knowledge\" title=\"Democratization of knowledge\">Democratization of knowledge</a></li>\n<li><a href=\"/wiki/Interpedia\" title=\"Interpedia\">Interpedia</a>, an early proposal for a collaborative <a href=\"/wiki/Internet\" title=\"Internet\">Internet</a> encyclopedia</li>\n<li><a href=\"/wiki/List_of_online_encyclopedias\" title=\"List of online encyclopedias\">List of online encyclopedias</a></li>\n<li><a href=\"/wiki/List_of_Wikipedia_controversies\" title=\"List of Wikipedia controversies\">List of Wikipedia controversies</a></li>\n<li><a href=\"/wiki/Network_effect\" title=\"Network effect\">Network effect</a></li>\n<li><a href=\"/wiki/Outline_of_Wikipedia\" title=\"Outline of Wikipedia\">Outline of Wikipedia</a>—guide to the subject of <i>Wikipedia</i> presented as a <a href=\"/wiki/Tree_structure\" title=\"Tree structure\">tree structured</a> list of its subtopics; for an outline of the contents of Wikipedia, see <a href=\"/wiki/Portal:Contents/Outlines\" title=\"Portal:Contents/Outlines\" class=\"mw-redirect\">Portal:Contents/Outlines</a></li>\n<li><a href=\"/wiki/Print_Wikipedia\" title=\"Print Wikipedia\">Print Wikipedia</a> art project to visualize how big Wikipedia is. In cooperation with Wikimedia foundation.</li>\n<li><a href=\"/wiki/QRpedia\" title=\"QRpedia\">QRpedia</a>—multilingual, mobile interface to Wikipedia</li>\n<li><a href=\"/wiki/Wikipedia_Review\" title=\"Wikipedia Review\">Wikipedia Review</a></li></ul>\n</div>\n\n","toclevel":1,"line":"See also","anchor":"See_also"},{"id":54,"text":"\n\n<div class=\"reflist \" style=\" list-style-type: decimal;\" about=\"#mwt2557\">\n<div class=\"mw-references-wrap\" about=\"#mwt2560\"><ol class=\"mw-references references\" data-mw-group=\"note\"><li id=\"cite_note-3\"> <span id=\"mw-reference-text-cite_note-3\" class=\"mw-reference-text\">Registration is required for certain tasks such as editing <a href=\"/wiki/Protected_page\" title=\"Protected page\" class=\"mw-redirect\">protected pages</a>, creating pages in the English Wikipedia, and uploading files.</span></li><li id=\"cite_note-4\"> <span id=\"mw-reference-text-cite_note-4\" class=\"mw-reference-text\">To be considered <a href=\"/wiki/Special:ActiveUsers\" title=\"Special:ActiveUsers\">active</a>, a user must make at least one edit or other action in a given month.</span></li><li id=\"cite_note-79\"> <span id=\"mw-reference-text-cite_note-79\" class=\"mw-reference-text\">The procrastination principle dictates that you should wait for problems to arise before solving them.</span></li><li id=\"cite_note-89\"> <span id=\"mw-reference-text-cite_note-89\" class=\"mw-reference-text\">Revisions with libelous content, criminal threats, or copyright infringements <a href=\"/wiki/Wikipedia:Suppression\" title=\"Wikipedia:Suppression\" class=\"mw-redirect\">may be removed completely</a>.</span></li><li id=\"cite_note-124\"> <span id=\"mw-reference-text-cite_note-124\" class=\"mw-reference-text\">See for example the <a href=\"/wiki/Wikipedia:Biographies_of_living_persons/Noticeboard\" title=\"Wikipedia:Biographies of living persons/Noticeboard\">Biographies of Living Persons Noticeboard</a> or <a href=\"/wiki/Wikipedia:Neutral_point_of_view/Noticeboard\" title=\"Wikipedia:Neutral point of view/Noticeboard\">Neutral Point of View Noticeboard</a>, created to address content falling under their respective areas.</span></li><li id=\"cite_note-239\"> <span id=\"mw-reference-text-cite_note-239\" class=\"mw-reference-text\">See <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20101130081035/http://texaspress.com/index.php/publications/law-media/731-law-a-the-media-in-texas--libel-cases\" class=\"external text\">\"Libel\"</a> by David McHam for the legal distinction.</span></li></ol></div></div>\n\n","toclevel":1,"line":"Notes","anchor":"Notes","isReferenceSection":true},{"id":55,"text":"\n\n<div class=\"reflist \" style=\" list-style-type: decimal;\" about=\"#mwt2629\">\n<div class=\"mw-references-wrap mw-references-columns\" about=\"#mwt3073\"><ol class=\"mw-references references\"><li id=\"cite_note-Sidener-1\"> <span id=\"mw-reference-text-cite_note-Sidener-1\" class=\"mw-reference-text\"><cite class=\"citation news\">Sidener, Jonathan (December 6, 2004). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160114101809/http://www.sandiegouniontribune.com/uniontrib/20041206/news_mz1b6encyclo.html\" class=\"external text\">\"Everyone's Encyclopedia\"</a>. <i><a href=\"/wiki/U-T_San_Diego\" title=\"U-T San Diego\" class=\"mw-redirect\">U-T San Diego</a></i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.signonsandiego.com/uniontrib/20041206/news_mz1b6encyclo.html\" class=\"external text\">the original</a> on January 14, 2016<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 15,</span> 2006</span>.</cite></span></li><li id=\"cite_note-alexasiteinfo-2\"> <span id=\"mw-reference-text-cite_note-alexasiteinfo-2\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.alexa.com/siteinfo/wikipedia.org\" class=\"external text\">\"wikipedia.org Competitive Analysis, Marketing Mix and Traffic—Alexa\"</a>. <i>www.alexa.com</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 19,</span> 2020</span>.</cite></span></li><li id=\"cite_note-roadchap-5\"> <span id=\"mw-reference-text-cite_note-roadchap-5\" class=\"mw-reference-text\"><cite class=\"citation web\">Chapman, Roger (September 6, 2011). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20130922015103/http://rogchap.com/2011/09/06/top-40-website-programming-languages/\" class=\"external text\">\"Top 40 Website Programming Languages\"</a>. <i>rogchap.com</i>. Archived from <a rel=\"mw:ExtLink\" href=\"https://rogchap.com/2011/09/06/top-40-website-programming-languages/\" class=\"external text\">the original</a> on September 22, 2013<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 6,</span> 2011</span>.</cite></span></li><li id=\"cite_note-McNeil2011-6\"> <span id=\"mw-reference-text-cite_note-McNeil2011-6\" class=\"mw-reference-text\"><cite class=\"citation news\">Mark McNeil (October 4, 2011). <a rel=\"mw:ExtLink\" href=\"https://www.thespec.com/news-story/2205263-wikipedia-makes-a-house-call-to-mac/\" class=\"external text\">\"Wikipedia Makes A House Call To Mac\"</a>. <i><a href=\"/wiki/The_Hamilton_Spectator\" title=\"The Hamilton Spectator\">The Hamilton Spectator</a></i>.</cite></span></li><li id=\"cite_note-Poe2006-7\"> <span id=\"mw-reference-text-cite_note-Poe2006-7\" class=\"mw-reference-text\"><cite class=\"citation magazine\"><a href=\"/wiki/Marshall_Poe\" title=\"Marshall Poe\">Poe, Marshall</a> (September 2006). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/magazine/archive/2006/09/the-hive/305118/\" class=\"external text\">\"The Hive\"</a>. <i><a href=\"/wiki/The_Atlantic\" title=\"The Atlantic\">The Atlantic Monthly</a></i>.</cite></span></li><li id=\"cite_note-Tancer-8\"> <span id=\"mw-reference-text-cite_note-Tancer-8\" class=\"mw-reference-text\"><cite class=\"citation news\">Bill Tancer (May 1, 2007). <a rel=\"mw:ExtLink\" href=\"http://www.time.com/time/business/article/0,8599,1595184,00.html\" class=\"external text\">\"Look Who's Using Wikipedia\"</a>. <i><a href=\"/wiki/Time_(magazine)\" title=\"Time (magazine)\">Time</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 1,</span> 2007</span>. <q>The sheer volume of content [...] is partly responsible for the site's dominance as an online reference. When compared to the top 3,200 educational reference sites in the US, Wikipedia is No. 1, capturing 24.3% of all visits to the category</q></cite>. <a href=\"/wiki/Cf.\" title=\"Cf.\">Cf.</a> Bill Tancer (Global Manager, Hitwise), <a rel=\"mw:ExtLink\" href=\"http://weblogs.hitwise.com/bill-tancer/2007/03/wikipedia_search_and_school_ho.html\" class=\"external text\">\"Wikipedia, Search and School Homework\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120325220239/http://weblogs.hitwise.com/bill-tancer/2007/03/wikipedia_search_and_school_ho.html\" class=\"external text\">Archived</a> March 25, 2012, at the <a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <i><a href=\"/wiki/Hitwise\" title=\"Hitwise\">Hitwise</a></i>, March 1, 2007.</span></li><li id=\"cite_note-Woodson-9\"> <span id=\"mw-reference-text-cite_note-Woodson-9\" class=\"mw-reference-text\"><cite class=\"citation news\">Alex Woodson (July 8, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.reuters.com/article/internetNews/idUSN0819429120070708\" class=\"external text\">\"Wikipedia remains go-to site for online news\"</a>. Reuters<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 16,</span> 2007</span>. <q>Online encyclopedia Wikipedia has added about 20 million unique monthly visitors in the past year, making it the top online news and information destination, according to Nielsen//NetRatings.</q></cite></span></li><li id=\"cite_note-10\"> <span id=\"mw-reference-text-cite_note-10\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.comscore.com/Insights/Press-Releases/2012/9/comScore-Media-Metrix-Ranks-Top-50-US-Web-Properties-for-August-201?cs_edgescape_cc=US\" class=\"external text\">\"comScore MMX Ranks Top 50 US Web Properties for August 2012\"</a>. <i>comScore</i>. September 12, 2012. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20190831234506/https://www.comscore.com/Insights/Press-Releases/2012/9/comScore-Media-Metrix-Ranks-Top-50-US-Web-Properties-for-August-201?cs_edgescape_cc=US\" class=\"external text\">Archived</a> from the original on August 31, 2019<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 6,</span> 2013</span>.</cite></span></li><li id=\"cite_note-Alexa_siteinfo-11\"><span></span> <span id=\"mw-reference-text-cite_note-Alexa_siteinfo-11\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.alexa.com/siteinfo/wikipedia.org\" class=\"external text\">\"Wikipedia.org Traffic, Demographics and Competitors\"</a>. <i>www.alexa.com</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 1,</span> 2019</span>.</cite></span></li><li id=\"cite_note-12\"> <span id=\"mw-reference-text-cite_note-12\" class=\"mw-reference-text\"><cite class=\"citation news\">Dewey, Caitlin (December 2, 2015). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/news/the-intersect/wp/2015/12/02/wikipedia-has-a-ton-of-money-so-why-is-it-begging-you-to-donate-yours/\" class=\"external text\">\"Wikipedia has a ton of money. So why is it begging you to donate yours?\"</a>. The Washington Post<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 10,</span> 2019</span>.</cite></span></li><li id=\"cite_note-13\"> <span id=\"mw-reference-text-cite_note-13\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.bbc.com/news/10104946\" class=\"external text\">\"Wikimedia pornography row deepens as Wales cedes rights—BBC News\"</a>. <i>BBC</i>. May 10, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 28,</span> 2016</span>.</cite></span></li><li id=\"cite_note-14\"> <span id=\"mw-reference-text-cite_note-14\" class=\"mw-reference-text\"><cite class=\"citation news\">Vogel, Peter S. (October 10, 2012). <a rel=\"mw:ExtLink\" href=\"https://www.ecommercetimes.com/story/76351.html\" class=\"external text\">\"The Mysterious Workings of Wikis: Who Owns What?\"</a>. <i>Ecommerce Times</i>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20200222001728/https://www.ecommercetimes.com/story/76351.html\" class=\"external text\">Archived</a> from the original on February 22, 2020<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 28,</span> 2016</span>.</cite></span></li><li id=\"cite_note-15\"> <span id=\"mw-reference-text-cite_note-15\" class=\"mw-reference-text\"><cite class=\"citation news\">Mullin, Joe (January 10, 2014). <a rel=\"mw:ExtLink\" href=\"https://arstechnica.com/tech-policy/2014/01/wikimedia-foundation-employee-ousted-over-paid-editing/\" class=\"external text\">\"Wikimedia Foundation employee ousted over paid editing\"</a>. <i>Ars Technica</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 28,</span> 2016</span>.</cite></span></li><li id=\"cite_note-16\"> <span id=\"mw-reference-text-cite_note-16\" class=\"mw-reference-text\"><cite class=\"citation news\">Shin, Annys (January 5, 2017). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/lifestyle/magazine/wikipedia-was-born-in-2001-and-the-world-got-a-bit-truthier/2017/01/04/1d082742-bb0f-11e6-ac85-094a21c44abc_story.html\" class=\"external text\">\"Wikipedia was born in 2001. And the world got a bit truthier\"</a>. <i>The Washington Post</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 22,</span> 2019</span>.</cite></span></li><li id=\"cite_note-MiliardWho-17\"> <span id=\"mw-reference-text-cite_note-MiliardWho-17\" class=\"mw-reference-text\"><cite class=\"citation news\">Mike Miliard (March 1, 2008). <a rel=\"mw:ExtLink\" href=\"http://www.cityweekly.net/utah/article-5129-feature-wikipediots-who-are-these-devoted-even-obsessive-contributors-to-wikipedia.html\" class=\"external text\">\"Wikipediots: Who Are These Devoted, Even Obsessive Contributors to Wikipedia?\"</a>. <i><a href=\"/wiki/Salt_Lake_City_Weekly\" title=\"Salt Lake City Weekly\">Salt Lake City Weekly</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 18,</span> 2008</span>.</cite></span></li><li id=\"cite_note-J_Sidener-18\"> <span id=\"mw-reference-text-cite_note-J_Sidener-18\" class=\"mw-reference-text\"><cite class=\"citation news\">Sidener, Jonathan (October 9, 2006). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161111074945/http://legacy.sandiegouniontribune.com/news/tech/personaltech/20061009-9999-mz1b9wikiped.html\" class=\"external text\">\"Wikipedia family feud rooted in San Diego\"</a>. <i><a href=\"/wiki/The_San_Diego_Union-Tribune\" title=\"The San Diego Union-Tribune\">The San Diego Union-Tribune</a></i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://legacy.utsandiego.com/news/tech/personaltech/20061009-9999-mz1b9wikiped.html\" class=\"external text\">the original</a> on November 11, 2016<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 5,</span> 2009</span>.</cite></span></li><li id=\"cite_note-19\"> <span id=\"mw-reference-text-cite_note-19\" class=\"mw-reference-text\"><cite class=\"citation news\">\"Wiki\". <i>Hawaiian Dictionary</i> (Revised and enlarged ed.). University of Hawaii Press. 1986.</cite></span></li><li id=\"cite_note-CBS-20\"> <span id=\"mw-reference-text-cite_note-CBS-20\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.cbsnews.com/news/wikipedia-jimmy-wales-morley-safer-60-minutes/\" class=\"external text\">\"Wikipedia cofounder Jimmy Wales on 60 Minutes\"</a>. <i><a href=\"/wiki/CBS_News\" title=\"CBS News\">CBS News</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 6,</span> 2015</span>.</cite></span></li><li id=\"cite_note-small_screen-21\"><span></span> <span id=\"mw-reference-text-cite_note-small_screen-21\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (February 9, 2014). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2014/02/10/technology/wikipedia-vs-the-small-screen.html?_r=0\" class=\"external text\">\"Wikipedia vs. the Small Screen\"</a>. <i>The New York Times</i>.</cite></span></li><li id=\"cite_note-Wikimedia_Stats-22\"><span></span> <span id=\"mw-reference-text-cite_note-Wikimedia_Stats-22\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://stats.wikimedia.org/#/all-wikipedia-projects\" class=\"external text\">\"Wikistats - Statistics For Wikimedia Projects\"</a>. <i>stats.wikimedia.org</i>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 21,</span> 2020</span>.</cite></span></li><li id=\"cite_note-GilesJ2005Internet-23\"><span></span> <span id=\"mw-reference-text-cite_note-GilesJ2005Internet-23\" class=\"mw-reference-text\"><cite class=\"citation journal\"><a href=\"/wiki/Jim_Giles_(reporter)\" title=\"Jim Giles (reporter)\">Jim Giles</a> (December 2005). \"Internet encyclopedias go head to head\". <i><a href=\"/wiki/Nature_(journal)\" title=\"Nature (journal)\">Nature</a></i>. <b>438</b> (7070): 900–901. <a href=\"/wiki/Bibcode\" title=\"Bibcode\">Bibcode</a>:<a rel=\"mw:ExtLink\" href=\"https://ui.adsabs.harvard.edu/abs/2005Natur.438..900G\" class=\"external text\">2005Natur.438..900G</a>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//doi.org/10.1038%2F438900a\" class=\"external text\">10.1038/438900a</a></span>. <a href=\"/wiki/PubMed_Identifier\" title=\"PubMed Identifier\" class=\"mw-redirect\">PMID</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//pubmed.ncbi.nlm.nih.gov/16355180\" class=\"external text\">16355180</a>.</cite><span style=\"font-size:0.95em; font-size:90%; color:#555\">(subscription required)</span>\nNote: The study was cited in several news articles; e.g.:\n<ul><li><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://news.bbc.co.uk/2/hi/technology/4530930.stm\" class=\"external text\">\"Wikipedia survives research test\"</a>. <i>BBC News</i>. December 15, 2005.</cite></li></ul></span></li><li id=\"cite_note-Reagle,_pp._165–166-24\"><span></span> <span id=\"mw-reference-text-cite_note-Reagle,_pp._165–166-24\" class=\"mw-reference-text\">Reagle, pp. 165–166.</span></li><li id=\"cite_note-Orlowski2005-25\"><span></span> <span id=\"mw-reference-text-cite_note-Orlowski2005-25\" class=\"mw-reference-text\"><cite class=\"citation news\">Orlowski, Andrew (December 16, 2005). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2005/12/16/wikipedia_britannica_science_comparison/\" class=\"external text\">\"Wikipedia science 31% more cronky than Britannica's Excellent for Klingon science, though\"</a>. <i><a href=\"/wiki/The_Register\" title=\"The Register\">The Register</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 25,</span> 2019</span>.</cite></span></li><li id=\"cite_note-26\"> <span id=\"mw-reference-text-cite_note-26\" class=\"mw-reference-text\"><cite class=\"citation journal\"><a rel=\"mw:ExtLink\" href=\"http://content.time.com/time/specials/packages/article/0,28804,1975813_1975844_1976488,00.html\" class=\"external text\">\"The 2006 Time 100\"</a>. <i>Time</i>. May 8, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 11,</span> 2017</span>.</cite></span></li><li id=\"cite_note-EdwinBlack-27\"><span></span> <span id=\"mw-reference-text-cite_note-EdwinBlack-27\" class=\"mw-reference-text\"><a href=\"/wiki/Edwin_Black\" title=\"Edwin Black\">Black, Edwin</a> (April 19, 2010) <a rel=\"mw:ExtLink\" href=\"http://historynewsnetwork.org/article/125437\" class=\"external text\">Wikipedia—The Dumbing Down of World Knowledge</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160909210831/http://historynewsnetwork.org/article/125437\" class=\"external text\">Archived</a><span> September 9, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <a href=\"/wiki/History_News_Network\" title=\"History News Network\">History News Network</a> Retrieved October 21, 2014</span></li><li id=\"cite_note-Petrilli-28\"><span></span> <span id=\"mw-reference-text-cite_note-Petrilli-28\" class=\"mw-reference-text\">J. Petrilli, Michael (Spring 2008/Vol. 8, No. 2) <a rel=\"mw:ExtLink\" href=\"http://educationnext.org/wikipedia-or-wickedpedia/\" class=\"external text\">Wikipedia or Wickedpedia?</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161121024654/http://educationnext.org/wikipedia-or-wickedpedia/\" class=\"external text\">Archived</a><span> November 21, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <a href=\"/wiki/Education_Next\" title=\"Education Next\" class=\"mw-redirect\">Education Next</a> Retrieved October 22, 2014</span></li><li id=\"cite_note-tnw-29\"> <span id=\"mw-reference-text-cite_note-tnw-29\" class=\"mw-reference-text\"><cite class=\"citation web\">Curtis, Cara (2019). <a rel=\"mw:ExtLink\" href=\"https://thenextweb.com/tech/2019/03/19/physicist-has-written-over-500-biographies-female-scientists-wikipedia/\" class=\"external text\">\"This physicist has written over 500 biographies of women scientists on Wikipedia\"</a>. <i>thenextweb.com</i>. <a href=\"/wiki/The_Next_Web\" title=\"The Next Web\">The Next Web</a>.</cite></span></li><li id=\"cite_note-indy500-30\"> <span id=\"mw-reference-text-cite_note-indy500-30\" class=\"mw-reference-text\"><cite class=\"citation web\"><a href=\"/wiki/Jess_Wade\" title=\"Jess Wade\">Wade, Jessica</a> (2019). <a rel=\"mw:ExtLink\" href=\"https://www.independent.co.uk/voices/science-women-wikipedia-biography-sexism-academia-physics-a-level-a8773631.html\" class=\"external text\">\"This is why I've written 500 biographies of female scientists on Wikipedia\"</a>. <i>independent.co.uk</i>. <a href=\"/wiki/The_Independent\" title=\"The Independent\">The Independent</a>.</cite></span></li><li id=\"cite_note-auto-31\"><span></span> <span id=\"mw-reference-text-cite_note-auto-31\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (April 7, 2018). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20180614045810/https://www.washingtonpost.com/outlook/conspiracy-videos-fake-news-enter-wikipedia-the-good-cop-of-the-internet/2018/04/06/ad1f018a-3835-11e8-8fd2-49fe3c675a89_story.html\" class=\"external text\">\"Conspiracy videos? Fake news? Enter Wikipedia, the 'good cop' of the Internet\"</a>. <i>The Washington Post</i>. Archived from <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/outlook/conspiracy-videos-fake-news-enter-wikipedia-the-good-cop-of-the-internet/2018/04/06/ad1f018a-3835-11e8-8fd2-49fe3c675a89_story.html\" class=\"external text\">the original</a> on June 14, 2018.</cite></span></li><li id=\"cite_note-32\"> <span id=\"mw-reference-text-cite_note-32\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.niemanlab.org/2011/10/the-contribution-conundrum-why-did-wikipedia-succeed-while-other-encyclopedias-failed/\" class=\"external text\">\"The contribution conundrum: Why did Wikipedia succeed while other encyclopedias failed?\"</a>. <i>Nieman Lab</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-KockJungSyn2016-33\"><span></span> <span id=\"mw-reference-text-cite_note-KockJungSyn2016-33\" class=\"mw-reference-text\">Kock, N., Jung, Y., &amp; Syn, T. (2016). <a rel=\"mw:ExtLink\" href=\"http://cits.tamiu.edu/kock/pubs/journals/2016JournalIJeC_WikipediaEcollaboration/Kock_etal_2016_IJeC_WikipediaEcollaboration.pdf\" class=\"external text\">Wikipedia and e-Collaboration Research: Opportunities and Challenges.</a> (PDF) <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160927001627/http://cits.tamiu.edu/kock/pubs/journals/2016JournalIJeC_WikipediaEcollaboration/Kock_etal_2016_IJeC_WikipediaEcollaboration.pdf\" class=\"external text\">Archived</a><span> September 27, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <i>International Journal of e-Collaboration</i> (IJeC), 12(2), 1–8.</span></li><li id=\"cite_note-autogenerated1-34\"> <span id=\"mw-reference-text-cite_note-autogenerated1-34\" class=\"mw-reference-text\"><cite class=\"citation news\">Jonathan Sidener (December 6, 2004). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20071011150228/http://signonsandiego.com/uniontrib/20041206/news_mz1b6encyclo.html\" class=\"external text\">\"Everyone's Encyclopedia\"</a>. <i><a href=\"/wiki/U-T_San_Diego\" title=\"U-T San Diego\" class=\"mw-redirect\">U-T San Diego</a></i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.signonsandiego.com/uniontrib/20041206/news_mz1b6encyclo.html\" class=\"external text\">the original</a> on October 11, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 15,</span> 2006</span>.</cite></span></li><li id=\"cite_note-Meyers-35\"> <span id=\"mw-reference-text-cite_note-Meyers-35\" class=\"mw-reference-text\"><cite class=\"citation news\">Meyers, Peter (September 20, 2001). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2001/09/20/technology/fact-driven-collegial-this-site-wants-you.html?n=Top%2FReference%2FTimes+Topics%2FSubjects%2FC%2FComputer+Software\" class=\"external text\">\"Fact-Driven? Collegial? This Site Wants You\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 22,</span> 2007</span>. <q>'I can start an article that will consist of one paragraph, and then a real expert will come along and add three paragraphs and clean up my one paragraph,' said Larry Sanger of Las Vegas, who founded Wikipedia with Mr. Wales.</q></cite></span></li><li id=\"cite_note-stallman1999-36\"> <span id=\"mw-reference-text-cite_note-stallman1999-36\" class=\"mw-reference-text\"><cite class=\"citation web\"><a href=\"/wiki/Richard_Stallman\" title=\"Richard Stallman\">Richard M. Stallman</a> (June 20, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.gnu.org/encyclopedia/encyclopedia.html\" class=\"external text\">\"The Free Encyclopedia Project\"</a>. Free Software Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 4,</span> 2008</span>.</cite></span></li><li id=\"cite_note-SangerMemoir-37\"><span></span> <span id=\"mw-reference-text-cite_note-SangerMemoir-37\" class=\"mw-reference-text\"><cite class=\"citation news\">Sanger, Larry (April 18, 2005). <a rel=\"mw:ExtLink\" href=\"http://features.slashdot.org/features/05/04/18/164213.shtml\" class=\"external text\">\"The Early History of Nupedia and Wikipedia: A Memoir\"</a>. <i>Slashdot</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-Sanger-38\"> <span id=\"mw-reference-text-cite_note-Sanger-38\" class=\"mw-reference-text\"><cite class=\"citation news\">Sanger, Larry (January 17, 2001). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20010506042824/http://www.nupedia.com/pipermail/nupedia-l/2001-January/000684.html\" class=\"external text\">\"Wikipedia Is Up!\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.nupedia.com/pipermail/nupedia-l/2001-January/000684.html\" class=\"external text\">the original</a> on May 6, 2001<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WM_foundation_of_WP_1-39\"> <span id=\"mw-reference-text-cite_note-WM_foundation_of_WP_1-39\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://lists.wikimedia.org/pipermail/wikipedia-l/2001-October/000671.html\" class=\"external text\">\"Wikipedia-l: LinkBacks?\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 20,</span> 2007</span>.</cite></span></li><li id=\"cite_note-nupedia_feeder_from_WP_1-40\"> <span id=\"mw-reference-text-cite_note-nupedia_feeder_from_WP_1-40\" class=\"mw-reference-text\"><cite class=\"citation news\">Sanger, Larry (January 10, 2001). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20030414014355/http://www.nupedia.com/pipermail/nupedia-l/2001-January/000676.html\" class=\"external text\">\"Let's Make a Wiki\"</a>. Internet Archive. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.nupedia.com/pipermail/nupedia-l/2001-January/000676.html\" class=\"external text\">the original</a> on April 14, 2003<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-41\"> <span id=\"mw-reference-text-cite_note-41\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20070927193149/http://www.networksolutions.com/whois/results.jsp?domain=wikipedia.com\" class=\"external text\">\"WHOIS domain registration information results for wikipedia.com from Network Solutions\"</a>. September 27, 2007. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.networksolutions.com/whois/results.jsp?domain=wikipedia.com\" class=\"external text\">the original</a> on September 27, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 31,</span> 2018</span>.</cite></span></li><li id=\"cite_note-42\"> <span id=\"mw-reference-text-cite_note-42\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20070927194913/http://www.networksolutions.com/whois/results.jsp?domain=wikipedia.org\" class=\"external text\">\"WHOIS domain registration information results for wikipedia.org from Network Solutions\"</a>. September 27, 2007. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.networksolutions.com/whois/results.jsp?domain=wikipedia.org\" class=\"external text\">the original</a> on September 27, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 31,</span> 2018</span>.</cite></span></li><li id=\"cite_note-WikipediaHome-43\"> <span id=\"mw-reference-text-cite_note-WikipediaHome-43\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20010331173908/http://www.wikipedia.com/\" class=\"external text\">\"Wikipedia: HomePage\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.wikipedia.com/\" class=\"external text\">the original</a> on March 31, 2001<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 31,</span> 2001</span>.</cite></span></li><li id=\"cite_note-NPOV-44\"> <span id=\"mw-reference-text-cite_note-NPOV-44\" class=\"mw-reference-text\">\"<a href=\"/wiki/Wikipedia:Neutral_point_of_view\" title=\"Wikipedia:Neutral point of view\">Wikipedia:Neutral point of view</a>, Wikipedia (January 21, 2007).</span></li><li id=\"cite_note-Seth-Finkelstein-45\"> <span id=\"mw-reference-text-cite_note-Seth-Finkelstein-45\" class=\"mw-reference-text\"><cite class=\"citation news\">Finkelstein, Seth (September 25, 2008). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/2008/sep/25/wikipedia.internet\" class=\"external text\">\"Read me first: Wikipedia isn't about human potential, whatever Wales says\"</a>. <i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i>. London.</cite></span></li><li id=\"cite_note-WP_early_language_stats_1-46\"> <span id=\"mw-reference-text-cite_note-WP_early_language_stats_1-46\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Multilingual_statistics\" class=\"external text\">\"Multilingual statistics\"</a>. <i>Wikipedia</i>. March 30, 2005<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-EB_encyclopedia-47\"> <span id=\"mw-reference-text-cite_note-EB_encyclopedia-47\" class=\"mw-reference-text\"><cite class=\"citation encyclopaedia\">\"Encyclopedias and Dictionaries\". <i>Encyclopædia Britannica</i>. <b>18</b> (15th ed.). 2007. pp.<span>&nbsp;</span>257–286.</cite></span></li><li id=\"cite_note-EL_fears_and_start_1-48\"> <span id=\"mw-reference-text-cite_note-EL_fears_and_start_1-48\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20081006065927/http://osdir.com/ml/science.linguistics.wikipedia.international/2003-03/msg00008.html\" class=\"external text\">\"<span>[</span>long<span>]</span> Enciclopedia Libre: msg#00008\"</a>. <i>Osdir</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://osdir.com/ml/science.linguistics.wikipedia.international/2003-03/msg00008.html\" class=\"external text\">the original</a> on October 6, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-Shirky-49\"> <span id=\"mw-reference-text-cite_note-Shirky-49\" class=\"mw-reference-text\"><cite class=\"citation book\"><a href=\"/wiki/Clay_Shirky\" title=\"Clay Shirky\">Clay Shirky</a> (February 28, 2008). <a rel=\"mw:ExtLink\" href=\"https://archive.org/details/herecomeseverybo0000shir/page/273\" class=\"external text\"><i>Here Comes Everybody: The Power of Organizing Without Organizations</i></a>. The Penguin Press via Amazon Online Reader. p.<span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"https://archive.org/details/herecomeseverybo0000shir/page/273\" class=\"external text\">273</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-59420-153-0\" title=\"Special:BookSources/978-1-59420-153-0\"><bdi>978-1-59420-153-0</bdi></a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-50\"> <span id=\"mw-reference-text-cite_note-50\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"https://lists.wikimedia.org/pipermail/wikipedia-l/2002-August/003982.html\" class=\"external free\">https://lists.wikimedia.org/pipermail/wikipedia-l/2002-August/003982.html</a></span></li><li id=\"cite_note-guardian_WP_user_peak_1-51\"> <span id=\"mw-reference-text-cite_note-guardian_WP_user_peak_1-51\" class=\"mw-reference-text\"><cite class=\"citation news\">Bobbie Johnson (August 12, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/2009/aug/12/wikipedia-deletionist-inclusionist\" class=\"external text\">\"Wikipedia approaches its limits\"</a>. <i>The Guardian</i>. London<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 31,</span> 2010</span>.</cite></span></li><li id=\"cite_note-WP_growth_modelling_1-52\"> <span id=\"mw-reference-text-cite_note-WP_growth_modelling_1-52\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Modelling_Wikipedia_extended_growth\" title=\"Wikipedia:Modelling Wikipedia extended growth\">Wikipedia:Modelling_Wikipedia_extended_growth</a></span></li><li id=\"cite_note-wikisym_slowing_growth_1-53\"> <span id=\"mw-reference-text-cite_note-wikisym_slowing_growth_1-53\" class=\"mw-reference-text\"><cite class=\"citation conference\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20110511110022/http://www.wikisym.org/ws2009/procfiles/p108-suh.pdf\" class=\"external text\"><i>The Singularity is Not Near: Slowing Growth of Wikipedia</i></a> <span class=\"cs1-format\">(PDF)</span>. The International Symposium on Wikis. Orlando, Florida. 2009. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.wikisym.org/ws2009/procfiles/p108-suh.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on May 11, 2011.</cite></span></li><li id=\"cite_note-bostonreview_the_end_of_WP_1-54\"> <span id=\"mw-reference-text-cite_note-bostonreview_the_end_of_WP_1-54\" class=\"mw-reference-text\"><cite class=\"citation magazine\">Evgeny Morozov (November–December 2009). <a rel=\"mw:ExtLink\" href=\"https://bostonreview.net/books-ideas/edit-page-wikipedia-evgeny-morozov\" class=\"external text\">\"Edit This Page; Is it the end of Wikipedia\"</a>. <i>Boston Review</i>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20191211050926/http://bostonreview.net/books-ideas/edit-page-wikipedia-evgeny-morozov\" class=\"external text\">Archived</a> from the original on December 11, 2019.</cite></span></li><li id=\"cite_note-55\"> <span id=\"mw-reference-text-cite_note-55\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (March 28, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2009/03/29/weekinreview/29cohen.html\" class=\"external text\">\"Wikipedia—Exploring Fact City\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 19,</span> 2011</span>.</cite></span></li><li id=\"cite_note-stanford_WP_lack_of_future_growth_1-56\"> <span id=\"mw-reference-text-cite_note-stanford_WP_lack_of_future_growth_1-56\" class=\"mw-reference-text\">Austin Gibbons, David Vetrano, Susan Biancani (2012). <a rel=\"mw:ExtLink\" href=\"http://snap.stanford.edu/class/cs341-2012/reports/09-GibbonsVetranoBiancaniCS341.pdf\" class=\"external text\">Wikipedia: Nowhere to grow</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20140718091331/http://snap.stanford.edu/class/cs341-2012/reports/09-GibbonsVetranoBiancaniCS341.pdf\" class=\"external text\">Archived</a><span> July 18, 2014, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <span style=\"position:relative; top: -2px;\"><figure-inline><a href=\"/wiki/Open_access\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/77/Open_Access_logo_PLoS_transparent.svg/9px-Open_Access_logo_PLoS_transparent.svg.png\" data-file-width=\"640\" data-file-height=\"1000\" data-file-type=\"drawing\" height=\"14\" width=\"9\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/77/Open_Access_logo_PLoS_transparent.svg/18px-Open_Access_logo_PLoS_transparent.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/7/77/Open_Access_logo_PLoS_transparent.svg/14px-Open_Access_logo_PLoS_transparent.svg.png 1.5x\"></a></figure-inline></span></span></li><li id=\"cite_note-guardian_editors_leaving_1-57\"> <span id=\"mw-reference-text-cite_note-guardian_editors_leaving_1-57\" class=\"mw-reference-text\"><cite class=\"citation news\">Jenny Kleeman (November 26, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/2009/nov/26/wikipedia-losing-disgruntled-editors\" class=\"external text\">\"Wikipedia falling victim to a war of words\"</a>. <i>The Guardian</i>. London<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 31,</span> 2010</span>.</cite></span></li><li id=\"cite_note-58\"> <span id=\"mw-reference-text-cite_note-58\" class=\"mw-reference-text\"><cite class=\"citation journal\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120403172516/http://libresoft.es/publications/thesis-jfelipe\" class=\"external text\">\"Wikipedia: A quantitative analysis\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://libresoft.es/publications/thesis-jfelipe\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on April 3, 2012.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-WSJ_WP_losing_editors_1-59\"> <span id=\"mw-reference-text-cite_note-WSJ_WP_losing_editors_1-59\" class=\"mw-reference-text\">Volunteers Log Off as Wikipedia Ages, The Wall Street Journal, November 27, 2009.</span></li><li id=\"cite_note-telegraph_Wales_WP_not_losing_editors_1-60\"> <span id=\"mw-reference-text-cite_note-telegraph_Wales_WP_not_losing_editors_1-60\" class=\"mw-reference-text\"><cite class=\"citation news\">Barnett, Emma (November 26, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.telegraph.co.uk/technology/wikipedia/6660646/Wikipedias-Jimmy-Wales-denies-site-is-losing-thousands-of-volunteer-editors.html\" class=\"external text\">\"Wikipedia's Jimmy Wales denies site is 'losing' thousands of volunteer editors\"</a>. <i>The Daily Telegraph</i>. London<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 31,</span> 2010</span>.</cite></span></li><li id=\"cite_note-wiki-women-61\"><span></span> <span id=\"mw-reference-text-cite_note-wiki-women-61\" class=\"mw-reference-text\"><cite class=\"citation news\">Kevin Rawlinson (August 8, 2011). <a rel=\"mw:ExtLink\" href=\"https://www.independent.co.uk/life-style/gadgets-and-tech/news/wikipedia-seeks-women-to-balance-its-geeky-editors-2333605.html\" class=\"external text\">\"Wikipedia seeks women to balance its 'geeky' editors\"</a>. <i>The Independent</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 5,</span> 2012</span>.</cite></span></li><li id=\"cite_note-Simonite-2013-62\"><span></span> <span id=\"mw-reference-text-cite_note-Simonite-2013-62\" class=\"mw-reference-text\"><cite class=\"citation journal\">Simonite, Tom (October 22, 2013). <a rel=\"mw:ExtLink\" href=\"http://www.technologyreview.com/featuredstory/520446/the-decline-of-wikipedia/\" class=\"external text\">\"The Decline of Wikipedia\"</a>. <i><a href=\"/wiki/MIT_Technology_Review\" title=\"MIT Technology Review\">MIT Technology Review</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 30,</span> 2013</span>.</cite></span></li><li id=\"cite_note-63\"> <span id=\"mw-reference-text-cite_note-63\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/technology/archive/2012/07/3-charts-that-show-how-wikipedia-is-running-out-of-admins/259829\" class=\"external text\">\"3 Charts That Show How Wikipedia Is Running Out of Admins\"</a>. <i>The Atlantic</i>. July 16, 2012.</cite></span></li><li id=\"cite_note-64\"> <span id=\"mw-reference-text-cite_note-64\" class=\"mw-reference-text\">Ward, Katherine. <i>New York</i> Magazine, issue of November 25, 2013, p. 18.</span></li><li id=\"cite_note-65\"> <span id=\"mw-reference-text-cite_note-65\" class=\"mw-reference-text\"><cite class=\"citation magazine\"><a rel=\"mw:ExtLink\" href=\"http://www.pcworld.com/article/129135/wikipedia_breaks_into_us_top_10_sites.html\" class=\"external text\">\"Wikipedia Breaks Into US Top 10 Sites\"</a>. <i>PCWorld</i>. February 17, 2007.</cite></span></li><li id=\"cite_note-66\"> <span id=\"mw-reference-text-cite_note-66\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://stats.wikimedia.org/wikimedia/squids/SquidReportPageViewsPerCountryOverview.htm\" class=\"external text\">\"Wikimedia Traffic Analysis Report—Wikipedia Page Views Per Country\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 8,</span> 2015</span>.</cite></span></li><li id=\"cite_note-LA_Times_Jan_19-67\"> <span id=\"mw-reference-text-cite_note-LA_Times_Jan_19-67\" class=\"mw-reference-text\"><cite class=\"citation news\">Netburn, Deborah (January 19, 2012). <a rel=\"mw:ExtLink\" href=\"http://latimesblogs.latimes.com/technology/2012/01/wikipedia-sopa-blackout-congressional-representatives.html\" class=\"external text\">\"Wikipedia: SOPA protest led eight million to look up reps in Congress\"</a>. <i>Los Angeles Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 6,</span> 2012</span>.</cite></span></li><li id=\"cite_note-BBC_WP_blackout_protest_1-68\"> <span id=\"mw-reference-text-cite_note-BBC_WP_blackout_protest_1-68\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.bbc.co.uk/news/technology-16590585\" class=\"external text\">\"Wikipedia joins blackout protest at US anti-piracy moves\"</a>. <i>BBC News</i>. January 18, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 19,</span> 2012</span>.</cite></span></li><li id=\"cite_note-69\"> <span id=\"mw-reference-text-cite_note-69\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20180622185443/https://wikimediafoundation.org/wiki/SOPA/Blackoutpage\" class=\"external text\">\"SOPA/Blackoutpage\"</a>. Wikimedia Foundation. Archived from <a rel=\"mw:ExtLink\" href=\"https://wikimediafoundation.org/wiki/SOPA/Blackoutpage\" class=\"external text\">the original</a> on June 22, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 19,</span> 2012</span>.</cite></span></li><li id=\"cite_note-sagepub_WP_and_encyclopedic_production_1-70\"> <span id=\"mw-reference-text-cite_note-sagepub_WP_and_encyclopedic_production_1-70\" class=\"mw-reference-text\"><cite class=\"citation journal\">Jeff Loveland and Joseph Reagle (January 15, 2013). \"Wikipedia and encyclopedic production. New Media &amp; Society. Sage Journals\". <i>New Media &amp; Society</i>. <b>15</b> (8): 1294. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1177%2F1461444812470428\" class=\"external text\">10.1177/1461444812470428</a>.</cite></span></li><li id=\"cite_note-theatlantic_WP_actually_a_reversion_1-71\"> <span id=\"mw-reference-text-cite_note-theatlantic_WP_actually_a_reversion_1-71\" class=\"mw-reference-text\"><cite class=\"citation web\">Rebecca J. Rosen (January 30, 2013). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/technology/archive/2013/01/what-if-the-great-wikipedia-revolution-was-actually-a-reversion/272697\" class=\"external text\">\"What If the Great Wikipedia 'Revolution' Was Actually a Reversion? • The Atlantic\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 9,</span> 2013</span>.</cite></span></li><li id=\"cite_note-economictimes.indiatimes.com-72\"><span></span> <span id=\"mw-reference-text-cite_note-economictimes.indiatimes.com-72\" class=\"mw-reference-text\"><cite class=\"citation news\">Varma, Subodh (January 20, 2014). <a rel=\"mw:ExtLink\" href=\"http://economictimes.indiatimes.com/articleshow/29094246.cms\" class=\"external text\">\"Google eating into Wikipedia page views?\"</a>. <i>The Economic Times</i>. <a href=\"/wiki/Times_Internet_Limited\" title=\"Times Internet Limited\" class=\"mw-redirect\">Times Internet Limited</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 10,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Alexa-73\"> <span id=\"mw-reference-text-cite_note-Alexa-73\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.alexa.com/topsites\" class=\"external text\">\"Alexa Top 500 Global Sites\"</a>. <i><a href=\"/wiki/Alexa_Internet\" title=\"Alexa Internet\">Alexa Internet</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 28,</span> 2016</span>.</cite></span></li><li id=\"cite_note-Watson-74\"> <span id=\"mw-reference-text-cite_note-Watson-74\" class=\"mw-reference-text\"><cite class=\"citation journal\">Watson, J.M. (2019). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20191001153437/http://www.srgc.org.uk/logs/logdir/2019Sep261569525649IRG117.pdf\" class=\"external text\">\"Lest we forget. A new identity and status for a <i>Viola</i> of section Andinium W. Becker; named for an old and treasured friend and companion. Plus another ...\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>International Rock Gardener</i> (117): 47–. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.srgc.org.uk/logs/logdir/2019Sep261569525649IRG117.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on October 1, 2019<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 6,</span> 2019</span>.</cite></span></li><li id=\"cite_note-WRD-20190805-75\"> <span id=\"mw-reference-text-cite_note-WRD-20190805-75\" class=\"mw-reference-text\"><cite class=\"citation news\">Oberhaus, Daniel (August 5, 2019). <a rel=\"mw:ExtLink\" href=\"https://www.wired.com/story/a-crashed-israeli-lunar-lander-spilled-tardigrades-on-the-moon/\" class=\"external text\">\"A Crashed Israeli Lunar Lander Spilled Tardigrades On The Moon\"</a>. <i><a href=\"/wiki/Wired_(magazine)\" title=\"Wired (magazine)\">Wired</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 6,</span> 2019</span>.</cite></span></li><li id=\"cite_note-VOX-20190806-76\"> <span id=\"mw-reference-text-cite_note-VOX-20190806-76\" class=\"mw-reference-text\"><cite class=\"citation news\">Resnick, Brian (August 6, 2019). <a rel=\"mw:ExtLink\" href=\"https://www.vox.com/science-and-health/2019/8/6/20756844/tardigrade-moon-beresheet-arch-mission\" class=\"external text\">\"Tardigrades, the toughest animals on Earth, have crash-landed on the moon—The tardigrade conquest of the solar system has begun\"</a>. <i><a href=\"/wiki/Vox_(website)\" title=\"Vox (website)\">Vox</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 6,</span> 2019</span>.</cite></span></li><li id=\"cite_note-CNET-20190629-77\"> <span id=\"mw-reference-text-cite_note-CNET-20190629-77\" class=\"mw-reference-text\"><cite class=\"citation news\">Shankland, Stephen (June 29, 2019). <a rel=\"mw:ExtLink\" href=\"https://www.cnet.com/news/startup-packs-all-16gb-wikipedia-onto-dna-strands-demonstrate-new-storage-tech/\" class=\"external text\">\"Startup packs all 16GB of Wikipedia onto DNA strands to demonstrate new storage tech—Biological molecules will last a lot longer than the latest computer storage technology, Catalog believes\"</a>. <i><a href=\"/wiki/CNET\" title=\"CNET\">CNET</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 7,</span> 2019</span>.</cite></span></li><li id=\"cite_note-stats.wikimedia.org_editor_metric_graph-78\"> <span id=\"mw-reference-text-cite_note-stats.wikimedia.org_editor_metric_graph-78\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://w.wiki/8Hj\" class=\"external text\">\"Wikipedia Statistics (English)\"</a><span class=\"cs1-visible-error error citation-comment\"> Check <code class=\"cs1-code\"><span>|</span>url=</code> value (<a href=\"/wiki/Help:CS1_errors#bad_url\" title=\"Help:CS1 errors\">help</a>)</span>. <i>stats.wikimedia.org</i>.</cite></span></li><li id=\"cite_note-zittrain-80\"><span></span> <span id=\"mw-reference-text-cite_note-zittrain-80\" class=\"mw-reference-text\"><cite class=\"citation book\"><a href=\"/wiki/Jonathan_Zittrain\" title=\"Jonathan Zittrain\">Zittrain, Jonathan</a> (2008). <a rel=\"mw:ExtLink\" href=\"https://archive.org/details/futureofinternet00zitt\" class=\"external text\"><i>The Future of the Internet and How to Stop It—Chapter 6: The Lessons of Wikipedia</i></a>. Yale University Press. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-300-12487-3\" title=\"Special:BookSources/978-0-300-12487-3\"><bdi>978-0-300-12487-3</bdi></a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-81\"> <span id=\"mw-reference-text-cite_note-81\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Tutorial/Registration\" title=\"Wikipedia:Tutorial/Registration\">Registration notes</a></span></li><li id=\"cite_note-WP_protection_policy_1-82\"> <span id=\"mw-reference-text-cite_note-WP_protection_policy_1-82\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Protection_policy\" title=\"Wikipedia:Protection policy\">Protection Policy</a></span></li><li id=\"cite_note-83\"> <span id=\"mw-reference-text-cite_note-83\" class=\"mw-reference-text\"><cite class=\"citation news\">Hafner, Katie (June 17, 2006). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2006/06/17/technology/17wiki.html\" class=\"external text\">\"Growing Wikipedia Refines Its 'Anyone Can Edit' Policy\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-84\"> <span id=\"mw-reference-text-cite_note-84\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Protection_policy\" title=\"Wikipedia:Protection policy\">English Wikipedia's protection policy</a></span></li><li id=\"cite_note-85\"> <span id=\"mw-reference-text-cite_note-85\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Full_protection\" title=\"Wikipedia:Full protection\" class=\"mw-redirect\">English Wikipedia's full protection policy</a></span></li><li id=\"cite_note-WP_some_sites_stable_versions_1-86\"><span></span> <span id=\"mw-reference-text-cite_note-WP_some_sites_stable_versions_1-86\" class=\"mw-reference-text\"><cite class=\"citation mailinglist\">Birken, P. (December 14, 2008). <a rel=\"mw:ExtLink\" href=\"https://lists.wikimedia.org/pipermail/wikide-l/2008-December/021594.html\" class=\"external text\">\"Bericht Gesichtete Versionen\"</a>. <i>Wikide-l</i> (Mailing list) (in German). Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 15,</span> 2009</span>.</cite></span></li><li id=\"cite_note-BInsider_pending_changes_intro_1-87\"> <span id=\"mw-reference-text-cite_note-BInsider_pending_changes_intro_1-87\" class=\"mw-reference-text\"><cite class=\"citation news\">William Henderson (December 10, 2012). <a rel=\"mw:ExtLink\" href=\"http://www.businessinsider.com/pending-changes-safeguard-on-wikipedia-2012-12\" class=\"external text\">\"Wikipedia Has Figured Out A New Way To Stop Vandals In Their Tracks\"</a>. <i>Business Insider</i>.</cite></span></li><li id=\"cite_note-88\"> <span id=\"mw-reference-text-cite_note-88\" class=\"mw-reference-text\"><cite class=\"citation news\">Frewin, Jonathan (June 15, 2010). <a rel=\"mw:ExtLink\" href=\"https://www.bbc.com/news/10312095\" class=\"external text\">\"Wikipedia unlocks divisive pages for editing\"</a>. <i>BBC News</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 21,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Torsten_Kleinz-90\"><span></span> <span id=\"mw-reference-text-cite_note-Torsten_Kleinz-90\" class=\"mw-reference-text\"><cite class=\"citation news\">Kleinz, Torsten (February 2005). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20070925220722/http://w3.linux-magazine.com/issue/51/Wikipedia_Encyclopedia.pdf\" class=\"external text\">\"World of Knowledge\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>Linux Magazine</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://w3.linux-magazine.com/issue/51/Wikipedia_Encyclopedia.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on September 25, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 13,</span> 2007</span>. <q>The Wikipedia's open structure makes it a target for trolls and vandals who malevolently add incorrect information to articles, get other people tied up in endless discussions, and generally do everything to draw attention to themselves.</q></cite></span></li><li id=\"cite_note-91\"> <span id=\"mw-reference-text-cite_note-91\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:New_pages_patrol\" title=\"Wikipedia:New pages patrol\">Wikipedia:New pages patrol</a></span></li><li id=\"cite_note-FMonday_collaborative_effort_1-92\"> <span id=\"mw-reference-text-cite_note-FMonday_collaborative_effort_1-92\" class=\"mw-reference-text\">Andrea Ciffolilli, <a rel=\"mw:ExtLink\" href=\"http://firstmonday.org/article/view/1108/1028\" class=\"external text\">\"Phantom authority, self-selective recruitment, and retention of members in virtual communities: The case of Wikipedia\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161206104747/http://firstmonday.org/article/view/1108/1028\" class=\"external text\">Archived</a><span> December 6, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <i><a href=\"/wiki/First_Monday_(journal)\" title=\"First Monday (journal)\">First Monday</a></i> December 2003.</span></li><li id=\"cite_note-upenn_link_spamming_1-93\"> <span id=\"mw-reference-text-cite_note-upenn_link_spamming_1-93\" class=\"mw-reference-text\"><cite class=\"citation conference\">West, Andrew G.; Chang, Jian; Venkatasubramanian, Krishna; Sokolsky, Oleg; Lee, Insup (2011). <a rel=\"mw:ExtLink\" href=\"http://repository.upenn.edu/cgi/viewcontent.cgi?article=1508&amp;context=cis_papers\" class=\"external text\"><i>Link Spamming Wikipedia for Profit</i></a>. 8th Annual Collaboration, Electronic Messaging, Anti-Abuse, and Spam Conference. pp.<span>&nbsp;</span>152–161. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F2030376.2030394\" class=\"external text\">10.1145/2030376.2030394</a>.</cite></span></li><li id=\"cite_note-WP_vandalism_manipulation_1-94\"> <span id=\"mw-reference-text-cite_note-WP_vandalism_manipulation_1-94\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Vandalism\" title=\"Wikipedia:Vandalism\">Vandalism</a>. <i>Wikipedia</i>. Retrieved November 6, 2012.</span></li><li id=\"cite_note-MIT_IBM_study-95\"> <span id=\"mw-reference-text-cite_note-MIT_IBM_study-95\" class=\"mw-reference-text\"><cite class=\"citation book\">Fernanda B. Viégas; Martin Wattenberg; Kushal Dave (2004). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20060125025047/http://alumni.media.mit.edu/~fviegas/papers/history_flow.pdf\" class=\"external text\"><i>Studying Cooperation and Conflict between Authors with History Flow Visualizations</i></a> <span class=\"cs1-format\">(PDF)</span>. <i>Proceedings of the ACM Conference on Human Factors in Computing Systems (CHI)</i>. pp.<span>&nbsp;</span>575–582. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F985921.985953\" class=\"external text\">10.1145/985921.985953</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-58113-702-6\" title=\"Special:BookSources/978-1-58113-702-6\"><bdi>978-1-58113-702-6</bdi></a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://alumni.media.mit.edu/~fviegas/papers/history_flow.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on January 25, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 24,</span> 2007</span>.</cite></span></li><li id=\"cite_note-CreatingDestroyingAndRestoringValue-96\"> <span id=\"mw-reference-text-cite_note-CreatingDestroyingAndRestoringValue-96\" class=\"mw-reference-text\"><cite class=\"citation journal\">Reid Priedhorsky; Jilin Chen; Shyong (Tony) K. Lam; Katherine Panciera; Loren Terveen; John Riedl (November 4, 2007). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20071025080718/http://www-users.cs.umn.edu/~reid/papers/group282-priedhorsky.pdf\" class=\"external text\">\"Creating, Destroying, and Restoring Value in Wikipedia\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>Association for Computing Machinery GROUP '07 Conference Proceedings; GroupLens Research, Department of Computer Science and Engineering, University of Minnesota</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www-users.cs.umn.edu/~reid/papers/group282-priedhorsky.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on October 25, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 13,</span> 2007</span>.</cite></span></li><li id=\"cite_note-Seigenthaler-97\"><span></span> <span id=\"mw-reference-text-cite_note-Seigenthaler-97\" class=\"mw-reference-text\"><cite class=\"citation news\">Seigenthaler, John (November 29, 2005). <a rel=\"mw:ExtLink\" href=\"https://www.usatoday.com/news/opinion/editorials/2005-11-29-wikipedia-edit_x.htm\" class=\"external text\">\"A False Wikipedia 'biography<span class=\"cs1-kern-right\">'</span>\"</a>. <i>USA Today</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-book_The_World_is_Flat_1-98\"> <span id=\"mw-reference-text-cite_note-book_The_World_is_Flat_1-98\" class=\"mw-reference-text\"><cite class=\"citation book\">Friedman, Thomas L. (2007). <i>The World is Flat</i>. <a href=\"/wiki/Farrar,_Straus_&amp;_Giroux\" title=\"Farrar, Straus &amp; Giroux\" class=\"mw-redirect\">Farrar, Straus &amp; Giroux</a>. p.<span>&nbsp;</span>124. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-374-29278-2\" title=\"Special:BookSources/978-0-374-29278-2\"><bdi>978-0-374-29278-2</bdi></a>.</cite></span></li><li id=\"cite_note-99\"> <span id=\"mw-reference-text-cite_note-99\" class=\"mw-reference-text\"><cite class=\"citation web\">Buchanan, Brian (November 17, 2006). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20121221140311/http://archive.firstamendmentcenter.org/news.aspx?id=17798\" class=\"external text\">\"Founder shares cautionary tale of libel in cyberspace\"</a>. archive.firstamendmentcenter.org. Archived from <a rel=\"mw:ExtLink\" href=\"http://archive.firstamendmentcenter.org/news.aspx?id=17798\" class=\"external text\">the original</a> on December 21, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 17,</span> 2012</span>.</cite></span></li><li id=\"cite_note-100\"> <span id=\"mw-reference-text-cite_note-100\" class=\"mw-reference-text\"><cite class=\"citation news\">Helm, Burt (December 13, 2005). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120708062333/http://www.businessweek.com/stories/2005-12-13/wikipedia-a-work-in-progress\" class=\"external text\">\"Wikipedia: \"A Work in Progress<span class=\"cs1-kern-right\">\"</span>\"</a>. <i><a href=\"/wiki/BusinessWeek\" title=\"BusinessWeek\" class=\"mw-redirect\">BusinessWeek</a></i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.businessweek.com/stories/2005-12-13/wikipedia-a-work-in-progress\" class=\"external text\">the original</a> on July 8, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 26,</span> 2012</span>.</cite></span></li><li id=\"cite_note-101\"> <span id=\"mw-reference-text-cite_note-101\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Dispute_Resolution\" title=\"Wikipedia:Dispute Resolution\" class=\"mw-redirect\">Dispute Resolution</a></span></li><li id=\"cite_note-NBC_WP_editorial_warzone_12-102\"> <span id=\"mw-reference-text-cite_note-NBC_WP_editorial_warzone_12-102\" class=\"mw-reference-text\"><cite class=\"citation news\">Coldewey, Devin (June 21, 2012). <a rel=\"mw:ExtLink\" href=\"https://archive.today/20140822010030/http://sys03-public.nbcnews.com/technology/wikipedia-editorial-warzone-says-study-838793\" class=\"external text\">\"Wikipedia is editorial warzone, says study\"</a>. Technology. <i><a href=\"/wiki/NBC_News\" title=\"NBC News\">NBC News</a></i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://sys03-public.nbcnews.com/technology/wikipedia-editorial-warzone-says-study-838793\" class=\"external text\">the original</a> on August 22, 2014.</cite></span></li><li id=\"cite_note-103\"> <span id=\"mw-reference-text-cite_note-103\" class=\"mw-reference-text\"><cite class=\"citation journal\">Kalyanasundaram, Arun; Wei, Wei; Carley, Kathleen M.; Herbsleb, James D. (December 2015). \"An agent-based model of edit wars in Wikipedia: How and when is consensus reached\". <i>2015 Winter Simulation Conference (WSC)</i>. Huntington Beach, CA, USA: IEEE: 276–287. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1109%2FWSC.2015.7408171\" class=\"external text\">10.1109/WSC.2015.7408171</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/9781467397438\" title=\"Special:BookSources/9781467397438\"><bdi>9781467397438</bdi></a>.</cite></span></li><li id=\"cite_note-104\"> <span id=\"mw-reference-text-cite_note-104\" class=\"mw-reference-text\"><cite class=\"citation journal\">Suh, Bongwon; Convertino, Gregorio; Chi, Ed H.; Pirolli, Peter (2009). <a rel=\"mw:ExtLink\" href=\"http://portal.acm.org/citation.cfm?doid=1641309.1641322\" class=\"external text\">\"The singularity is not near: slowing growth of Wikipedia\"</a>. <i>Proceedings of the 5th International Symposium on Wikis and Open Collaboration—WikiSym '09</i>. Orlando, Florida: ACM Press: 1. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F1641309.1641322\" class=\"external text\">10.1145/1641309.1641322</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/9781605587301\" title=\"Special:BookSources/9781605587301\"><bdi>9781605587301</bdi></a>.</cite></span></li><li id=\"cite_note-105\"> <span id=\"mw-reference-text-cite_note-105\" class=\"mw-reference-text\"><cite class=\"citation news\">Torres, Nicole (June 2, 2016). <a rel=\"mw:ExtLink\" href=\"https://hbr.org/2016/06/why-do-so-few-women-edit-wikipedia\" class=\"external text\">\"Why Do So Few Women Edit Wikipedia?\"</a>. <i>Harvard Business Review</i>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/0017-8012\" class=\"external text\">0017-8012</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 20,</span> 2019</span>.</cite></span></li><li id=\"cite_note-106\"> <span id=\"mw-reference-text-cite_note-106\" class=\"mw-reference-text\"><cite class=\"citation journal\">Bear, Julia B.; Collier, Benjamin (March 2016). \"Where are the Women in Wikipedia? Understanding the Different Psychological Experiences of Men and Women in Wikipedia\". <i>Sex Roles</i>. <b>74</b> (5–6): 254–265. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1007%2Fs11199-015-0573-y\" class=\"external text\">10.1007/s11199-015-0573-y</a>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/0360-0025\" class=\"external text\">0360-0025</a>.</cite></span></li><li id=\"cite_note-107\"> <span id=\"mw-reference-text-cite_note-107\" class=\"mw-reference-text\"><cite class=\"citation news\">Kiss, Rachel Shabi Jemima (August 18, 2010). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/world/2010/aug/18/wikipedia-editing-zionist-groups\" class=\"external text\">\"Wikipedia editing courses launched by Zionist groups\"</a>. <i>The Guardian</i>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/0261-3077\" class=\"external text\">0261-3077</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 20,</span> 2019</span>.</cite></span></li><li id=\"cite_note-108\"> <span id=\"mw-reference-text-cite_note-108\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.haaretz.com/1.5101511\" class=\"external text\">\"The Right's Latest Weapon: 'Zionist Editing' on Wikipedia\"</a>. <i>Haaretz</i>. August 18, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 20,</span> 2019</span>.</cite></span></li><li id=\"cite_note-pcworld_who's_behind_WP-109\"> <span id=\"mw-reference-text-cite_note-pcworld_who's_behind_WP-109\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080209110303/http://www.pcworld.idg.com.au/index.php/id%3B1866322157%3Bfp%3B2%3Bfpid%3B2\" class=\"external text\">\"Who's behind Wikipedia?\"</a>. <i>PC World</i>. February 6, 2008. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.pcworld.idg.com.au/index.php/id;1866322157;fp;2;fpid;2\" class=\"external text\">the original</a> on February 9, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 7,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_content_policy_1-110\"> <span id=\"mw-reference-text-cite_note-WP_content_policy_1-110\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:What_Wikipedia_is_not\" title=\"Wikipedia:What Wikipedia is not\">What Wikipedia is not</a>. Retrieved April 1, 2010. \"Wikipedia is not a dictionary, usage, or jargon guide.\"</span></li><li id=\"cite_note-WP_notability_guide_1-111\"> <span id=\"mw-reference-text-cite_note-WP_notability_guide_1-111\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Notability\" title=\"Wikipedia:Notability\">Notability</a>. Retrieved February 13, 2008. \"A topic is presumed to be notable if it has received significant coverage in reliable secondary sources that are independent of the subject.\"</span></li><li id=\"cite_note-NOR-112\"> <span id=\"mw-reference-text-cite_note-NOR-112\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:No_original_research\" title=\"Wikipedia:No original research\">No original research</a>. February 13, 2008. \"Wikipedia does not publish original thought.\"</span></li><li id=\"cite_note-WP_Verifiability_policy_1-113\"> <span id=\"mw-reference-text-cite_note-WP_Verifiability_policy_1-113\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Verifiability\" title=\"Wikipedia:Verifiability\">Verifiability</a>. February 13, 2008. \"Material challenged or likely to be challenged, and all quotations, must be attributed to a reliable, published source.\"</span></li><li id=\"cite_note-IHT_WP_valid_info_wrong_removable_1-114\"> <span id=\"mw-reference-text-cite_note-IHT_WP_valid_info_wrong_removable_1-114\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (August 9, 2011). \"For inclusive mission, Wikipedia is told that written word goes only so far\". <i><a href=\"/wiki/International_Herald_Tribune\" title=\"International Herald Tribune\" class=\"mw-redirect\">International Herald Tribune</a></i>. p.<span>&nbsp;</span>18.</cite><span style=\"font-size:0.95em; font-size:90%; color:#555\">(subscription required)</span></span></li><li id=\"cite_note-autogenerated2-115\"> <span id=\"mw-reference-text-cite_note-autogenerated2-115\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Neutral_point_of_view\" title=\"Wikipedia:Neutral point of view\">Neutral point of view</a>. February 13, 2008. \"All Wikipedia articles and other encyclopedic content must be written from a neutral point of view, representing significant views fairly, proportionately and without bias.\"</span></li><li id=\"cite_note-116\"> <span id=\"mw-reference-text-cite_note-116\" class=\"mw-reference-text\"><cite class=\"citation web\">Sanger, Larry (April 18, 2005). <a rel=\"mw:ExtLink\" href=\"http://features.slashdot.org/story/05/04/18/164213/the-early-history-of-nupedia-and-wikipedia-a-memoir\" class=\"external text\">\"The Early History of Nupedia and Wikipedia: A Memoir\"</a>. <i>Slashdot</i>. Dice.</cite></span></li><li id=\"cite_note-117\"> <span id=\"mw-reference-text-cite_note-117\" class=\"mw-reference-text\"><cite class=\"citation journal\">Kostakis, Vasilis (March 2010). <a rel=\"mw:ExtLink\" href=\"http://firstmonday.org/ojs/index.php/fm/article/view/2613/2479\" class=\"external text\">\"Identifying and understanding the problems of Wikipedia's peer governance: The case of inclusionists versus deletionists\"</a>. <i>First Monday</i>. <b>15</b> (3).</cite></span></li><li id=\"cite_note-118\"> <span id=\"mw-reference-text-cite_note-118\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Ownership_of_articles\" title=\"Wikipedia:Ownership of articles\" class=\"mw-redirect\">Ownership of articles</a></span></li><li id=\"cite_note-119\"> <span id=\"mw-reference-text-cite_note-119\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Administrators\" title=\"Wikipedia:Administrators\">Wikipedia:Administrators</a></span></li><li id=\"cite_note-David_Mehegan-120\"> <span id=\"mw-reference-text-cite_note-David_Mehegan-120\" class=\"mw-reference-text\"><cite class=\"citation news\">Mehegan, David (February 13, 2006). <a rel=\"mw:ExtLink\" href=\"https://www.boston.com/business/technology/articles/2006/02/13/many_contributors_common_cause\" class=\"external text\">\"Many contributors, common cause\"</a>. <i>Boston Globe</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 25,</span> 2007</span>.</cite></span></li><li id=\"cite_note-121\"> <span id=\"mw-reference-text-cite_note-121\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Administrators#Administrator_conduct\" class=\"external text\">\"Wikipedia:Administrators\"</a>. October 3, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 12,</span> 2009</span>.</cite></span></li><li id=\"cite_note-122\"> <span id=\"mw-reference-text-cite_note-122\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:RfA_Review/Reflect\" class=\"external text\">\"Wikipedia:RfA_Review/Reflect\"</a>. January 22, 2017<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 24,</span> 2009</span>.</cite></span></li><li id=\"cite_note-123\"> <span id=\"mw-reference-text-cite_note-123\" class=\"mw-reference-text\"><cite class=\"citation web\">Meyer, Robinson (July 16, 2012). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/technology/archive/2012/07/3-charts-that-show-how-wikipedia-is-running-out-of-admins/259829\" class=\"external text\">\"3 Charts That Show How Wikipedia Is Running Out of Admins\"</a>. <i><a href=\"/wiki/The_Atlantic\" title=\"The Atlantic\">The Atlantic</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 2,</span> 2012</span>.</cite></span></li><li id=\"cite_note-emory_disputes_handled_1-125\"> <span id=\"mw-reference-text-cite_note-emory_disputes_handled_1-125\" class=\"mw-reference-text\"><cite class=\"citation journal\">David A. Hoffman; Salil K. Mehra (2009). \"Wikitruth through Wikiorder\". <i>Emory Law Journal</i>. <b>59</b> (1): 181. <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//ssrn.com/abstract=1354424\" class=\"external text\">1354424</a></span>.</cite></span></li><li id=\"cite_note-126\"> <span id=\"mw-reference-text-cite_note-126\" class=\"mw-reference-text\"><cite class=\"citation journal\">David A. Hoffman; Salil K. Mehra (2009). \"Wikitruth through Wikiorder\". <i><a href=\"/wiki/Emory_Law_Journal\" title=\"Emory Law Journal\" class=\"mw-redirect\">Emory Law Journal</a></i>. <b>59</b> (1): 151–210. <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//ssrn.com/abstract=1354424\" class=\"external text\">1354424</a></span>.</cite></span></li><li id=\"cite_note-127\"> <span id=\"mw-reference-text-cite_note-127\" class=\"mw-reference-text\"><cite class=\"citation journal\"><a href=\"/wiki/Fernanda_B._Viégas\" title=\"Fernanda B. Viégas\" class=\"mw-redirect\">Fernanda B. Viégas</a>; <a href=\"/wiki/Martin_M._Wattenberg\" title=\"Martin M. Wattenberg\">Martin M. Wattenberg</a>; Jesse Kriss; Frank van Ham (January 3, 2007). <a rel=\"mw:ExtLink\" href=\"http://www.research.ibm.com/visual/papers/wikipedia_coordination_final.pdf\" class=\"external text\">\"Talk Before You Type: Coordination in Wikipedia\"</a> <span class=\"cs1-format\">(PDF)</span>. Visual Communication Lab, <a href=\"/wiki/IBM_Research\" title=\"IBM Research\">IBM Research</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 27,</span> 2008</span>.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-128\"> <span id=\"mw-reference-text-cite_note-128\" class=\"mw-reference-text\"><cite class=\"citation news\">Arthur, Charles (December 15, 2005). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/2005/dec/15/wikipedia.web20\" class=\"external text\">\"Log on and join in, but beware the web cults\"</a>. <i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i>. London<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-129\"> <span id=\"mw-reference-text-cite_note-129\" class=\"mw-reference-text\"><cite class=\"citation news\">Lu Stout, Kristie (August 4, 2003). <a rel=\"mw:ExtLink\" href=\"http://www.cnn.com/2003/TECH/internet/08/03/wikipedia/index.html\" class=\"external text\">\"Wikipedia: The know-it-all Web site\"</a>. CNN<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-130\"> <span id=\"mw-reference-text-cite_note-130\" class=\"mw-reference-text\"><cite class=\"citation web\"><a href=\"/wiki/Larry_Sanger\" title=\"Larry Sanger\">Larry Sanger</a> (December 31, 2004). <a rel=\"mw:ExtLink\" href=\"http://www.kuro5hin.org/story/2004/12/30/142458/25\" class=\"external text\">\"Why Wikipedia Must Jettison Its Anti-Elitism\"</a>. <i><a href=\"/wiki/Kuro5hin.org\" title=\"Kuro5hin.org\" class=\"mw-redirect\">Kuro5hin</a>, Op–Ed</i>. <q>There is a certain mindset associated with unmoderated Usenet groups [...] that infects the collectively-managed Wikipedia project: if you react strongly to trolling, that reflects poorly on you, not (necessarily) on the troll. If you [...] demand that something be done about constant disruption by trollish behavior, the other listmembers will cry \"censorship\", attack you, and even come to the defense of the troll. [...] The root problem: anti-elitism, or lack of respect for expertise. There is a deeper problem [...] which explains both of the above-elaborated problems. Namely, as a community, Wikipedia lacks the habit or tradition of respect for expertise. As a community, far from being elitist, it is anti-elitist (which, in this context, means that expertise is not accorded any special respect, and snubs and disrespect of expertise is tolerated). This is one of my failures: a policy that I attempted to institute in Wikipedia's first year, but for which I did not muster adequate support, was the policy of respecting and deferring politely to experts. (Those who were there will, I hope, remember that I tried very hard.)</q></cite></span></li><li id=\"cite_note-131\"> <span id=\"mw-reference-text-cite_note-131\" class=\"mw-reference-text\"><cite class=\"citation book\">Kriplean TK, Beschastnikh I, McDonald DW (2008). \"Articulations of wikiwork\". <i>Articulations of wikiwork: uncovering valued work in Wikipedia through barnstars</i>. Proceedings of the ACM. p.<span>&nbsp;</span>47. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F1460563.1460573\" class=\"external text\">10.1145/1460563.1460573</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-60558-007-4\" title=\"Special:BookSources/978-1-60558-007-4\"><bdi>978-1-60558-007-4</bdi></a>.</cite> <span style=\"font-size:0.95em; font-size:90%; color:#555\">(Subscription required.)</span></span></li><li id=\"cite_note-user_identification-132\"> <span id=\"mw-reference-text-cite_note-user_identification-132\" class=\"mw-reference-text\"><cite class=\"citation web\">Jean Goodwin (2009). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20091122202231/http://www.public.iastate.edu/~goodwin/pubs/goodwinwikipedia.pdf\" class=\"external text\">\"The Authority of Wikipedia\"</a> <span class=\"cs1-format\">(PDF)</span>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.public.iastate.edu/~goodwin/pubs/goodwinwikipedia.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on November 22, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 31,</span> 2011</span>. <q>Wikipedia's commitment to anonymity/pseudonymity thus imposes a sort of epistemic agnosticism on its readers</q></cite></span></li><li id=\"cite_note-133\"> <span id=\"mw-reference-text-cite_note-133\" class=\"mw-reference-text\"><cite class=\"citation journal\">Kittur, Aniket (2007). \"Power of the Few vs. Wisdom of the Crowd: Wikipedia and the Rise of the Bourgeoisie\". Viktoria Institute. <a href=\"/wiki/CiteSeerX\" title=\"CiteSeerX\">CiteSeerX</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.212.8218\" class=\"external text\">10.1.1.212.8218</a></span>.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-blodget-134\"><span></span> <span id=\"mw-reference-text-cite_note-blodget-134\" class=\"mw-reference-text\"><cite class=\"citation news\">Blodget, Henry (January 3, 2009). <a rel=\"mw:ExtLink\" href=\"http://www.businessinsider.com/2009/1/who-the-hell-writes-wikipedia-anyway\" class=\"external text\">\"Who The Hell Writes Wikipedia, Anyway?\"</a>. <i>Business Insider</i>.</cite></span></li><li id=\"cite_note-135\"> <span id=\"mw-reference-text-cite_note-135\" class=\"mw-reference-text\"><cite class=\"citation news\">Wilson, Chris (February 22, 2008). <a rel=\"mw:ExtLink\" href=\"http://www.slate.com/id/2184487\" class=\"external text\">\"The Wisdom of the Chaperones\"</a>. <i><a href=\"/wiki/Slate_(magazine)\" title=\"Slate (magazine)\">Slate</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 13,</span> 2014</span>.</cite></span></li><li id=\"cite_note-136\"> <span id=\"mw-reference-text-cite_note-136\" class=\"mw-reference-text\"><cite class=\"citation web\">Swartz, Aaron (September 4, 2006). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20140803134036/http://www.aaronsw.com/weblog/whowriteswikipedia\" class=\"external text\">\"Raw Thought: Who Writes Wikipedia?\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.aaronsw.com/weblog/whowriteswikipedia\" class=\"external text\">the original</a> on August 3, 2014<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 23,</span> 2008</span>.</cite></span></li><li id=\"cite_note-labor_squeeze_on_WP_1-137\"><span></span> <span id=\"mw-reference-text-cite_note-labor_squeeze_on_WP_1-137\" class=\"mw-reference-text\"><cite class=\"citation journal\">Goldman, Eric. \"Wikipedia's Labor Squeeze and its Consequences\". <b>8</b>. Journal on Telecommunications and High Technology Law.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-legal_edu_and_WP_1-138\"> <span id=\"mw-reference-text-cite_note-legal_edu_and_WP_1-138\" class=\"mw-reference-text\"><cite class=\"citation journal\">Noveck, Beth Simone. \"Wikipedia and the Future of Legal Education\". <b>57</b>. Journal of Legal Education.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-sciam_good_samaritans_1-139\"> <span id=\"mw-reference-text-cite_note-sciam_good_samaritans_1-139\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://www.sciam.com/article.cfm?id=good-samaritans-are-on-the-money\" class=\"external text\">\"Wikipedia \"Good Samaritans\" Are on the Money\"</a>. <i>Scientific American</i>. October 19, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-liebertonline_view_on_WP_users_1-140\"> <span id=\"mw-reference-text-cite_note-liebertonline_view_on_WP_users_1-140\" class=\"mw-reference-text\">Yair Amichai–Hamburger, Naama Lamdan, Rinat Madiel, Tsahi Hayat, <a rel=\"mw:ExtLink\" href=\"https://archive.today/20121209032032/http://www.liebertonline.com/doi/abs/10.1089/cpb.2007.0225\" class=\"external text\">Personality Characteristics of Wikipedia Members</a>, <i>CyberPsychology &amp; Behavior</i>, December 1, 2008, 11 (6): 679–681; <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a><span>:</span><a rel=\"mw:ExtLink\" href=\"https://doi.org/10.1089%2Fcpb.2007.0225\" class=\"external text\">10.1089/cpb.2007.0225</a>.</span></li><li id=\"cite_note-newscientist_view_on_WP_users_1-141\"> <span id=\"mw-reference-text-cite_note-newscientist_view_on_WP_users_1-141\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.newscientist.com/article/mg20126883.900-wikipedians-are-closed-and-disagreeable.html\" class=\"external text\">\"Wikipedians are 'closed' and 'disagreeable<span class=\"cs1-kern-right\">'</span>\"</a>. <i>New Scientist</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 13,</span> 2010</span>.</cite> <span style=\"font-size:0.95em; font-size:90%; color:#555\">(Subscription required.)</span></span></li><li id=\"cite_note-142\"> <span id=\"mw-reference-text-cite_note-142\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.psychologytoday.com/blog/unique-everybody-else/201303/the-misunderstood-personality-profile-wikipedia-members\" class=\"external text\">\"The Misunderstood Personality Profile of Wikipedia Members\"</a>. <i>psychologytoday.com</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-newscientist_WP_boom_to_bust_1-143\"> <span id=\"mw-reference-text-cite_note-newscientist_WP_boom_to_bust_1-143\" class=\"mw-reference-text\"><cite class=\"citation web\">Giles, Jim (August 4, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.newscientist.com/article/dn17554-after-the-boom-is-wikipedia-heading-for-bust.html\" class=\"external text\">\"After the boom, is Wikipedia heading for bust?\"</a>. <i>New Scientist</i>.</cite></span></li><li id=\"cite_note-144\"> <span id=\"mw-reference-text-cite_note-144\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam. <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2011/01/31/business/media/31link.html?_r=0\" class=\"external text\">\"Define Gender Gap? Look Up Wikipedia's Contributor List\"</a>. <i>The New York Times</i>. The New York Times Company<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 28,</span> 2013</span>.</cite></span></li><li id=\"cite_note-145\"> <span id=\"mw-reference-text-cite_note-145\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://www.cbc.ca/news/canada/toronto/ocad-to-storm-wikipedia-this-fall-1.1412807\" class=\"external text\">\"OCAD to 'Storm Wikipedia' this fall\"</a>. <i>CBC News</i>. August 27, 2013<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 21,</span> 2014</span>.</cite></span></li><li id=\"cite_note-146\"> <span id=\"mw-reference-text-cite_note-146\" class=\"mw-reference-text\">Dimitra Kessenides (December 26, 2017). <a href=\"/wiki/Bloomberg_News\" title=\"Bloomberg News\">Bloomberg News</a> Weekly, \"Is Wikipedia 'Woke'\". p. 73.</span></li><li id=\"cite_note-memeb-147\"><span></span> <span id=\"mw-reference-text-cite_note-memeb-147\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://memeburn.com/2018/06/wikipedia-wikimania-africa-numbers/\" class=\"external text\">\"The startling numbers behind Africa's Wikipedia knowledge gaps\"</a>. <i>memeburn.com</i>. June 21, 2018.</cite></span></li><li id=\"cite_note-WP_list_of_WPs_by_article_1-148\"> <span id=\"mw-reference-text-cite_note-WP_list_of_WPs_by_article_1-148\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/List_of_Wikipedias#All_Wikipedias_ordered_by_number_of_articles\" class=\"external text\">\"Wikipedia:List of Wikipedias\"</a>. English Wikipedia<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 16,</span> 2020</span>.</cite></span></li><li id=\"cite_note-ListOfWikipedias-149\"> <span id=\"mw-reference-text-cite_note-ListOfWikipedias-149\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Special:Statistics\" class=\"external text\">\"Statistics\"</a>. <a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English Wikipedia</a>. October 4, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 21,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_list_of_WPs_1-150\"> <span id=\"mw-reference-text-cite_note-WP_list_of_WPs_1-150\" class=\"mw-reference-text\"><a href=\"https://meta.wikimedia.org/wiki/List%20of%20Wikipedias\" title=\"meta:List of Wikipedias\">List of Wikipedias</a></span></li><li id=\"cite_note-meta.wikimedia-151\"> <span id=\"mw-reference-text-cite_note-meta.wikimedia-151\" class=\"mw-reference-text\"><a href=\"https://meta.wikimedia.org/wiki/List%20of%20Wikipedias#1+_articles\" title=\"m:List of Wikipedias\">List of Wikipedias—Meta</a></span></li><li id=\"cite_note-152\"> <span id=\"mw-reference-text-cite_note-152\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://meta.wikimedia.org/wiki/List_of_Wikipedias#All_Wikipedias_ordered_by_number_of_articles\" class=\"external text\">\"List of Wikipedias\"</a>. <i>Wikimedia Meta-Wiki</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 16,</span> 2020</span>.</cite></span></li><li id=\"cite_note-WP_spelling_MOS_1-153\"> <span id=\"mw-reference-text-cite_note-WP_spelling_MOS_1-153\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Manual_of_Style/Spelling\" class=\"external text\">\"Spelling\"</a>. <i>Manual of Style</i>. Wikipedia. September 26, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 19,</span> 2007</span>.</cite></span></li><li id=\"cite_note-WP_countering_bias_1-154\"> <span id=\"mw-reference-text-cite_note-WP_countering_bias_1-154\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:WikiProject_Countering_systemic_bias\" class=\"external text\">\"Countering systemic bias\"</a>. July 15, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 19,</span> 2007</span>.</cite></span></li><li id=\"cite_note-WP_meta_fair_use_1-155\"> <span id=\"mw-reference-text-cite_note-WP_meta_fair_use_1-155\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Fair_use\" class=\"external text\">\"Fair use\"</a>. Meta-Wiki<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 14,</span> 2007</span>.</cite></span></li><li id=\"cite_note-WP_meta_WP_images_1-156\"> <span id=\"mw-reference-text-cite_note-WP_meta_WP_images_1-156\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Images_on_Wikipedia\" class=\"external text\">\"Images on Wikipedia\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 14,</span> 2007</span>.</cite></span></li><li id=\"cite_note-IBM_visual_WP_1-157\"> <span id=\"mw-reference-text-cite_note-IBM_visual_WP_1-157\" class=\"mw-reference-text\"><cite class=\"citation journal\">Fernanda B. Viégas (January 3, 2007). <a rel=\"mw:ExtLink\" href=\"http://www.research.ibm.com/visual/papers/viegas_hicss_visual_wikipedia.pdf\" class=\"external text\">\"The Visual Side of Wikipedia\"</a> <span class=\"cs1-format\">(PDF)</span>. Visual Communication Lab, IBM Research<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 30,</span> 2007</span>.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-WP_Wales_free_multi-lingual_encyclopedia-158\"> <span id=\"mw-reference-text-cite_note-WP_Wales_free_multi-lingual_encyclopedia-158\" class=\"mw-reference-text\"><a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a>, <a href=\"https://lists.wikimedia.org/pipermail/wikipedia-l/2005-March/020469.html\" title=\"mailarchive:wikipedia-l/2005-March/020469.html\">\"Wikipedia is an encyclopedia\"</a>, March 8, 2005, <span>&lt;</span>Wikipedia-l@wikimedia.org<span>&gt;</span></span></li><li id=\"cite_note-WP_metawiki_maintenance_1-159\"> <span id=\"mw-reference-text-cite_note-WP_metawiki_maintenance_1-159\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org\" class=\"external text\">\"Meta-Wiki\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 24,</span> 2009</span>.</cite></span></li><li id=\"cite_note-WP_meta_stats_1-160\"> <span id=\"mw-reference-text-cite_note-WP_meta_stats_1-160\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Statistics\" class=\"external text\">\"Meta-Wiki Statistics\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 24,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_meta_articles_on_all_sites_1-161\"> <span id=\"mw-reference-text-cite_note-WP_meta_articles_on_all_sites_1-161\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/List_of_articles_every_Wikipedia_should_have\" class=\"external text\">\"List of articles every Wikipedia should have\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 24,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_auto-translations_rules_1-162\"> <span id=\"mw-reference-text-cite_note-WP_auto-translations_rules_1-162\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Translation\" class=\"external text\">\"Wikipedia: Translation\"</a>. <i>English Wikipedia</i>. September 27, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 3,</span> 2007</span>.</cite></span></li><li id=\"cite_note-163\"> <span id=\"mw-reference-text-cite_note-163\" class=\"mw-reference-text\"><cite class=\"citation journal\">Yasseri, Taha; Sumi, Robert; <a href=\"/wiki/János_Kertész\" title=\"János Kertész\">Kertész, János</a> (January 17, 2012). <a rel=\"mw:ExtLink\" href=\"//www.ncbi.nlm.nih.gov/pmc/articles/PMC3260192\" class=\"external text\">\"Circadian Patterns of Wikipedia Editorial Activity: A Demographic Analysis\"</a>. <i><a href=\"/wiki/PLoS_ONE\" title=\"PLoS ONE\" class=\"mw-redirect\">PLoS ONE</a></i>. <b>7</b> (1): e30091. <a href=\"/wiki/ArXiv\" title=\"ArXiv\">arXiv</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//arxiv.org/abs/1109.1746\" class=\"external text\">1109.1746</a></span>. <a href=\"/wiki/Bibcode\" title=\"Bibcode\">Bibcode</a>:<a rel=\"mw:ExtLink\" href=\"https://ui.adsabs.harvard.edu/abs/2012PLoSO...730091Y\" class=\"external text\">2012PLoSO...730091Y</a>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1371%2Fjournal.pone.0030091\" class=\"external text\">10.1371/journal.pone.0030091</a>. <a href=\"/wiki/PubMed_Central\" title=\"PubMed Central\">PMC</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//www.ncbi.nlm.nih.gov/pmc/articles/PMC3260192\" class=\"external text\">3260192</a></span>. <a href=\"/wiki/PubMed_Identifier\" title=\"PubMed Identifier\" class=\"mw-redirect\">PMID</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//pubmed.ncbi.nlm.nih.gov/22272279\" class=\"external text\">22272279</a>.</cite></span></li><li id=\"cite_note-WP_global_south_demographic_increase_plan_1-164\"> <span id=\"mw-reference-text-cite_note-WP_global_south_demographic_increase_plan_1-164\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://upload.wikimedia.org/wikipedia/foundation/3/37/2011-12_Wikimedia_Foundation_Plan_FINAL_FOR_WEBSITE_.pdf\" class=\"external text\">\"Wikimedia Foundation 2011–12 Annual Plan\"</a> <span class=\"cs1-format\">(PDF)</span>. Wikimedia Foundation. p.<span>&nbsp;</span>8<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-economist1-165\"><span></span> <span id=\"mw-reference-text-cite_note-economist1-165\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.economist.com/news/international/21597959-popular-online-encyclopedia-must-work-out-what-next-wikipeaks\" class=\"external text\">\"The future of Wikipedia: WikiPeaks?\"</a>. <i>The Economist</i>. March 1, 2014<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 11,</span> 2014</span>.</cite></span></li><li id=\"cite_note-166\"> <span id=\"mw-reference-text-cite_note-166\" class=\"mw-reference-text\">Andrew Lih. <i>Wikipedia</i>. Alternative edit policies at Wikipedia in other languages.</span></li><li id=\"cite_note-bureaucracy-167\"> <span id=\"mw-reference-text-cite_note-bureaucracy-167\" class=\"mw-reference-text\"><cite class=\"citation magazine\">Jemielniak, Dariusz (June 22, 2014). <a rel=\"mw:ExtLink\" href=\"http://www.slate.com/articles/technology/future_tense/2014/06/wikipedia_s_bureaucracy_problem_and_how_to_fix_it.html\" class=\"external text\">\"The Unbearable Bureaucracy of Wikipedia\"</a>. <i><a href=\"/wiki/Slate_(magazine)\" title=\"Slate (magazine)\">Slate</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 18,</span> 2014</span>.</cite></span></li><li id=\"cite_note-168\"> <span id=\"mw-reference-text-cite_note-168\" class=\"mw-reference-text\">D. Jemielniak, <i>Common Knowledge</i>, Stanford University Press, 2014.</span></li><li id=\"cite_note-169\"> <span id=\"mw-reference-text-cite_note-169\" class=\"mw-reference-text\">Messer-Kruse, Timothy (February 12, 2012) <a rel=\"mw:ExtLink\" href=\"http://chronicle.com/article/The-Undue-Weight-of-Truth-on/130704/\" class=\"external text\">The 'Undue Weight' of Truth on Wikipedia</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161218162359/http://chronicle.com/article/The-Undue-Weight-of-Truth-on/130704/\" class=\"external text\">Archived</a><span> December 18, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <i><a href=\"/wiki/The_Chronicle_of_Higher_Education\" title=\"The Chronicle of Higher Education\">The Chronicle of Higher Education</a></i> Retrieved March 27, 2014</span></li><li id=\"cite_note-170\"> <span id=\"mw-reference-text-cite_note-170\" class=\"mw-reference-text\">Colón-Aguirre, Monica &amp; Fleming-May, Rachel A. (October 11, 2012) <a rel=\"mw:ExtLink\" href=\"http://faculty.washington.edu/jwj/lis521/colon%20wikipedia.pdf\" class=\"external text\">\"You Just Type in What You Are Looking For\": Undergraduates' Use of Library Resources vs. Wikipedia</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160419031904/http://faculty.washington.edu/jwj/lis521/colon%20wikipedia.pdf\" class=\"external text\">Archived</a><span> April 19, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> (p. 392) <i><a href=\"/wiki/The_Journal_of_Academic_Librarianship\" title=\"The Journal of Academic Librarianship\">The Journal of Academic Librarianship</a></i> Retrieved March 27, 2014</span></li><li id=\"cite_note-171\"> <span id=\"mw-reference-text-cite_note-171\" class=\"mw-reference-text\">Bowling Green News (February 27, 2012) <a rel=\"mw:ExtLink\" href=\"http://www.bgsu.edu/news/2012/02/wikipedia-experience-sparks-national-debate.html\" class=\"external text\">Wikipedia experience sparks national debate</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160827120800/http://www.bgsu.edu/news/2012/02/wikipedia-experience-sparks-national-debate.html\" class=\"external text\">Archived</a><span> August 27, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <a href=\"/wiki/Bowling_Green_State_University\" title=\"Bowling Green State University\">Bowling Green State University</a> Retrieved March 27, 2014</span></li><li id=\"cite_note-okw-172\"> <span id=\"mw-reference-text-cite_note-okw-172\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20110814104256/http://www.timesonline.co.uk/tol/comment/columnists/guest_contributors/article2267665.ece\" class=\"external text\">Wisdom? More like dumbness of the crowds | Oliver Kamm—Times Online (archive version 2011-08-14)</a> (<a rel=\"mw:ExtLink\" href=\"http://oliverkamm.typepad.com/blog/2007/08/wisdom-more-lik.html\" class=\"external text\">Author's own copy</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160905131644/http://oliverkamm.typepad.com/blog/2007/08/wisdom-more-lik.html\" class=\"external text\">Archived</a><span> September 5, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>)</span></li><li id=\"cite_note-wwplagiarism-173\"> <span id=\"mw-reference-text-cite_note-wwplagiarism-173\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://www.webcitation.org/5lXiLbptk?url=http://www.wikipedia-watch.org/psamples.html\" class=\"external text\">\"Plagiarism by Wikipedia editors\"</a>. Wikipedia Watch. October 27, 2006. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.wikipedia-watch.org/psamples.html\" class=\"external text\">the original</a> on November 25, 2009.</cite></span></li><li id=\"cite_note-174\"> <span id=\"mw-reference-text-cite_note-174\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://archive.wired.com/culture/lifestyle/news/2005/12/69844\" class=\"external text\">\"Wikipedia, Britannica: A Toss-Up\"</a>. <i>Wired</i>. Associated Press. December 15, 2005<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 8,</span> 2015</span>.</cite></span></li><li id=\"cite_note-corporate.britannica.com-175\"> <span id=\"mw-reference-text-cite_note-corporate.britannica.com-175\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"http://corporate.britannica.com/britannica_nature_response.pdf\" class=\"external text\">Fatally Flawed: Refuting the recent study on encyclopedic accuracy by the journal Nature</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160709053629/http://corporate.britannica.com/britannica_nature_response.pdf\" class=\"external text\">Archived</a> July 9, 2016, at the <a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, Encyclopædia Britannica, March 2006</span></li><li id=\"cite_note-nature.com_britannica_response_1-176\"> <span id=\"mw-reference-text-cite_note-nature.com_britannica_response_1-176\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.nature.com/press_releases/Britannica_response.pdf?item\" class=\"external text\">\"Encyclopaedia Britannica and Nature: a response\"</a> <span class=\"cs1-format\">(PDF)</span><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 13,</span> 2010</span>.</cite></span></li><li id=\"cite_note-nature.com-177\"> <span id=\"mw-reference-text-cite_note-nature.com-177\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20170515025717/http://www.nature.com/nature/britannica/index.html\" class=\"external text\">\"Nature's responses to Encyclopaedia Britannica\"</a>. <i>Nature</i>. March 30, 2006. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.nature.com/nature/britannica/index.html\" class=\"external text\">the original</a> on May 15, 2017<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 25,</span> 2018</span>.</cite></span></li><li id=\"cite_note-178\"> <span id=\"mw-reference-text-cite_note-178\" class=\"mw-reference-text\">See author acknowledged comments in response to the citation of the <i>Nature</i> study, at <i>PLoS ONE</i>, 2014, \"Citation of fundamentally flawed <i>Nature</i> quality 'study' \", In response to T. Yasseri et al. (2012) Dynamics of Conflicts in Wikipedia, Published June 20, 2012, <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a><span>:</span><a rel=\"mw:ExtLink\" href=\"https://doi.org/10.1371%2Fjournal.pone.0038869\" class=\"external text\">10.1371/journal.pone.0038869</a>, see <cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160116210930/http://www.plosone.org/annotation/listThread.action?root=80078\" class=\"external text\">\"Dynamics of Conflicts in Wikipedia\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.plosone.org/annotation/listThread.action?root%3D80078\" class=\"external text\">the original</a> on January 16, 2016<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 22,</span> 2014</span>.</cite>, accessed July 21, 2014.</span></li><li id=\"cite_note-WP_general_disclaimer_1-179\"> <span id=\"mw-reference-text-cite_note-WP_general_disclaimer_1-179\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:General_disclaimer\" class=\"external text\">\"Wikipedia:General disclaimer\"</a>. English Wikipedia. September 18, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 22,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WikipediaWatch-180\"> <span id=\"mw-reference-text-cite_note-WikipediaWatch-180\" class=\"mw-reference-text\">Public Information Research, Wikipedia Watch</span></li><li id=\"cite_note-pcworld_WP_blunders_1-181\"> <span id=\"mw-reference-text-cite_note-pcworld_WP_blunders_1-181\" class=\"mw-reference-text\"><cite class=\"citation web\">Raphel, JR (August 26, 2009). <a rel=\"mw:ExtLink\" href=\"http://www.pcworld.com/article/170874/the_15_biggest_wikipedia_blunders.html\" class=\"external text\">\"The 15 Biggest Wikipedia Blunders\"</a>. <i><a href=\"/wiki/PC_World\" title=\"PC World\">PC World</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 2,</span> 2009</span>.</cite></span></li><li id=\"cite_note-tnr_experts_vigilant_in_correcting_WP_1-182\"> <span id=\"mw-reference-text-cite_note-tnr_experts_vigilant_in_correcting_WP_1-182\" class=\"mw-reference-text\"><cite class=\"citation web\">Cowen, Tyler (March 14, 2008). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080318103017/http://www.tnr.com/story.html?id=82eb5d70-13bd-4086-9ec0-cb0e9e8411b3\" class=\"external text\">\"Cooked Books\"</a>. <i>The New Republic</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.tnr.com/story.html?id=82eb5d70-13bd-4086-9ec0-cb0e9e8411b3\" class=\"external text\">the original</a> on March 18, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-TNY_reliability_issues_1-183\"> <span id=\"mw-reference-text-cite_note-TNY_reliability_issues_1-183\" class=\"mw-reference-text\"><cite class=\"citation news\"><a href=\"/wiki/Stacy_Schiff\" title=\"Stacy Schiff\">Stacy Schiff</a> (July 31, 2006). \"Know It All\". <i><a href=\"/wiki/The_New_Yorker\" title=\"The New Yorker\">The New Yorker</a></i>.</cite></span></li><li id=\"cite_note-AcademiaAndWikipedia-184\"> <span id=\"mw-reference-text-cite_note-AcademiaAndWikipedia-184\" class=\"mw-reference-text\"><cite class=\"citation web\">Danah Boyd (January 4, 2005). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20060316184224/http://many.corante.com/archives/2005/01/04/academia_and_wikipedia.php\" class=\"external text\">\"Academia and Wikipedia\"</a>. <i>Many 2 Many: A Group <a href=\"/wiki/Blog\" title=\"Blog\">Weblog</a> on Social Software</i>. Corante. Archived from <a rel=\"mw:ExtLink\" href=\"http://many.corante.com/archives/2005/01/04/academia_and_wikipedia.php\" class=\"external text\">the original</a> on March 16, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 18,</span> 2008</span>. <q>[The author, Danah Boyd, describes herself as] an expert on social media[,] [...] a doctoral student in the School of Information at the <a href=\"/wiki/University_of_California,_Berkeley\" title=\"University of California, Berkeley\">University of California, Berkeley</a> [,] and a fellow at the <a href=\"/wiki/Harvard_University\" title=\"Harvard University\">Harvard University</a> <a href=\"/wiki/Berkman_Center_for_Internet_&amp;_Society\" title=\"Berkman Center for Internet &amp; Society\" class=\"mw-redirect\">Berkman Center for Internet &amp; Society</a> [at <a href=\"/wiki/Harvard_Law_School\" title=\"Harvard Law School\">Harvard Law School</a>.]</q></cite></span></li><li id=\"cite_note-McHenry_2004-185\"> <span id=\"mw-reference-text-cite_note-McHenry_2004-185\" class=\"mw-reference-text\"><a href=\"/wiki/Robert_McHenry\" title=\"Robert McHenry\">Robert McHenry</a>, <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20060107210301/http://www.techcentralstation.com/111504A.html\" class=\"external text\">\"The Faith-Based Encyclopedia\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20060116022451/http://www.techcentralstation.com/111504A.html\" class=\"external text\">Archived</a> January 16, 2006, at the <a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <a href=\"/wiki/TCS_Daily\" title=\"TCS Daily\">Tech Central Station</a>, November 15, 2004.</span></li><li id=\"cite_note-186\"> <span id=\"mw-reference-text-cite_note-186\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.npr.org/2018/04/27/606393983/wikipedia-founder-says-internet-users-are-adrift-in-the-fake-news-era\" class=\"external text\">\"Wikipedia Founder Says Internet Users Are Adrift In The 'Fake News' Era\"</a>. <i>NPR.org</i>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20180625213220/https://www.npr.org/2018/04/27/606393983/wikipedia-founder-says-internet-users-are-adrift-in-the-fake-news-era\" class=\"external text\">Archived</a> from the original on June 25, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 1,</span> 2018</span>.</cite></span></li><li id=\"cite_note-dw-187\"> <span id=\"mw-reference-text-cite_note-dw-187\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.dw.de/inside-wikipedia-attack-of-the-pr-industry/av-17745881\" class=\"external text\">\"Inside Wikipedia—Attack of the PR Industry\"</a>. <a href=\"/wiki/Deutsche_Welle\" title=\"Deutsche Welle\">Deutsche Welle</a>. June 30, 2014<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 2,</span> 2014</span>.</cite></span></li><li id=\"cite_note-citizendium_WP_trolling_issues_1-188\"> <span id=\"mw-reference-text-cite_note-citizendium_WP_trolling_issues_1-188\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20061011230402/http://www.citizendium.org/essay.html\" class=\"external text\">\"Toward a New Compendium of Knowledge (longer version)\"</a>. <i>Citizendium</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.citizendium.org/essay.html\" class=\"external text\">the original</a> on October 11, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 10,</span> 2006</span>.</cite></span></li><li id=\"cite_note-ReferenceA-189\"><span></span> <span id=\"mw-reference-text-cite_note-ReferenceA-189\" class=\"mw-reference-text\"><cite class=\"citation news\">Elder, Jeff (June 16, 2014). <a rel=\"mw:ExtLink\" href=\"https://blogs.wsj.com/digits/2014/06/16/wikipedia-strengthens-rules-against-undisclosed-editing/\" class=\"external text\">\"Wikipedia Strengthens Rules Against Undisclosed Editing\"</a>. <i><a href=\"/wiki/The_Wall_Street_Journal\" title=\"The Wall Street Journal\">The Wall Street Journal</a></i>.</cite></span></li><li id=\"cite_note-DeathByWikipedia-190\"> <span id=\"mw-reference-text-cite_note-DeathByWikipedia-190\" class=\"mw-reference-text\"><cite class=\"citation news\">Ahrens, Frank (July 9, 2006). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/wp-dyn/content/article/2006/07/08/AR2006070800135.html\" class=\"external text\">\"Death by Wikipedia: The Kenneth Lay Chronicles\"</a>. <i>The Washington Post</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 1,</span> 2006</span>.</cite></span></li><li id=\"cite_note-cnet_politicians_and_WP_1-191\"> <span id=\"mw-reference-text-cite_note-cnet_politicians_and_WP_1-191\" class=\"mw-reference-text\"><cite class=\"citation web\">Kane, Margaret (January 30, 2006). <a rel=\"mw:ExtLink\" href=\"http://news.cnet.com/8301-10784_3-6032713-7.html\" class=\"external text\">\"Politicians notice Wikipedia\"</a>. <i>CNET</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 28,</span> 2007</span>.</cite></span></li><li id=\"cite_note-msnbc_MS_cash_for_WP_edits_1-192\"> <span id=\"mw-reference-text-cite_note-msnbc_MS_cash_for_WP_edits_1-192\" class=\"mw-reference-text\"><cite class=\"citation web\"><a href=\"/wiki/Brian_Bergstein\" title=\"Brian Bergstein\">Bergstein, Brian</a> (January 23, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.nbcnews.com/id/16775981\" class=\"external text\">\"Microsoft offers cash for Wikipedia edit\"</a>. NBC News<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 1,</span> 2007</span>.</cite></span></li><li id=\"cite_note-Seeing_Corporate_Fingerprints-193\"> <span id=\"mw-reference-text-cite_note-Seeing_Corporate_Fingerprints-193\" class=\"mw-reference-text\"><cite class=\"citation news\">Hafner, Katie (August 19, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2007/08/19/technology/19wikipedia.html\" class=\"external text\">\"Lifting Corporate Fingerprints From the Editing of Wikipedia\"</a>. <i>The New York Times</i>. p.<span>&nbsp;</span>1<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-wikiality-194\"><span></span> <span id=\"mw-reference-text-cite_note-wikiality-194\" class=\"mw-reference-text\"><cite class=\"citation news\">Stephen Colbert (July 30, 2006). <a rel=\"mw:ExtLink\" href=\"http://www.cc.com/video-clips/z1aahs/the-colbert-report-the-word---wikiality\" class=\"external text\">\"Wikiality\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 8,</span> 2015</span>.</cite></span></li><li id=\"cite_note-Nutshell_in-depth_resources-195\"> <span id=\"mw-reference-text-cite_note-Nutshell_in-depth_resources-195\" class=\"mw-reference-text\"><cite class=\"citation book\">Cohen, Morris; Olson, Kent (2010). <a rel=\"mw:ExtLink\" href=\"https://archive.org/details/legalre_coh_2010_00_0532/page/32\" class=\"external text\"><i>Legal Research in a Nutshell</i></a> (10th ed.). St. Paul, Minnesota: Thomson Reuters. pp.<span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"https://archive.org/details/legalre_coh_2010_00_0532/page/32\" class=\"external text\">32–34</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-314-26408-4\" title=\"Special:BookSources/978-0-314-26408-4\"><bdi>978-0-314-26408-4</bdi></a>.</cite></span></li><li id=\"cite_note-WideWorldOfWikipedia-196\"> <span id=\"mw-reference-text-cite_note-WideWorldOfWikipedia-196\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20071107052908/http://www.emorywheel.com/detail.php?n=17902\" class=\"external text\">\"Wide World of Wikipedia\"</a>. <i>The Emory Wheel</i>. April 21, 2006. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.emorywheel.com/detail.php?n=17902\" class=\"external text\">the original</a> on November 7, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 17,</span> 2007</span>.</cite></span></li><li id=\"cite_note-insidehighered_against_WP_1-197\"> <span id=\"mw-reference-text-cite_note-insidehighered_against_WP_1-197\" class=\"mw-reference-text\"><cite class=\"citation journal\">Waters, N.L. (2007). \"Why you can't cite Wikipedia in my class\". <i>Communications of the ACM</i>. <b>50</b> (9): 15. <a href=\"/wiki/Bibcode\" title=\"Bibcode\">Bibcode</a>:<a rel=\"mw:ExtLink\" href=\"https://ui.adsabs.harvard.edu/abs/1985CACM...28...22S\" class=\"external text\">1985CACM...28...22S</a>. <a href=\"/wiki/CiteSeerX\" title=\"CiteSeerX\">CiteSeerX</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.380.4996\" class=\"external text\">10.1.1.380.4996</a></span>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F1284621.1284635\" class=\"external text\">10.1145/1284621.1284635</a>.</cite></span></li><li id=\"cite_note-insidehighered_wiki_no_cite-198\"> <span id=\"mw-reference-text-cite_note-insidehighered_wiki_no_cite-198\" class=\"mw-reference-text\"><cite class=\"citation web\">Jaschik, Scott (January 26, 2007). <a rel=\"mw:ExtLink\" href=\"http://www.insidehighered.com/news/2007/01/26/wiki\" class=\"external text\">\"A Stand Against Wikipedia\"</a>. <i>Inside Higher Ed</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 27,</span> 2007</span>.</cite></span></li><li id=\"cite_note-AWorkInProgress-199\"> <span id=\"mw-reference-text-cite_note-AWorkInProgress-199\" class=\"mw-reference-text\"><cite class=\"citation news\">Helm, Burt (December 14, 2005). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120421000522/http://www.businessweek.com/technology/content/dec2005/tc20051214_441708.htm\" class=\"external text\">\"Wikipedia: 'A Work in Progress<span class=\"cs1-kern-right\">'</span>\"</a>. <i>Bloomberg BusinessWeek</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.businessweek.com/technology/content/dec2005/tc20051214_441708.htm\" class=\"external text\">the original</a> on April 21, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 29,</span> 2007</span>.</cite></span></li><li id=\"cite_note-Jimmy_Wales_don't_cite_WP_1-200\"> <span id=\"mw-reference-text-cite_note-Jimmy_Wales_don't_cite_WP_1-200\" class=\"mw-reference-text\">\"Jimmy Wales\", <i>Biography Resource Center Online</i>. (Gale, 2006.)</span></li><li id=\"cite_note-thecrimson_wiki_debate-201\"> <span id=\"mw-reference-text-cite_note-thecrimson_wiki_debate-201\" class=\"mw-reference-text\">Child, Maxwell L., <a rel=\"mw:ExtLink\" href=\"https://www.thecrimson.com/article.aspx?ref=517305\" class=\"external text\">\"Professors Split on Wiki Debate\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20081220125910/http://www.thecrimson.com/article.aspx?ref=517305\" class=\"external text\">Archived</a><span> December 20, 2008, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, <i>The Harvard Crimson</i>, February 26, 2007.</span></li><li id=\"cite_note-stothart-202\"> <span id=\"mw-reference-text-cite_note-stothart-202\" class=\"mw-reference-text\">Chloe Stothart. <a rel=\"mw:ExtLink\" href=\"http://www.timeshighereducation.co.uk/story.asp?sectioncode=26&amp;storycode=209408\" class=\"external text\">\"Web threatens learning ethos\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20121221140310/http://www.timeshighereducation.co.uk/story.asp?sectioncode=26&amp;storycode=209408\" class=\"external text\">Archived</a> December 21, 2012, at the <a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <i>The Times Higher Education Supplement</i>, 2007, 1799 (June 22), p. 2.</span></li><li id=\"cite_note-203\"> <span id=\"mw-reference-text-cite_note-203\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.quest-cdecjournal.it/focus.php?id=403\" class=\"external text\">\"Wikishtetl: Commemorating Jewish Communities that Perished in the Holocaust through the Wikipedia Platform<span>&nbsp;</span>:: Quest CDEC journal\"</a>. <i>www.quest-cdecjournal.it</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 15,</span> 2020</span>.</cite></span></li><li id=\"cite_note-204\"> <span id=\"mw-reference-text-cite_note-204\" class=\"mw-reference-text\"><cite class=\"citation journal\">Petiška, Eduard; Moldan, Bedřich (December 9, 2019). \"Indicator of quality for environmental articles on Wikipedia at the higher education level\". <i>Journal of Information Science</i>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1177%2F0165551519888607\" class=\"external text\">10.1177/0165551519888607</a>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/0165-5515\" class=\"external text\">0165-5515</a>.</cite></span></li><li id=\"cite_note-Julie_Beck_2014-205\"><span></span> <span id=\"mw-reference-text-cite_note-Julie_Beck_2014-205\" class=\"mw-reference-text\">Julie Beck. \"Doctors' #1 Source for Healthcare Information: Wikipedia\". <i>The Atlantic</i>, March 5, 2014.</span></li><li id=\"cite_note-theatlantic.com-206\"><span></span> <span id=\"mw-reference-text-cite_note-theatlantic.com-206\" class=\"mw-reference-text\"><cite class=\"citation magazine\">Green, Emma (May 7, 2014). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/health/archive/2014/05/can-wikipedia-ever-be-a-definitive-medical-text/361822/\" class=\"external text\">\"Can Wikipedia Ever Be a Definitive Medical Text?—Julie Beck\"</a>. <i>The Atlantic</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-computers2019-207\"><span></span> <span id=\"mw-reference-text-cite_note-computers2019-207\" class=\"mw-reference-text\"><cite class=\"citation journal\">Lewoniewski, Włodzimierz; Węcel, Krzysztof; Abramowicz, Witold (2019). \"Multilingual Ranking of Wikipedia Articles with Quality and Popularity Assessment in Different Topics\". <i>Computers</i>. <b>8</b> (3): 60. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//doi.org/10.3390%2Fcomputers8030060\" class=\"external text\">10.3390/computers8030060</a></span>.</cite></span></li><li id=\"cite_note-208\"> <span id=\"mw-reference-text-cite_note-208\" class=\"mw-reference-text\"><cite class=\"citation book\">Kittur, Aniket; Kraut, Robert E. (2008). \"Harnessing the wisdom of crowds in Wikipedia: quality through coordination\". <i>Proceedings of the 2008 ACM conference on Computer supported cooperative work</i>. New York: ACM. pp.<span>&nbsp;</span>37–46. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F1460563.1460572\" class=\"external text\">10.1145/1460563.1460572</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-60558-007-4\" title=\"Special:BookSources/978-1-60558-007-4\"><bdi>978-1-60558-007-4</bdi></a>.</cite><sup class=\"noprint Inline-Template\"><span style=\"white-space: nowrap;\"><span>[</span><i><a href=\"/wiki/Wikipedia:Link_rot\" title=\"Wikipedia:Link rot\"><span>permanent dead link</span></a></i><span>]</span></span></sup></span></li><li id=\"cite_note-Rosenzweig-209\"><span></span> <span id=\"mw-reference-text-cite_note-Rosenzweig-209\" class=\"mw-reference-text\"><cite class=\"citation journal\">Roy Rosenzweig (June 2006). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20100425130754/http://chnm.gmu.edu/essays-on-history-new-media/essays/?essayid=42\" class=\"external text\">\"Can History be Open Source? Wikipedia and the Future of the Past\"</a>. <i>The Journal of American History</i>. <b>93</b> (1): 117–146. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.2307%2F4486062\" class=\"external text\">10.2307/4486062</a>. <a href=\"/wiki/JSTOR\" title=\"JSTOR\">JSTOR</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.jstor.org/stable/4486062\" class=\"external text\">4486062</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://chnm.gmu.edu/essays-on-history-new-media/essays/?essayid=42\" class=\"external text\">the original</a> on April 25, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 11,</span> 2006</span>.</cite> (Center for History and New Media.)</span></li><li id=\"cite_note-theregister_Wales_WP_founder_on_quality_1-210\"> <span id=\"mw-reference-text-cite_note-theregister_Wales_WP_founder_on_quality_1-210\" class=\"mw-reference-text\"><cite class=\"citation web\">Andrew Orlowski (October 18, 2005). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2005/10/18/wikipedia_quality_problem/page2.html\" class=\"external text\">\"Wikipedia founder admits to serious quality problems\"</a>. <i>The Register</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 30,</span> 2007</span>.</cite></span></li><li id=\"cite_note-upi_accuracy_1-211\"> <span id=\"mw-reference-text-cite_note-upi_accuracy_1-211\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.sciencedaily.com/releases/2010/06/100601114641.htm\" class=\"external text\">\"Cancer information on Wikipedia is accurate, but not very readable, study finds\"</a>. <i>Science Daily</i>. June 2, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 31,</span> 2010</span>.</cite></span></li><li id=\"cite_note-economist_incomplete_info-212\"> <span id=\"mw-reference-text-cite_note-economist_incomplete_info-212\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.economist.com/node/8820422?story_id=8820422\" class=\"external text\">\"Fact or fiction? Wikipedia's variety of contributors is not only a strength\"</a>. <i>The Economist</i>. March 10, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 31,</span> 2010</span>.</cite></span></li><li id=\"cite_note-measures2019-213\"><span></span> <span id=\"mw-reference-text-cite_note-measures2019-213\" class=\"mw-reference-text\"><cite class=\"citation book\">Lewoniewski, Włodzimierz (2019). <a rel=\"mw:ExtLink\" href=\"https://www.researchgate.net/publication/330087836\" class=\"external text\"><i>Measures for Quality Assessment of Articles and Infoboxes in Multilingual Wikipedia</i></a>. <i>Lecture Notes in Business Information Processing</i>. <b>339</b>. pp.<span>&nbsp;</span>619–633. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1007%2F978-3-030-04849-5_53\" class=\"external text\">10.1007/978-3-030-04849-5_53</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-3-030-04849-5\" title=\"Special:BookSources/978-3-030-04849-5\"><bdi>978-3-030-04849-5</bdi></a>.</cite></span></li><li id=\"cite_note-WP_advantages_over_trad_media_1-214\"> <span id=\"mw-reference-text-cite_note-WP_advantages_over_trad_media_1-214\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:PAPER\" title=\"Wikipedia:PAPER\" class=\"mw-redirect\">Wikipedia:PAPER</a></span></li><li id=\"cite_note-Economist_disagreements_not_uncommon-215\"> <span id=\"mw-reference-text-cite_note-Economist_disagreements_not_uncommon-215\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.economist.com/printedition/displaystory.cfm?story_id=10789354\" class=\"external text\">\"The battle for Wikipedia's soul\"</a>. <i>The Economist</i>. March 6, 2008. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/0013-0613\" class=\"external text\">0013-0613</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 7,</span> 2008</span>.</cite></span></li><li id=\"cite_note-telegraph_WP_torn_apart_1-216\"> <span id=\"mw-reference-text-cite_note-telegraph_WP_torn_apart_1-216\" class=\"mw-reference-text\"><cite class=\"citation news\">Douglas, Ian (November 10, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.telegraph.co.uk/technology/3354752/Wikipedia-an-online-encyclopedia-torn-apart.html\" class=\"external text\">\"Wikipedia: an online encyclopedia torn apart\"</a>. <i>The Daily Telegraph</i>. London<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 23,</span> 2010</span>.</cite></span></li><li id=\"cite_note-Taylor-217\"> <span id=\"mw-reference-text-cite_note-Taylor-217\" class=\"mw-reference-text\"><cite class=\"citation news\">Sophie Taylor (April 5, 2008). <a rel=\"mw:ExtLink\" href=\"http://in.reuters.com/article/technologyNews/idINIndia-32865420080405\" class=\"external text\">\"China allows access to English Wikipedia\"</a>. Reuters<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 29,</span> 2008</span>.</cite></span></li><li id=\"cite_note-washington_post_state_censorship_1-218\"> <span id=\"mw-reference-text-cite_note-washington_post_state_censorship_1-218\" class=\"mw-reference-text\"><cite class=\"citation news\">Bruilliard, Karin (May 21, 2010). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/wp-dyn/content/article/2010/05/20/AR2010052005073.html\" class=\"external text\">\"Pakistan blocks YouTube a day after shutdown of Facebook over Muhammad issue\"</a>. <i>The Washington Post</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 24,</span> 2011</span>.</cite></span></li><li id=\"cite_note-Kittur2009-219\"><span></span> <span id=\"mw-reference-text-cite_note-Kittur2009-219\" class=\"mw-reference-text\">Kittur, A., Chi, E. H., and Suh, B. 2009. <a rel=\"mw:ExtLink\" href=\"http://www-users.cs.umn.edu/~echi/papers/2009-CHI2009/p1509.pdf\" class=\"external text\">What's in Wikipedia? Mapping Topics and Conflict Using Socially Annotated Category Structure</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160413130503/http://www-users.cs.umn.edu/~echi/papers/2009-CHI2009/p1509.pdf\" class=\"external text\">Archived</a> April 13, 2016, at the <a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> In Proceedings of the 27th International Conference on Human Factors in Computing Systems (Boston, Massachusetts, April 4–9, 2009). CHI '09. ACM, New York, 1509–1512.</span></li><li id=\"cite_note-NYT_subjects_and_articles-220\"> <span id=\"mw-reference-text-cite_note-NYT_subjects_and_articles-220\" class=\"mw-reference-text\"><cite class=\"citation news\">Petrusich, Amanda (October 20, 2011). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2011/10/21/theater/editing-wikipedia-at-the-new-york-public-library-for-the-performing-arts.html\" class=\"external text\">\"Wikipedia's Deep Dive Into a Library Collection\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 28,</span> 2011</span>.</cite></span></li><li id=\"cite_note-221\"> <span id=\"mw-reference-text-cite_note-221\" class=\"mw-reference-text\"><cite class=\"citation journal\">Lam, Shyong (Tony) K.; Anuradha Uduwage; Zhenhua Dong; Shilad Sen; David R. Musicant; Loren Terveen; John Riedl (October 3–5, 2011). <a rel=\"mw:ExtLink\" href=\"http://files.grouplens.org/papers/wp-gender-wikisym2011.pdf\" class=\"external text\">\"WP: Clubhouse? An Exploration of Wikipedia's Gender Imbalance\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>WikiSym 2011</i>: 4.</cite></span></li><li id=\"cite_note-222\"> <span id=\"mw-reference-text-cite_note-222\" class=\"mw-reference-text\">Mark Graham, <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161002051150/http://zerogeography.net/post/144973716228/mapping-the-geographies-of-wikipedia-content\" class=\"external text\">Mapping the Geographies of Wikipedia Content</a>, <i>Zerogeography.net</i> (November 12, 2009).</span></li><li id=\"cite_note-223\"> <span id=\"mw-reference-text-cite_note-223\" class=\"mw-reference-text\"><cite class=\"citation book\">Strohmaier, Markus (March 6, 2017). \"KAT50 Society, Culture\". <i>Multilingual historical narratives on Wikipedia</i>. GESIS Data Archive. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.7802%2F1411\" class=\"external text\">10.7802/1411</a>. <q>Wikipedia narratives about national histories (i) are skewed towards more recent events (recency bias) and (ii) are distributed unevenly across the continents with significant focus on the history of European countries (Eurocentric bias).</q></cite></span></li><li id=\"cite_note-GuardianAugust2014-224\"> <span id=\"mw-reference-text-cite_note-GuardianAugust2014-224\" class=\"mw-reference-text\"><i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i> 2014 (London) <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/commentisfree/2014/aug/07/guardian-view-wikipedia-evolving-truth\" class=\"external text\">The Guardian view on Wikipedia: evolving truth</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161112212758/https://www.theguardian.com/commentisfree/2014/aug/07/guardian-view-wikipedia-evolving-truth\" class=\"external text\">Archived</a><span> November 12, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a></span></li><li id=\"cite_note-Quilter-225\"><span></span> <span id=\"mw-reference-text-cite_note-Quilter-225\" class=\"mw-reference-text\"><cite class=\"citation web\">Quilter, Laura (October 24, 2012). <a rel=\"mw:ExtLink\" href=\"http://works.bepress.com/cgi/viewcontent.cgi?article=1035&amp;context=laura_quilter\" class=\"external text\">\"Systemic Bias in Wikipedia: What It Looks Like, and How to Deal with It\"</a>. University of Massachusetts—Amherst<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 26,</span> 2012</span>.</cite></span></li><li id=\"cite_note-226\"> <span id=\"mw-reference-text-cite_note-226\" class=\"mw-reference-text\">\"<a rel=\"mw:ExtLink\" href=\"https://www.technologyreview.com/s/517101/edit-wars-reveal-the-10-most-controversial-topics-on-wikipedia/\" class=\"external text\">Edit Wars Reveal the 10 Most Controversial Topics on Wikipedia</a>\", MIT Technology Review, July 17, 2013.</span></li><li id=\"cite_note-autogenerated3-227\"><span></span> <span id=\"mw-reference-text-cite_note-autogenerated3-227\" class=\"mw-reference-text\"><cite id=\"CITEREFYasseriSpoerriGrahamKertesz2013\" class=\"citation\">Yasseri, Taha; Spoerri, Anselm; Graham, Mark; Kertesz, Janos (May 23, 2013), <i>The Most Controversial Topics in Wikipedia: A Multilingual and Geographical Analysis by Taha Yasseri, Anselm Spoerri, Mark Graham, Janos Kertesz<span>&nbsp;</span>:: SSRN</i>, <a href=\"/wiki/ArXiv\" title=\"ArXiv\">arXiv</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//arxiv.org/abs/1305.5566\" class=\"external text\">1305.5566</a></span>, <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.2139%2Fssrn.2269392\" class=\"external text\">10.2139/ssrn.2269392</a>, <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//ssrn.com/abstract=2269392\" class=\"external text\">2269392</a></span></cite></span></li><li id=\"cite_note-228\"> <span id=\"mw-reference-text-cite_note-228\" class=\"mw-reference-text\">\n<cite class=\"citation conference\">Das, Sanmay; Allen, Lavoie; Malik, Magdon-Ismail (November 1, 2013). <a rel=\"mw:ExtLink\" href=\"https://dl.acm.org/citation.cfm?id=2505566\" class=\"external text\">\"Manipulation among the arbiters of collective intelligence: How Wikipedia administrators mold public opinion\"</a>. <i>CIKM '13 Proceedings of the 22nd ACM international conference on Information &amp; Knowledge Management</i>. San Francisco, California: ACM. pp.<span>&nbsp;</span>1097–1106. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F2505515.2505566\" class=\"external text\">10.1145/2505515.2505566</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-4503-2263-8\" title=\"Special:BookSources/978-1-4503-2263-8\"><bdi>978-1-4503-2263-8</bdi></a>.</cite>\n</span></li><li id=\"cite_note-229\"> <span id=\"mw-reference-text-cite_note-229\" class=\"mw-reference-text\">\n<cite class=\"citation journal\">Das, Sanmay; Allen, Lavoie; Malik, Magdon-Ismail (December 24, 2016). \"Manipulation among the arbiters of collective intelligence: How Wikipedia administrators mold public opinion\". <i>ACM Transactions on the Web</i>. <b>10</b> (4): 24. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F3001937\" class=\"external text\">10.1145/3001937</a>.</cite>\n</span></li><li id=\"cite_note-Register_ISP_censorship-230\"> <span id=\"mw-reference-text-cite_note-Register_ISP_censorship-230\" class=\"mw-reference-text\"><cite class=\"citation news\">Metz, Cade (December 7, 2008). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2008/12/07/brit_isps_censor_wikipedia\" class=\"external text\">\"Brit ISPs censor Wikipedia over 'child porn' album cover\"</a>. <i><a href=\"/wiki/The_Register\" title=\"The Register\">The Register</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 10,</span> 2009</span>.</cite></span></li><li id=\"cite_note-231\"> <span id=\"mw-reference-text-cite_note-231\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.smh.com.au/technology/technology-news/wikipedia-rejects-child-porn-accusation-20100428-tsvh\" class=\"external text\">\"Wikipedia rejects child porn accusation\"</a>. <i>The Sydney Morning Herald</i>. April 29, 2010. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20170902180523/http://www.smh.com.au/technology/technology-news/wikipedia-rejects-child-porn-accusation-20100428-tsvh\" class=\"external text\">Archived</a> from the original on September 2, 2017<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 14,</span> 2017</span>.</cite></span></li><li id=\"cite_note-Inquirer_child_abuse_allegations-232\"> <span id=\"mw-reference-text-cite_note-Inquirer_child_abuse_allegations-232\" class=\"mw-reference-text\"><cite class=\"citation news\">Farrell, Nick (April 29, 2010). <a rel=\"mw:ExtLink\" href=\"http://www.theinquirer.net/inquirer/news/1603521/wikipedia-denies-child-abuse-allegations\" class=\"external text\">\"Wikipedia denies child abuse allegations: Co-founder grassed the outfit to the FBI\"</a>. <i>The Inquirer</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 9,</span> 2010</span>.</cite></span></li><li id=\"cite_note-The_Register-April-233\"><span></span> <span id=\"mw-reference-text-cite_note-The_Register-April-233\" class=\"mw-reference-text\"><cite class=\"citation news\">Metz, Cade (April 9, 2010). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2010/04/09/sanger_reports_wikimedia_to_the_fbi/\" class=\"external text\">\"Wikifounder reports Wikiparent to FBI over 'child porn<span class=\"cs1-kern-right\">'</span>\"</a>. <i>The Register</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 19,</span> 2010</span>.</cite></span></li><li id=\"cite_note-TET_child_porn_accusations-234\"> <span id=\"mw-reference-text-cite_note-TET_child_porn_accusations-234\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://economictimes.indiatimes.com/infotech/internet/Wikipedia-blasts-co-founders-accusations-of-child-porn-on-website/articleshow/5871943.cms\" class=\"external text\">\"Wikipedia blasts co-founder's accusations of child porn on website\"</a>. <i>The Economic Times</i>. India. April 29, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 29,</span> 2010</span>.</cite></span></li><li id=\"cite_note-AFP-235\"><span></span> <span id=\"mw-reference-text-cite_note-AFP-235\" class=\"mw-reference-text\"><cite class=\"citation news\">Agence France-Presse (April 29, 2010). <a rel=\"mw:ExtLink\" href=\"https://www.smh.com.au/technology/technology-news/wikipedia-rejects-child-porn-accusation-20100428-tsvh.html\" class=\"external text\">\"Wikipedia rejects child porn accusation\"</a>. <i>The Sydney Morning Herald</i>.</cite></span></li><li id=\"cite_note-BBC_News_Wales_cedes_rights-236\"> <span id=\"mw-reference-text-cite_note-BBC_News_Wales_cedes_rights-236\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://news.bbc.co.uk/2/hi/technology/10104946.stm\" class=\"external text\">\"Wikimedia pornography row deepens as Wales cedes rights\"</a>. <i>BBC News</i>. May 10, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 19,</span> 2010</span>.</cite></span></li><li id=\"cite_note-XBIZ-237\"> <span id=\"mw-reference-text-cite_note-XBIZ-237\" class=\"mw-reference-text\"><cite class=\"citation news\">Gray, Lila (September 17, 2013). <a rel=\"mw:ExtLink\" href=\"http://newswire.xbiz.com/view.php?id=169017\" class=\"external text\">\"Wikipedia Gives Porn a Break\"</a>. <i>XBIZ.com</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 10,</span> 2013</span>.</cite></span></li><li id=\"cite_note-238\"> <span id=\"mw-reference-text-cite_note-238\" class=\"mw-reference-text\">Andrew McStay, 2014, <a rel=\"mw:ExtLink\" href=\"https://www.amazon.co.uk/Privacy-Philosophy-Affective-Protocol-Formations/dp/143311898X\" class=\"external text\">Privacy and Philosophy: New Media and Affective Protocol</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160414204326/http://www.amazon.co.uk/Privacy-Philosophy-Affective-Protocol-Formations/dp/143311898X\" class=\"external text\">Archived</a><span> April 14, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>, New York Peter Lang.</span></li><li id=\"cite_note-heise_Tron_public_issue_1-240\"> <span id=\"mw-reference-text-cite_note-heise_Tron_public_issue_1-240\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"http://www.heise.de/newsticker/meldung/Gericht-weist-einstweilige-Verfuegung-gegen-Wikimedia-Deutschland-ab-Update-173587.html\" class=\"external text\">Heise</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120913054949/http://www.heise.de/newsticker/meldung/Gericht-weist-einstweilige-Verfuegung-gegen-Wikimedia-Deutschland-ab-Update-173587.html\" class=\"external text\">Archived</a><span> September 13, 2012, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a>—<i lang=\"de\" title=\"German language text\">Gericht weist einstweilige Verfügung gegen Wikimedia Deutschland ab (update)</i>, by Torsten Kleinz, February 9, 2006.</span></li><li id=\"cite_note-241\"> <span id=\"mw-reference-text-cite_note-241\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20131030215341/http://www.otrs.com/en/\" class=\"external text\">\"IT Service Management Software\"</a>. OTRS.com. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.otrs.com/en/\" class=\"external text\">the original</a> on October 30, 2013<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 9,</span> 2012</span>.</cite></span></li><li id=\"cite_note-Paling-242\"><span></span> <span id=\"mw-reference-text-cite_note-Paling-242\" class=\"mw-reference-text\"><cite class=\"citation web\">Paling, Emma (October 21, 2015). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/technology/archive/2015/10/how-wikipedia-is-hostile-to-women/411619/\" class=\"external text\">\"Wikipedia's Hostility to Women\"</a>. <i>The Atlantic</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 24,</span> 2015</span>.</cite></span></li><li id=\"cite_note-243\"> <span id=\"mw-reference-text-cite_note-243\" class=\"mw-reference-text\"><cite class=\"citation journal\">Auerbach, David (December 11, 2014). <a rel=\"mw:ExtLink\" href=\"http://www.slate.com/articles/technology/bitwise/2014/12/wikipedia_editing_disputes_the_crowdsourced_encyclopedia_has_become_a_rancorous.html\" class=\"external text\">\"Encyclopedia Frown\"</a>. <i>Slate</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 24,</span> 2015</span>.</cite></span></li><li id=\"cite_note-CSM-misogyny-244\"> <span id=\"mw-reference-text-cite_note-CSM-misogyny-244\" class=\"mw-reference-text\"><cite class=\"citation journal\"><a rel=\"mw:ExtLink\" href=\"http://www.csmonitor.com/World/Security-Watch/Backchannels/2013/0801/In-UK-rising-chorus-of-outrage-over-online-misogyny\" class=\"external text\">\"In UK, rising chorus of outrage over online misogyny\"</a>. <i>Christian Science Monitor</i>. August 2013.</cite></span></li><li id=\"cite_note-financialstatements-245\"> <span id=\"mw-reference-text-cite_note-financialstatements-245\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://upload.wikimedia.org/wikipedia/foundation/a/ac/FINAL_10_11From_KPMG.pdf\" class=\"external text\">\"Wikimedia Foundation—Financial Statements—June 30, 2011 and 2010\"</a> <span class=\"cs1-format\">(PDF)</span>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-246\"> <span id=\"mw-reference-text-cite_note-246\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://upload.wikimedia.org/wikipedia/foundation/5/5c/Form_990_-_FY_12-13_-_Public.pdf\" class=\"external text\">\"Wikimedia Foundation IRS Form 990\"</a> <span class=\"cs1-format\">(PDF)</span><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-247\"> <span id=\"mw-reference-text-cite_note-247\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://wikimediafoundation.org/wiki/Press_releases/WMF_announces_new_ED_Lila_Tretikov\" class=\"external text\">\"Press releases/WMF announces new ED Lila Tretikov\"</a>. Wikimedia Foundation. May 31, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Jeff_Elder_2014-248\"><span></span> <span id=\"mw-reference-text-cite_note-Jeff_Elder_2014-248\" class=\"mw-reference-text\">Jeff Elder, <i>The Wall Street Journal</i>, May 1, 2014, \"Wikipedia's New Chief: From Soviet Union to World's Sixth-Largest Site\".</span></li><li id=\"cite_note-nytimes.com-249\"><span></span> <span id=\"mw-reference-text-cite_note-nytimes.com-249\" class=\"mw-reference-text\"><cite class=\"citation news\">Noam Cohen (May 1, 2014). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2014/05/02/business/media/open-source-software-specialist-selected-as-executive-director-of-wikipedia.html?_r=0\" class=\"external text\">\"Media: Open-Source Software Specialist Selected as Executive Director of Wikipedia\"</a>. <i>The New York Times</i>.</cite></span></li><li id=\"cite_note-250\"> <span id=\"mw-reference-text-cite_note-250\" class=\"mw-reference-text\">Dimitra Kessenides. Bloomberg News Weekly. December 26, 2016. \"Is Wikipedia 'Woke'\".</span></li><li id=\"cite_note-251\"> <span id=\"mw-reference-text-cite_note-251\" class=\"mw-reference-text\">Dimitra Kessenides. Bloomberg News Weekly. December 26, 2016, p. 74. \"Is Wikipedia 'Woke'\".</span></li><li id=\"cite_note-nedworks_database_system-252\"> <span id=\"mw-reference-text-cite_note-nedworks_database_system-252\" class=\"mw-reference-text\"><cite class=\"citation web\">Mark Bergsma. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20090303204708/http://www.nedworks.org/~mark/presentations/san/Wikimedia%20architecture.pdf\" class=\"external text\">\"Wikimedia Architecture\"</a> <span class=\"cs1-format\">(PDF)</span>. Wikimedia Foundation. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.nedworks.org/~mark/presentations/san/Wikimedia%20architecture.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on March 3, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 27,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_extensions_installed-253\"> <span id=\"mw-reference-text-cite_note-WP_extensions_installed-253\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Special:Version\" class=\"external text\">\"Version: Installed extensions\"</a>. September 28, 2018.</cite>. Retrieved August 18, 2014.</span></li><li id=\"cite_note-254\"> <span id=\"mw-reference-text-cite_note-254\" class=\"mw-reference-text\"><cite class=\"citation web\">Michael Snow (December 29, 2016). <a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2005-04-18/Lucene_search\" class=\"external text\">\"Lucene search: Internal search function returns to service\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 26,</span> 2009</span>.</cite></span></li><li id=\"cite_note-255\"> <span id=\"mw-reference-text-cite_note-255\" class=\"mw-reference-text\"><cite class=\"citation web\">Brion Vibber. <a rel=\"mw:ExtLink\" href=\"https://lists.wikimedia.org/pipermail/wikitech-l/2005-April/016297.html\" class=\"external text\">\"<span>[</span>Wikitech-l<span>]</span> Lucene search\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 26,</span> 2009</span>.</cite></span></li><li id=\"cite_note-256\"> <span id=\"mw-reference-text-cite_note-256\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.mediawiki.org/wiki/Extension:Lucene-search\" class=\"external text\">\"Extension:Lucene-search\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 31,</span> 2009</span>.</cite></span></li><li id=\"cite_note-257\"> <span id=\"mw-reference-text-cite_note-257\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://phabricator.wikimedia.org/diffusion/SVN/browse/branches/lucene-search-2.1/lib/\" class=\"external text\">\"mediawiki—Revision 55688: /branches/lucene-search-2.1/lib\"</a>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 31,</span> 2009</span>.</cite></span></li><li id=\"cite_note-thenextwebve-258\"> <span id=\"mw-reference-text-cite_note-thenextwebve-258\" class=\"mw-reference-text\"><cite class=\"citation web\">Emil Protalinski (July 2, 2013). <a rel=\"mw:ExtLink\" href=\"https://thenextweb.com/insider/2013/07/02/wikimedia-rolls-out-its-wysiwyg-visual-editor-for-logged-in-users-accessing-wikipedia-articles-in-english/\" class=\"external text\">\"Wikimedia rolls out WYSIWYG visual editor for logged-in users accessing Wikipedia articles in English\"</a>. <i>The Next Web</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 6,</span> 2013</span>.</cite></span></li><li id=\"cite_note-259\"> <span id=\"mw-reference-text-cite_note-259\" class=\"mw-reference-text\"><cite class=\"citation news\">Curtis, Sophie (July 23, 2013). <a rel=\"mw:ExtLink\" href=\"https://www.telegraph.co.uk/technology/wikipedia/10196578/Wikipedia-introduces-new-features-to-entice-editors.html\" class=\"external text\">\"Wikipedia introduces new features to entice editors\"</a>. <i>The Daily Telegraph</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 18,</span> 2013</span>.</cite></span></li><li id=\"cite_note-TheEconomistVE-260\"> <span id=\"mw-reference-text-cite_note-TheEconomistVE-260\" class=\"mw-reference-text\"><cite class=\"citation news\">L. M. (December 13, 2011). <a rel=\"mw:ExtLink\" href=\"https://www.economist.com/blogs/babbage/2011/12/changes-wikipedia\" class=\"external text\">\"Changes at Wikipedia: Seeing things\"</a>. <i><a href=\"/wiki/The_Economist\" title=\"The Economist\">The Economist</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 28,</span> 2013</span>.</cite></span></li><li id=\"cite_note-softpedia-best-261\"> <span id=\"mw-reference-text-cite_note-softpedia-best-261\" class=\"mw-reference-text\"><cite class=\"citation web\">Lucian Parfeni (July 2, 2013). <a rel=\"mw:ExtLink\" href=\"http://news.softpedia.com/news/Wikipedia-s-New-VisualEditor-Is-the-Best-Update-in-Years-and-You-Can-Make-It-Better-365072.shtml\" class=\"external text\">\"Wikipedia's New VisualEditor Is the Best Update in Years and You Can Make It Better\"</a>. <i><a href=\"/wiki/Softpedia\" title=\"Softpedia\">Softpedia</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 30,</span> 2013</span>.</cite></span></li><li id=\"cite_note-Orlowski,_Andrew-262\"><span></span> <span id=\"mw-reference-text-cite_note-Orlowski,_Andrew-262\" class=\"mw-reference-text\"><cite class=\"citation web\">Orlowski, Andrew (August 1, 2013). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2013/08/01/wikipedians_reject_wysiwyg_editor/\" class=\"external text\">\"Wikipedians say no to Jimmy's 'buggy' WYSIWYG editor\"</a>. <i>The Register</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 18,</span> 2013</span>.</cite></span></li><li id=\"cite_note-263\"> <span id=\"mw-reference-text-cite_note-263\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Bots\" title=\"Wikipedia:Bots\">Wikipedia Bot Information</a></span></li><li id=\"cite_note-meetbots-264\"><span></span> <span id=\"mw-reference-text-cite_note-meetbots-264\" class=\"mw-reference-text\"><cite class=\"citation news\">Daniel Nasaw (July 24, 2012). <a rel=\"mw:ExtLink\" href=\"https://www.bbc.co.uk/news/magazine-18892510\" class=\"external text\">\"Meet the 'bots' that edit Wikipedia\"</a>. <i>BBC News</i>.</cite></span></li><li id=\"cite_note-265\"> <span id=\"mw-reference-text-cite_note-265\" class=\"mw-reference-text\"><cite class=\"citation news\">Halliday, Josh; Arthur, Charles (July 26, 2012). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/blog/2012/jul/26/boot-up-wikipedia-apple\" class=\"external text\">\"Boot up: The Wikipedia vandalism police, Apple analysts, and more\"</a>. <i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 5,</span> 2012</span>.</cite></span></li><li id=\"cite_note-266\"> <span id=\"mw-reference-text-cite_note-266\" class=\"mw-reference-text\"><cite class=\"citation news\">Jervell, Ellen Emmerentze (July 13, 2014). <a rel=\"mw:ExtLink\" href=\"https://online.wsj.com/articles/for-this-author-10-000-wikipedia-articles-is-a-good-days-work-1405305001\" class=\"external text\">\"For This Author, 10,000 Wikipedia Articles Is a Good Day's Work\"</a>. <i>The Wall Street Journal</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 18,</span> 2014</span>.</cite></span></li><li id=\"cite_note-267\"> <span id=\"mw-reference-text-cite_note-267\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_Signpost/2009-03-23/Abuse_Filter\" class=\"external text\">\"Wikipedia signpost: Abuse Filter is enabled\"</a>. English Wikipedia. March 23, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 13,</span> 2010</span>.</cite></span></li><li id=\"cite_note-268\"> <span id=\"mw-reference-text-cite_note-268\" class=\"mw-reference-text\">Aljazeera, July 21, 2014, \"MH17 Wikipedia entry edited from Russian Government IP Address\". <cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://stream.aljazeera.com/story/201407211855-0023944\" class=\"external text\">\"MH17 Wikipedia entry edited from Russian government IP address\"</a>. July 21, 2014. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20161116002928/http://stream.aljazeera.com/story/201407211855-0023944\" class=\"external text\">Archived</a> from the original on November 16, 2016<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 22,</span> 2014</span>.</cite></span></li><li id=\"cite_note-269\"> <span id=\"mw-reference-text-cite_note-269\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Bot_policy\" title=\"Wikipedia:Bot policy\">Wikipedia's policy on bots</a></span></li><li id=\"cite_note-270\"> <span id=\"mw-reference-text-cite_note-270\" class=\"mw-reference-text\">Andrew Lih (2009). <i><a href=\"/wiki/The_Wikipedia_Revolution\" title=\"The Wikipedia Revolution\">The Wikipedia Revolution</a></i>, chapter <i>Then came the Bots</i>, pp. 99–106.</span></li><li id=\"cite_note-WP_tools_requests_per_day-271\"> <span id=\"mw-reference-text-cite_note-WP_tools_requests_per_day-271\" class=\"mw-reference-text\"><a href=\"//toolserver.org/~leon/stats/reqstats/reqstats-monthly.png\" title=\"tools:~leon/stats/reqstats/reqstats-monthly.png\">\"Monthly request statistics\"</a>, Wikimedia. Retrieved October 31, 2008. <sup class=\"noprint Inline-Template\"><span style=\"white-space: nowrap;\"><span>[</span><i><a href=\"/wiki/Wikipedia:Link_rot\" title=\"Wikipedia:Link rot\"><span>dead link</span></a></i><span>]</span></span></sup></span></li><li id=\"cite_note-272\"> <span id=\"mw-reference-text-cite_note-272\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://wikitech.wikimedia.org/wiki/Varnish\" class=\"external text\">\"Varnish—Wikitech\"</a>. <i>wikitech.wikimedia.org</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 12,</span> 2019</span>.</cite></span></li><li id=\"cite_note-globule_access_trace-273\"> <span id=\"mw-reference-text-cite_note-globule_access_trace-273\" class=\"mw-reference-text\"><cite class=\"citation web\">Guido Urdaneta, Guillaume Pierre and Maarten van Steen. <a rel=\"mw:ExtLink\" href=\"http://www.globule.org/publi/WWADH_comnet2009.html\" class=\"external text\">\"Wikipedia Workload Analysis for Decentralized Hosting\"</a>. Elsevier Computer Networks 53 (11), pp. 1830–1845, June 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-CW_WP_simplifies_infrastructure-274\"> <span id=\"mw-reference-text-cite_note-CW_WP_simplifies_infrastructure-274\" class=\"mw-reference-text\"><cite class=\"citation news\">Weiss, Todd R. (October 9, 2008). <a rel=\"mw:ExtLink\" href=\"http://www.computerworld.com/s/article/9116787/Wikipedia_simplifies_IT_infrastructure_by_moving_to_one_Linux_vendor?taxonomyId=154&amp;pageNumber=1&amp;taxonomyName=Servers%20and%20Data%20Center\" class=\"external text\">\"Wikipedia simplifies IT infrastructure by moving to one Linux vendor\"</a>. <i><a href=\"/wiki/Computerworld\" title=\"Computerworld\">Computerworld</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 1,</span> 2008</span>.</cite></span></li><li id=\"cite_note-ars_tech_Ubuntu_server_infra-275\"> <span id=\"mw-reference-text-cite_note-ars_tech_Ubuntu_server_infra-275\" class=\"mw-reference-text\"><cite class=\"citation web\">Paul, Ryan (October 9, 2008). <a rel=\"mw:ExtLink\" href=\"https://arstechnica.com/open-source/news/2008/10/wikipedia-adopts-ubuntu-for-its-server-infrastructure.ars\" class=\"external text\">\"Wikipedia adopts Ubuntu for its server infrastructure\"</a>. <i>Ars Technica</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 1,</span> 2008</span>.</cite></span></li><li id=\"cite_note-servers-276\"> <span id=\"mw-reference-text-cite_note-servers-276\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20130116155841/http://wikitech.wikimedia.org/view/Server_roles\" class=\"external text\">\"Server roles at wikitech.wikimedia.org\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://wikitech.wikimedia.org/view/Server_roles\" class=\"external text\">the original</a> on January 16, 2013<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 8,</span> 2009</span>.</cite></span></li><li id=\"cite_note-277\"> <span id=\"mw-reference-text-cite_note-277\" class=\"mw-reference-text\"><cite class=\"citation web\">Palmier, Guillaume. <a rel=\"mw:ExtLink\" href=\"https://blog.wikimedia.org/2013/01/19/wikimedia-sites-move-to-primary-data-center-in-ashburn-virginia/\" class=\"external text\">\"Wikimedia sites to move to primary data center in Ashburn, Virginia\"</a>. WMF<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-278\"> <span id=\"mw-reference-text-cite_note-278\" class=\"mw-reference-text\"><cite class=\"citation web\">Verge, Jason (January 14, 2013). <a rel=\"mw:ExtLink\" href=\"http://www.datacenterknowledge.com/archives/2013/01/14/its-official-equinix-ashburn-is-wikimedias-home/\" class=\"external text\">\"It's Official: Ashburn is Wikipedia's New Home\"</a>. Data Center Knowledge<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-279\"> <span id=\"mw-reference-text-cite_note-279\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://phabricator.wikimedia.org/T156028\" class=\"external text\">\"⚓ T156028 Name Asia Cache DC site\"</a>. <i>Wikimedia Phabricator</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 12,</span> 2019</span>.</cite></span></li><li id=\"cite_note-autogenerated5-280\"> <span id=\"mw-reference-text-cite_note-autogenerated5-280\" class=\"mw-reference-text\">Frederic M. Scherer and David Ross, [1970] 1990. <i>Industrial Market Structure and Economic Performance</i>, 3rd ed. Houghton-Mifflin. <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"https://ssrn.com/abstract=1496716\" class=\"external text\">1496716</a> and 1st ed. review <a rel=\"mw:ExtLink\" href=\"https://www.jstor.org/stable/3003013\" class=\"external text\">extract</a>.<br><span>&nbsp;</span><span>&nbsp;</span> • <a href=\"/wiki/Google_Scholar\" title=\"Google Scholar\">Google Scholar</a> search of <a rel=\"mw:ExtLink\" href=\"https://archive.today/20120721074339/http://scholar.google.com/scholar?q=Frederic+M.+Scherer&amp;hl=en&amp;btnG=Search&amp;as_sdt=1,47&amp;as_sdtp=on\" class=\"external text\">Frederic M. Scherer</a></span></li><li id=\"cite_note-Patents,_Citations_pp_89-153-281\"><span></span> <span id=\"mw-reference-text-cite_note-Patents,_Citations_pp_89-153-281\" class=\"mw-reference-text\"><i>Patents, Citations, and Innovations</i>, by Adam B. Jaffe, Manuel Trajtenberg, pp. 89–153.</span></li><li id=\"cite_note-282\"> <span id=\"mw-reference-text-cite_note-282\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (March 5, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2007/03/05/technology/05wikipedia.html?pagewanted=2&amp;_r=1\" class=\"external text\">\"A Contributor to Wikipedia Has His Fictional Side\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 18,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_copyright_and_commerciality_1-283\"> <span id=\"mw-reference-text-cite_note-WP_copyright_and_commerciality_1-283\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Copyrights\" title=\"Wikipedia:Copyrights\">Wikipedia:Copyrights</a></span></li><li id=\"cite_note-WPF_switch_to_CC-284\"> <span id=\"mw-reference-text-cite_note-WPF_switch_to_CC-284\" class=\"mw-reference-text\"><cite class=\"citation web\">Walter Vermeir (2007). <a rel=\"mw:ExtLink\" href=\"https://wikimediafoundation.org/wiki/Resolution:License_update\" class=\"external text\">\"Resolution:License update\"</a>. Wikizine<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 4,</span> 2007</span>.</cite></span></li><li id=\"cite_note-voteresult-285\"> <span id=\"mw-reference-text-cite_note-voteresult-285\" class=\"mw-reference-text\"><a href=\"https://meta.wikimedia.org/wiki/Licensing%20update/Result\" title=\"meta:Licensing update/Result\">Wikimedia</a></span></li><li id=\"cite_note-MW_licensing_QA-286\"> <span id=\"mw-reference-text-cite_note-MW_licensing_QA-286\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Licensing_update/Questions_and_Answers\" class=\"external text\">\"Licensing update/Questions and Answers\"</a>. <i>Wikimedia Meta</i>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 15,</span> 2009</span>.</cite></span></li><li id=\"cite_note-MW_licensing_timeline_1-287\"> <span id=\"mw-reference-text-cite_note-MW_licensing_timeline_1-287\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Licensing_update/Timeline\" class=\"external text\">\"Licensing_update/Timeline\"</a>. <i>Wikimedia Meta</i>. Wikimedia Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 5,</span> 2009</span>.</cite></span></li><li id=\"cite_note-WP_blog_license_migration-288\"> <span id=\"mw-reference-text-cite_note-WP_blog_license_migration-288\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://blog.wikimedia.org/2009/05/21/wikimedia-community-approves-license-migration\" class=\"external text\">\"Wikimedia community approves license migration\"</a>. <i>Wikimedia Foundation</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 21,</span> 2009</span>.</cite></span></li><li id=\"cite_note-NYT_photos_on_WP-289\"> <span id=\"mw-reference-text-cite_note-NYT_photos_on_WP-289\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (July 19, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2009/07/20/arts/20funny.html\" class=\"external text\">\"Wikipedia May Be a Font of Facts, but It's a Desert for Photos\"</a>. <i>New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 9,</span> 2013</span>.</cite></span></li><li id=\"cite_note-reuters_French_defamation_case-290\"> <span id=\"mw-reference-text-cite_note-reuters_French_defamation_case-290\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.reuters.com/article/internetNews/idUSL0280486220071102?feedType=RSS&amp;feedName=internetNews\" class=\"external text\">\"Wikipedia cleared in French defamation case\"</a>. Reuters. November 2, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">November 2,</span> 2007</span>.</cite></span></li><li id=\"cite_note-ars_tech_WP_dumb_suing_case-291\"> <span id=\"mw-reference-text-cite_note-ars_tech_WP_dumb_suing_case-291\" class=\"mw-reference-text\"><cite class=\"citation web\">Anderson, Nate (May 2, 2008). <a rel=\"mw:ExtLink\" href=\"https://arstechnica.com/news.ars/post/20080502-dumb-idea-suing-wikipedia-for-calling-you-dumb.html\" class=\"external text\">\"Dumb idea: suing Wikipedia for calling you \"dumb<span class=\"cs1-kern-right\">\"</span>\"</a>. <i>Ars Technica</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 4,</span> 2008</span>.</cite></span></li><li id=\"cite_note-bing_WP_research_and_referencing-292\"> <span id=\"mw-reference-text-cite_note-bing_WP_research_and_referencing-292\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.bing.com/community/site_blogs/b/search/archive/2009/07/27/researching-with-bing-reference.aspxResearching\" class=\"external text\">\"With Bing Reference\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite><sup class=\"noprint Inline-Template\"><span style=\"white-space: nowrap;\"><span>[</span><i><a href=\"/wiki/Wikipedia:Link_rot\" title=\"Wikipedia:Link rot\"><span>dead link</span></a></i><span>]</span></span></sup></span></li><li id=\"cite_note-wikipediaondvd_authorized_1-293\"> <span id=\"mw-reference-text-cite_note-wikipediaondvd_authorized_1-293\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"http://www.wikipediaondvd.com/\" class=\"external text\">\"Wikipedia on DVD\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20130603205800/http://www.wikipediaondvd.com/\" class=\"external text\">Archived</a><span> June 3, 2013, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> Linterweb. Retrieved June 1, 2007. \"Linterweb is authorized to make a commercial use of the Wikipedia trademark restricted to the selling of the Encyclopedia CDs and DVDs\".</span></li><li id=\"cite_note-wikipediaondvd_commercially_available_1-294\"> <span id=\"mw-reference-text-cite_note-wikipediaondvd_commercially_available_1-294\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"http://www.wikipediaondvd.com/site.php?temp=buy\" class=\"external text\">\"Wikipedia 0.5 Available on a CD-ROM\"</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20130503073535/http://www.wikipediaondvd.com/site.php?temp=buy\" class=\"external text\">Archived</a><span> May 3, 2013, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> <i>Wikipedia on DVD</i>. Linterweb. \"The DVD or CD-ROM version 0.5 was commercially available for purchase.\" Retrieved June 1, 2007.</span></li><li id=\"cite_note-WM_polish_WP_on_dvd-295\"> <span id=\"mw-reference-text-cite_note-WM_polish_WP_on_dvd-295\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Polska_Wikipedia_na_DVD_%28z_Helionem%29/en\" class=\"external text\">\"Polish Wikipedia on DVD\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP_german_on_dvd_1-296\"> <span id=\"mw-reference-text-cite_note-WP_german_on_dvd_1-296\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://de.wikipedia.org/wiki/Wikipedia:DVD\" class=\"external text\">\"Wikipedia:DVD\"</a>. July 31, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-python.org_CDPedia_Argentina_1-297\"> <span id=\"mw-reference-text-cite_note-python.org_CDPedia_Argentina_1-297\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://python.org.ar/pyar/Proyectos/CDPedia\" class=\"external text\">\"CDPedia (Python Argentina)\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 7,</span> 2011</span>.</cite></span></li><li id=\"cite_note-WP_CD_selection_1-298\"> <span id=\"mw-reference-text-cite_note-WP_CD_selection_1-298\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Wikipedia_CD_Selection\" title=\"Wikipedia:Wikipedia CD Selection\">Wikipedia CD Selection</a>. Retrieved September 8, 2009.</span></li><li id=\"cite_note-WP_into_books_1-299\"> <span id=\"mw-reference-text-cite_note-WP_into_books_1-299\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.webcitation.org/5jeCgQjpj?url=http://www.telegraph.co.uk/news/newstopics/howaboutthat/5549589/Wikipedia-turned-into-book.html\" class=\"external text\">\"Wikipedia turned into book\"</a>. <i>The Daily Telegraph</i>. London: Telegraph Media Group. June 16, 2009. Archived from <a rel=\"mw:ExtLink\" href=\"https://www.telegraph.co.uk/news/newstopics/howaboutthat/5549589/Wikipedia-turned-into-book.html\" class=\"external text\">the original</a> on September 9, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 8,</span> 2009</span>.</cite></span></li><li id=\"cite_note-WP_schools_selection_1-300\"> <span id=\"mw-reference-text-cite_note-WP_schools_selection_1-300\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120804093730/http://schools-wikipedia.org/\" class=\"external text\">\"Wikipedia Selection for Schools\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://schools-wikipedia.org\" class=\"external text\">the original</a> on August 4, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 14,</span> 2012</span>.</cite></span></li><li id=\"cite_note-FAZ-301\"> <span id=\"mw-reference-text-cite_note-FAZ-301\" class=\"mw-reference-text\"><cite class=\"citation web\">Thiel, Thomas (September 27, 2010). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20101126184904/http://www.faz.net/s/RubCF3AEB154CE64960822FA5429A182360/Doc~E7A20980B9C0D46E99A9F60BC09506343~ATpl~Ecommon~Scontent.html\" class=\"external text\">\"Wikipedia und Amazon: Der Marketplace soll es richten\"</a>. <i>Frankfurter Allgemeine Zeitung</i> (in German). <a href=\"/wiki/Frankfurter_Allgemeine_Zeitung\" title=\"Frankfurter Allgemeine Zeitung\">Frankfurter Allgemeine Zeitung</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.faz.net/s/RubCF3AEB154CE64960822FA5429A182360/Doc~E7A20980B9C0D46E99A9F60BC09506343~ATpl~Ecommon~Scontent.html\" class=\"external text\">the original</a> on November 26, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 6,</span> 2010</span>.</cite></span></li><li id=\"cite_note-WP_DB_usage_policy_1-302\"> <span id=\"mw-reference-text-cite_note-WP_DB_usage_policy_1-302\" class=\"mw-reference-text\"><a href=\"/wiki/Wikipedia:Database_download\" title=\"Wikipedia:Database download\">Wikipedia policies</a> on data download</span></li><li id=\"cite_note-WP_image_data_dumps_1-303\"> <span id=\"mw-reference-text-cite_note-WP_image_data_dumps_1-303\" class=\"mw-reference-text\"><a href=\"https://meta.wikimedia.org/wiki/Data%20dumps#Downloading_Images\" title=\"meta:Data dumps\">Data dumps: Downloading Images</a>, <a href=\"/wiki/Wikimedia_Meta-Wiki\" title=\"Wikimedia Meta-Wiki\" class=\"mw-redirect\">Wikimedia Meta-Wiki</a></span></li><li id=\"cite_note-slis_WP_reference_desk_1-304\"> <span id=\"mw-reference-text-cite_note-slis_WP_reference_desk_1-304\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.slis.indiana.edu/news/story.php?story_id=2064\" class=\"external text\">\"Wikipedia Reference Desk\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-305\"> <span id=\"mw-reference-text-cite_note-305\" class=\"mw-reference-text\">Brad Stone, \"How Google's Android chief, Sundar Pichai, became the most powerful man in mobile\", June 30<span>&nbsp;</span><span>–</span><span> </span>July 6, 2014, <i>Bloomberg BusinessWeek</i>, pp. 47–51.</span></li><li id=\"cite_note-306\"> <span id=\"mw-reference-text-cite_note-306\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://play.google.com/store/apps/details?id=org.wikipedia&amp;hl=en\" class=\"external text\">\"Wikipedia—Android Apps on Google Play\"</a>. <i>Play.Google.com</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 21,</span> 2014</span>.</cite></span></li><li id=\"cite_note-307\"> <span id=\"mw-reference-text-cite_note-307\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://itunes.apple.com/us/app/wikipedia-mobile/id324715238?mt=8\" class=\"external text\">\"Wikipedia Mobile on the App Store on iTunes\"</a>. <i>iTunes.Apple.com</i>. August 4, 2014<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 21,</span> 2014</span>.</cite></span></li><li id=\"cite_note-WM_mobile_added_1-308\"> <span id=\"mw-reference-text-cite_note-WM_mobile_added_1-308\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://techblog.wikimedia.org/2009/06/wikimedia-mobile-launch\" class=\"external text\">\"Wikimedia Mobile is Officially Launched\"</a>. <i>Wikimedia Technical Blog</i>. June 30, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 22,</span> 2009</span>.</cite></span></li><li id=\"cite_note-androgeoid.com_LPOI_WP_1-309\"> <span id=\"mw-reference-text-cite_note-androgeoid.com_LPOI_WP_1-309\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://androgeoid.com/2011/04/local-points-of-interest-in-wikipedia\" class=\"external text\">\"Local Points Of Interest In Wikipedia\"</a>. May 15, 2011<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 15,</span> 2011</span>.</cite></span></li><li id=\"cite_note-ilounge_iphone_gems_WP-310\"> <span id=\"mw-reference-text-cite_note-ilounge_iphone_gems_WP-310\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.ilounge.com/index.php/articles/comments/15802\" class=\"external text\">\"iPhone Gems: Wikipedia Apps\"</a>. November 30, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 22,</span> 2008</span>.</cite></span></li><li id=\"cite_note-311\"> <span id=\"mw-reference-text-cite_note-311\" class=\"mw-reference-text\"><cite class=\"citation web\">Ellis, Justin (January 17, 2013). <a rel=\"mw:ExtLink\" href=\"http://www.niemanlab.org/2013/01/wikipedia-plans-to-expand-mobile-access-around-the-globe-with-new-funding\" class=\"external text\">\"Wikipedia plans to expand mobile access around the globe with new funding\"</a>. <i>NiemanLab</i>. Nieman Journalism Lab<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 22,</span> 2013</span>.</cite></span></li><li id=\"cite_note-312\"> <span id=\"mw-reference-text-cite_note-312\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://blog.wikimedia.org/2018/02/16/partnerships-new-approach/\" class=\"external text\">\"Building for the future of Wikimedia with a new approach to partnerships—Wikimedia Blog\"</a>. <i><a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">May 12,</span> 2019</span>.</cite></span></li><li id=\"cite_note-313\"> <span id=\"mw-reference-text-cite_note-313\" class=\"mw-reference-text\"><cite class=\"citation news\">Andrew Lih (June 20, 2015). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2015/06/21/opinion/can-wikipedia-survive.html\" class=\"external text\">\"Can Wikipedia Survive?\"</a>.</cite></span></li><li id=\"cite_note-314\"> <span id=\"mw-reference-text-cite_note-314\" class=\"mw-reference-text\"><cite class=\"citation news\">Andrew Brown (June 25, 2015). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/commentisfree/2015/jun/25/wikipedia-editors-dying-breed-mobile-smartphone-technology-online-encyclopedia\" class=\"external text\">\"Wikipedia editors are a dying breed. The reason? Mobile\"</a>. <i>The Guardian</i>.</cite></span></li><li id=\"cite_note-modelling-315\"> <span id=\"mw-reference-text-cite_note-modelling-315\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Modelling_Wikipedia%27s_growth\" class=\"external text\">\"Wikipedia:Modelling Wikipedia's growth\"</a>. July 31, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 22,</span> 2007</span>.</cite></span></li><li id=\"cite_note-comscore-316\"> <span id=\"mw-reference-text-cite_note-comscore-316\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080730011713/http://www.comscore.com/press/release.asp?press=849\" class=\"external text\">\"694 Million People Currently Use the Internet Worldwide According To comScore Networks\"</a>. comScore. May 4, 2006. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.comscore.com/press/release.asp?press=849\" class=\"external text\">the original</a> on July 30, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 16,</span> 2007</span>. <q>Wikipedia has emerged as a site that continues to increase in popularity, both globally and in the US</q></cite></span></li><li id=\"cite_note-hitwisegoogle-317\"> <span id=\"mw-reference-text-cite_note-hitwisegoogle-317\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20071214072031/http://weblogs.hitwise.com/leeann-prescott/2007/02/wikipedia_traffic_sources.html\" class=\"external text\">\"Google Traffic To Wikipedia up 166% Year over Year\"</a>. Hitwise. February 16, 2007. Archived from <a rel=\"mw:ExtLink\" href=\"http://weblogs.hitwise.com/leeann-prescott/2007/02/wikipedia_traffic_sources.html\" class=\"external text\">the original</a> on December 14, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 22,</span> 2007</span>.</cite></span></li><li id=\"cite_note-hitwiseAcademic-318\"> <span id=\"mw-reference-text-cite_note-hitwiseAcademic-318\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20061029213453/http://weblogs.hitwise.com/leeann-prescott/2006/10/wikipedia_and_academic_researc.html\" class=\"external text\">\"Wikipedia and Academic Research\"</a>. Hitwise. October 17, 2006. Archived from <a rel=\"mw:ExtLink\" href=\"http://weblogs.hitwise.com/leeann-prescott/2006/10/wikipedia_and_academic_researc.html\" class=\"external text\">the original</a> on October 29, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 6,</span> 2008</span>.</cite></span></li><li id=\"cite_note-365M-319\"> <span id=\"mw-reference-text-cite_note-365M-319\" class=\"mw-reference-text\"><cite class=\"citation web\">West, Stuart. <a rel=\"mw:ExtLink\" href=\"http://upload.wikimedia.org/wikipedia/meta/3/3a/TED2010%2C_Stuart_West_full_presentation_updated_with_January_data.pdf\" class=\"external text\">\"Wikipedia's Evolving Impact: slideshow presentation at TED2010\"</a> <span class=\"cs1-format\">(PDF)</span><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 23,</span> 2015</span>.</cite></span></li><li id=\"cite_note-Wikipedia_users-320\"> <span id=\"mw-reference-text-cite_note-Wikipedia_users-320\" class=\"mw-reference-text\"><cite class=\"citation web\">Rainie, Lee; Bill Tancer (December 15, 2007). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080306031354/http://www.pewinternet.org/pdfs/PIP_Wikipedia07.pdf\" class=\"external text\">\"Wikipedia users\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>Pew Internet &amp; American Life Project</i>. Pew Research Center. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.pewinternet.org/pdfs/PIP_Wikipedia07.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on March 6, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 15,</span> 2007</span>. <q>36% of online American adults consult Wikipedia. It is particularly popular with the well-educated and current college-age students.</q></cite></span></li><li id=\"cite_note-321\"> <span id=\"mw-reference-text-cite_note-321\" class=\"mw-reference-text\"><cite class=\"citation web\">SAI (October 7, 2011). <a rel=\"mw:ExtLink\" href=\"http://www.businessinsider.com/2011-digital-100#7-wikimedia-foundation-wikipedia-7\" class=\"external text\">\"The World's Most Valuable Startups\"</a>. <i>Business Insider</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-322\"> <span id=\"mw-reference-text-cite_note-322\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/wiki/Research:Wikipedia_Readership_Survey_2011/Results\" class=\"external text\">\"Research:Wikipedia Readership Survey 2011/Results—Meta\"</a>. Wikimedia. February 6, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 16,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Wikipedia_in_media-323\"> <span id=\"mw-reference-text-cite_note-Wikipedia_in_media-323\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://en.wikipedia.org/wiki/Wikipedia:Wikipedia_in_the_media\" class=\"external text\">\"Wikipedia:Wikipedia in the media\"</a>. <i>Wikipedia</i>. July 4, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-Bourgeois-324\"> <span id=\"mw-reference-text-cite_note-Bourgeois-324\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20070203021430/http://www.ca11.uscourts.gov/opinions/ops/200216886.pdf\" class=\"external text\">\"Bourgeois et al. v. Peters et al\"</a> <span class=\"cs1-format\">(PDF)</span>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.ca11.uscourts.gov/opinions/ops/200216886.pdf\" class=\"external text\">the original</a> <span class=\"cs1-format\">(PDF)</span> on February 3, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 6,</span> 2007</span>.</cite></span></li><li id=\"cite_note-ssrn.com_Wikipedian_Justice_1-325\"> <span id=\"mw-reference-text-cite_note-ssrn.com_Wikipedian_Justice_1-325\" class=\"mw-reference-text\"><cite id=\"CITEREFSharma2009\" class=\"citation\">Sharma, Raghav (February 19, 2009), <i>Wikipedian Justice</i>, <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//ssrn.com/abstract=1346311\" class=\"external text\">1346311</a></span></cite></span></li><li id=\"cite_note-parl.gc.ca_same-sex_marriage-326\"> <span id=\"mw-reference-text-cite_note-parl.gc.ca_same-sex_marriage-326\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.parl.gc.ca/LegisInfo/BillDetails.aspx?billId=1585203&amp;View=10\" class=\"external text\">\"LEGISinfo—House Government Bill C-38 (38–1)\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-WP_court_source-327\"> <span id=\"mw-reference-text-cite_note-WP_court_source-327\" class=\"mw-reference-text\"><cite class=\"citation journal\">Arias, Martha L. (January 29, 2007). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120520054827/http://www.ibls.com/internet_law_news_portal_view.aspx?s=latestnews&amp;id=1668\" class=\"external text\">\"Wikipedia: The Free Online Encyclopedia and its Use as Court Source\"</a>. <i>Internet Business Law Services</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.ibls.com/internet_law_news_portal_view.aspx?s=latestnews&amp;id=1668\" class=\"external text\">the original</a> on May 20, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite> (The name \"<i>World Intellectual Property Office</i>\" should however read \"<i>World Intellectual Property Organization</i>\" in this source.)</span></li><li id=\"cite_note-Courts_turn_to_Wikipedia-328\"> <span id=\"mw-reference-text-cite_note-Courts_turn_to_Wikipedia-328\" class=\"mw-reference-text\"><cite class=\"citation news\">Cohen, Noam (January 29, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2007/01/29/technology/29wikipedia.html\" class=\"external text\">\"Courts Turn to Wikipedia, but Selectively\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-US_Intelligence-329\"> <span id=\"mw-reference-text-cite_note-US_Intelligence-329\" class=\"mw-reference-text\"><cite class=\"citation web\">Aftergood, Steven (March 21, 2007). <a rel=\"mw:ExtLink\" href=\"https://fas.org/blog/secrecy/2007/03/the_wikipedia_factor_in_us_int.html\" class=\"external text\">\"The Wikipedia Factor in US Intelligence\"</a>. Federation of American Scientists Project on Government Secrecy<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 14,</span> 2007</span>.</cite></span></li><li id=\"cite_note-Declan-330\"> <span id=\"mw-reference-text-cite_note-Declan-330\" class=\"mw-reference-text\"><cite class=\"citation journal\">Butler, Declan (December 16, 2008). \"Publish in Wikipedia or perish\". <i>Nature News</i>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1038%2Fnews.2008.1312\" class=\"external text\">10.1038/news.2008.1312</a>.</cite></span></li><li id=\"cite_note-ajr.org_WP_in_the_newsroom-331\"> <span id=\"mw-reference-text-cite_note-ajr.org_WP_in_the_newsroom-331\" class=\"mw-reference-text\"><cite class=\"citation news\">Shaw, Donna (February–March 2008). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120805155909/http://www.ajr.org/Article.asp?id=4461\" class=\"external text\">\"Wikipedia in the Newsroom\"</a>. <i>American Journalism Review</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.ajr.org/Article.asp?id=4461\" class=\"external text\">the original</a> on August 5, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 11,</span> 2008</span>.</cite></span></li><li id=\"cite_note-twsY23-332\"> <span id=\"mw-reference-text-cite_note-twsY23-332\" class=\"mw-reference-text\"><cite class=\"citation news\">Lexington (September 24, 2011). <a rel=\"mw:ExtLink\" href=\"https://www.economist.com/node/21530100\" class=\"external text\">\"Classlessness in America: The uses and abuses of an enduring myth\"</a>. <i>The Economist</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 27,</span> 2011</span>. <q>Socialist Labour Party of America [...] though it can trace its history as far back as 1876, when it was known as the Workingmen's Party, no less an authority than Wikipedia pronounces it \"moribund\".</q></cite></span></li><li id=\"cite_note-shizuoka_plagiarized_WP_1-333\"> <span id=\"mw-reference-text-cite_note-shizuoka_plagiarized_WP_1-333\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20140312013353/http://www.japannewsreview.com/society/chubu/20070705page_id%3D364\" class=\"external text\">\"Shizuoka newspaper plagiarized Wikipedia article\"</a>. <i>Japan News Review</i>. July 5, 2007. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.japannewsreview.com/society/chubu/20070705page_id=364\" class=\"external text\">the original</a> on March 12, 2014.</cite></span></li><li id=\"cite_note-WA_Express-News_staffer_resigns-334\"> <span id=\"mw-reference-text-cite_note-WA_Express-News_staffer_resigns-334\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20071015045010/http://www.mysanantonio.com/news/metro/stories/MYSA010307.02A.richter.132c153.html\" class=\"external text\">\"Express-News staffer resigns after plagiarism in column is discovered\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.mysanantonio.com/news/metro/stories/MYSA010307.02A.richter.132c153.html\" class=\"external text\">the original</a> on October 15, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 31,</span> 2007</span>.</cite>, <i><a href=\"/wiki/San_Antonio_Express-News\" title=\"San Antonio Express-News\">San Antonio Express-News</a></i>, January 9, 2007.</span></li><li id=\"cite_note-starbulletin.com_Inquiry_prompts_dismissal-335\"> <span id=\"mw-reference-text-cite_note-starbulletin.com_Inquiry_prompts_dismissal-335\" class=\"mw-reference-text\"><cite class=\"citation web\">Frank Bridgewater. <a rel=\"mw:ExtLink\" href=\"http://archives.starbulletin.com/2006/01/13/news/story03.html\" class=\"external text\">\"Inquiry prompts reporter's dismissal\"</a>. <i>Honolulu Star-Bulletin</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Time2006-336\"> <span id=\"mw-reference-text-cite_note-Time2006-336\" class=\"mw-reference-text\"><cite class=\"citation news\">Grossman, Lev (December 13, 2006). <a rel=\"mw:ExtLink\" href=\"http://content.time.com/time/magazine/article/0,9171,1570810,00.html\" class=\"external text\">\"Time's Person of the Year: You\"</a>. <i>Time</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-337\"> <span id=\"mw-reference-text-cite_note-337\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.bbc.co.uk/programmes/b007tc6x\" class=\"external text\">\"Radio 4 documentary, BBC\"</a>. 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 24,</span> 2016</span>.</cite></span></li><li id=\"cite_note-338\"> <span id=\"mw-reference-text-cite_note-338\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20090330141810/http://www.grillini.it/show.php?4885\" class=\"external text\">\"Comunicato stampa. On. Franco Grillini. Wikipedia. Interrogazione a Rutelli. Con \"diritto di panorama\" promuovere arte e architettura contemporanea italiana. Rivedere con urgenza legge copyright\"</a> <span>[</span>Press release. Honorable Franco Grillini. Wikipedia. Interview with Rutelli about the \"right to view\" promoting contemporary art and architecture of Italy. Review with urgency copyright law<span>]</span> (in Italian). October 12, 2007. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.grillini.it/show.php?4885\" class=\"external text\">the original</a> on March 30, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-WP.com_WP_election_usage-339\"> <span id=\"mw-reference-text-cite_note-WP.com_WP_election_usage-339\" class=\"mw-reference-text\"><cite class=\"citation news\">Jose Antonio Vargas (September 17, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/wp-dyn/content/article/2007/09/16/AR2007091601699_pf.html\" class=\"external text\">\"On Wikipedia, Debating 2008 Hopefuls' Every Facet\"</a>. <i>The Washington Post</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-340\"> <span id=\"mw-reference-text-cite_note-340\" class=\"mw-reference-text\"><cite class=\"citation news\">Jennifer Ablan (October 22, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.reuters.com/article/domesticNews/idUSN2232893820071022?sp=true\" class=\"external text\">\"Wikipedia page the latest status symbol\"</a>. Reuters<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 24,</span> 2007</span>.</cite></span></li><li id=\"cite_note-LER_students_write_for_WP_1-341\"> <span id=\"mw-reference-text-cite_note-LER_students_write_for_WP_1-341\" class=\"mw-reference-text\"><cite class=\"citation journal\">Witzleb, Normann (2009). \"Engaging with the World: Students of Comparative Law Write for Wikipedia\". <b>19</b> (1 and 2). Legal Education Review: 83–98.</cite><span> </span><span class=\"cs1-hidden-error error citation-comment\">Cite journal requires <code class=\"cs1-code\"><span>|</span>journal=</code> (<a href=\"/wiki/Help:CS1_errors#missing_periodical\" title=\"Help:CS1 errors\">help</a>)</span></span></li><li id=\"cite_note-342\"> <span id=\"mw-reference-text-cite_note-342\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://ai100.stanford.edu/2016-report/section-i-what-artificial-intelligence/ai-research-trends\" class=\"external text\">\"AI Research Trends\"</a>. <i>One Hundred Year Study on Artificial Intelligence (AI100)</i>. Stanford University<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 3,</span> 2016</span>.</cite></span></li><li id=\"cite_note-343\"> <span id=\"mw-reference-text-cite_note-343\" class=\"mw-reference-text\"><cite class=\"citation news\"><a href=\"/wiki/Hossein_Derakhshan\" title=\"Hossein Derakhshan\">Derakhshan, Hossein</a> (October 19, 2017). <a rel=\"mw:ExtLink\" href=\"https://www.wired.com/story/wikipedias-fate-shows-how-the-web-endangers-knowledge/\" class=\"external text\">\"How Social Media Endangers Knowledge\"</a>. Business. <i><a href=\"/wiki/Wired_(magazine)\" title=\"Wired (magazine)\">Wired</a></i>. <a href=\"/wiki/Condé_Nast\" title=\"Condé Nast\">Condé Nast</a>. <a href=\"/wiki/International_Standard_Serial_Number#Electronic_ISSN\" title=\"International Standard Serial Number\">eISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/1078-3148\" class=\"external text\">1078-3148</a>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/1059-1028\" class=\"external text\">1059-1028</a>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20181022190537/https://www.wired.com/story/wikipedias-fate-shows-how-the-web-endangers-knowledge/\" class=\"external text\">Archived</a> from the original on October 22, 2018<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 22,</span> 2018</span>.</cite></span></li><li id=\"cite_note-WP_awards_for_WP_1-344\"> <span id=\"mw-reference-text-cite_note-WP_awards_for_WP_1-344\" class=\"mw-reference-text\"><a href=\"https://meta.wikimedia.org/wiki/Trophy%20box\" title=\"m:Trophy box\">\"Trophy box\"</a>, <a href=\"/wiki/Wikipedia:Meta\" title=\"Wikipedia:Meta\">Meta-Wiki</a> (March 28, 2005).</span></li><li id=\"cite_note-webbyawards_WP_awards_1-345\"> <span id=\"mw-reference-text-cite_note-webbyawards_WP_awards_1-345\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20110722174246/http://www.webbyawards.com/webbys/winners-2004.php\" class=\"external text\">\"Webby Awards 2004\"</a>. The International Academy of Digital Arts and Sciences. 2004. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.webbyawards.com/webbys/winners-2004.php\" class=\"external text\">the original</a> on July 22, 2011.</cite></span></li><li id=\"cite_note-brandchannel.com_awards_1-346\"> <span id=\"mw-reference-text-cite_note-brandchannel.com_awards_1-346\" class=\"mw-reference-text\"><cite class=\"citation news\">Zumpano, Anthony (January 29, 2007). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20070220095907/http://brandchannel.com/features_effect.asp?pf_id=352\" class=\"external text\">\"Similar Search Results: Google Wins\"</a>. Interbrand. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.brandchannel.com/features_effect.asp?pf_id=352\" class=\"external text\">the original</a> on February 20, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 28,</span> 2007</span>.</cite></span></li><li id=\"cite_note-loomarea.com_WP_award_1-347\"> <span id=\"mw-reference-text-cite_note-loomarea.com_WP_award_1-347\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080915140714/http://loomarea.com/die_quadriga/e/index.php?title=Award_2008\" class=\"external text\">\"Die Quadriga—Award 2008\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://loomarea.com/die_quadriga/e/index.php?title=Award_2008\" class=\"external text\">the original</a> on September 15, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></span></li><li id=\"cite_note-EP2015-348\"> <span id=\"mw-reference-text-cite_note-EP2015-348\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.erasmusprijs.org/?lang=en&amp;page=Erasmusprijs\" class=\"external text\">\"Erasmus Prize—Praemium Erasmianum\"</a>. Praemium Erasmianum Foundation<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 15,</span> 2015</span>.</cite></span></li><li id=\"cite_note-349\"> <span id=\"mw-reference-text-cite_note-349\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.fpa.es/es/premios-princesa-de-asturias/premiados/2015-wikipedia.html?especifica=0&amp;idCategoria=0&amp;anio=2015&amp;especifica=0\" class=\"external text\">\"Premio Princesa de Asturias de Cooperación Internacional 2015\"</a>. Fundación Princesa de Asturias<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 17,</span> 2015</span>.</cite></span></li><li id=\"cite_note-350\"> <span id=\"mw-reference-text-cite_note-350\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://www.lne.es/sociedad-cultura/2015/10/22/fundadores-wikipedia-destacan-version-asturiano/1830529.html\" class=\"external text\">\"Los fundadores de Wikipedia destacan la versión en asturiano\"</a> <span>[</span>The founders of Wikipedia highlight the Asturian version<span>]</span>. <i>La Nueva España</i> (in Spanish)<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 20,</span> 2015</span>.</cite></span></li><li id=\"cite_note-onion_WP_750_years_1-351\"> <span id=\"mw-reference-text-cite_note-onion_WP_750_years_1-351\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.theonion.com/articles/wikipedia-celebrates-750-years-of-american-indepen,2007/\" class=\"external text\">\"Wikipedia Celebrates 750 Years Of American Independence\"</a>. <i><a href=\"/wiki/The_Onion\" title=\"The Onion\">The Onion</a></i>. July 26, 2006<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 15,</span> 2006</span>.</cite></span></li><li id=\"cite_note-352\"> <span id=\"mw-reference-text-cite_note-352\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.theonion.com/articles/la-law-wikipedia-page-viewed-874-times-today,18521/\" class=\"external text\">\"<span class=\"cs1-kern-left\">'</span>L.A. Law' Wikipedia Page Viewed 874 Times Today\"</a>. <i><a href=\"/wiki/The_Onion\" title=\"The Onion\">The Onion</a></i>. November 24, 2010.</cite></span></li><li id=\"cite_note-353\"> <span id=\"mw-reference-text-cite_note-353\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.officetally.com/the-office-the-negotiation\" class=\"external text\">\"The Office: The Negotiation, 3.19\"</a>. April 5, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 27,</span> 2014</span>.</cite></span></li><li id=\"cite_note-354\"> <span id=\"mw-reference-text-cite_note-354\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://usatoday30.usatoday.com/tech/webguide/internetlife/2007-04-12-office-wikipedia_N.htm\" class=\"external text\">\"<span class=\"cs1-kern-left\">'</span>Office' fans, inspired by Michael Scott, flock to edit Wikipedia\"</a>. <i>USA Today</i>. April 12, 2007<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 12,</span> 2014</span>.</cite></span></li><li id=\"cite_note-Bakken_one_doctor_1-355\"> <span id=\"mw-reference-text-cite_note-Bakken_one_doctor_1-355\" class=\"mw-reference-text\">Bakken, Janae. \"<a href=\"/wiki/My_Number_One_Doctor\" title=\"My Number One Doctor\" class=\"mw-redirect\">My Number One Doctor</a>\"; <i><a href=\"/wiki/Scrubs_(TV_series)\" title=\"Scrubs (TV series)\">Scrubs</a></i>; <a href=\"/wiki/American_Broadcasting_Company\" title=\"American Broadcasting Company\">ABC</a>; December 6, 2007.</span></li><li id=\"cite_note-collegehumor.com_WP_funny_1-356\"> <span id=\"mw-reference-text-cite_note-collegehumor.com_WP_funny_1-356\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.collegehumor.com/video/3581424/professor-wikipedia\" class=\"external text\">\"Professor Wikipedia—CollegeHumor Video\"</a>. CollegeHumor. November 17, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 19,</span> 2011</span>.</cite></span></li><li id=\"cite_note-dilbert_WP_funny_1-357\"> <span id=\"mw-reference-text-cite_note-dilbert_WP_funny_1-357\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://dilbert.com/strips/comic/2009-05-08\" class=\"external text\">\"Dilbert comic strip for 05/08/2009 from the official Dilbert comic strips archive\"</a>. Universal Uclick. May 8, 2009<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 10,</span> 2013</span>.</cite></span></li><li id=\"cite_note-comedy.org.uk_WP_funny_1-358\"> <span id=\"mw-reference-text-cite_note-comedy.org.uk_WP_funny_1-358\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.comedy.org.uk/guide/radio/bigipedia/interview/\" class=\"external text\">\"Interview With Nick Doody and Matt Kirshen\"</a>. <i><a href=\"/wiki/British_Comedy_Guide\" title=\"British Comedy Guide\">British Comedy Guide</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 31,</span> 2009</span>.</cite></span></li><li id=\"cite_note-tosh_CC_WP_funny_1-359\"> <span id=\"mw-reference-text-cite_note-tosh_CC_WP_funny_1-359\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://tosh.comedycentral.com/blog/2010/02/03/your-wikipedia-entries\" class=\"external text\">\"Your Wikipedia Entries\"</a>. <i>Tosh.0</i>. February 3, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-tosh_CC_WP_funny_2-360\"> <span id=\"mw-reference-text-cite_note-tosh_CC_WP_funny_2-360\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://tosh.comedycentral.com/video-clips/wikipedia-updates\" class=\"external text\">\"Wikipedia Updates\"</a>. <i>Tosh.0</i>. February 3, 2010<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-361\"> <span id=\"mw-reference-text-cite_note-361\" class=\"mw-reference-text\"><cite class=\"citation web\"><a href=\"/wiki/Emily_Flake\" title=\"Emily Flake\">Emily Flake</a> (August 23, 2013). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20141012052730/http://www.condenaststore.com/-sp/Dammit-Manning-have-you-considered-the-pronoun-war-that-this-is-going-t-Cartoon-Prints_i9813981_.htm\" class=\"external text\">\"Manning/Wikipedia cartoon\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.condenaststore.com/-sp/Dammit-Manning-have-you-considered-the-pronoun-war-that-this-is-going-t-Cartoon-Prints_i9813981_.htm\" class=\"external text\">the original</a> on October 12, 2014<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">August 26,</span> 2013</span>.</cite></span></li><li id=\"cite_note-362\"> <span id=\"mw-reference-text-cite_note-362\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://www.thetimes.co.uk/tto/opinion/letters/article4639755.ece\" class=\"external text\">\"The obstacles to reforming our prisons—The Times\"</a>. <i>The Times</i>. December 14, 2015<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-363\"> <span id=\"mw-reference-text-cite_note-363\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.thetimes.co.uk/tto/public/sitesearch.do?querystring=john%20julius%20norwich&amp;p=tto&amp;pf=all&amp;bl=on\" class=\"external text\">\"john julius norwich—Search—The Times\"</a>. <i>thetimes.co.uk</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2016</span>.</cite></span></li><li id=\"cite_note-WM_dictionary_1-364\"> <span id=\"mw-reference-text-cite_note-WM_dictionary_1-364\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://meta.wikimedia.org/w/index.php?title=Wikimedia_News&amp;diff=prev&amp;oldid=4133\" class=\"external text\">\"Announcement of Wiktionary's creation\"</a>. meta.wikimedia.org<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 14,</span> 2012</span>.</cite></span></li><li id=\"cite_note-OurProjects-365\"> <span id=\"mw-reference-text-cite_note-OurProjects-365\" class=\"mw-reference-text\"><a href=\"https://foundation.wikimedia.org/wiki/Our%20projects\" title=\"foundation:Our projects\">\"Our projects\"</a>, <a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a>. Retrieved January 24, 2007.</span></li><li id=\"cite_note-366\"> <span id=\"mw-reference-text-cite_note-366\" class=\"mw-reference-text\"><cite class=\"citation web\">Bosman, Julie (March 13, 2012). <a rel=\"mw:ExtLink\" href=\"http://mediadecoder.blogs.nytimes.com//2012/03/13/after-244-years-encyclopaedia-britannica-stops-the-presses/\" class=\"external text\">\"After 244 Years, Encyclopaedia Britannica Stops the Presses\"</a>. <i>The New York Times</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 26,</span> 2015</span>.</cite></span></li><li id=\"cite_note-367\"> <span id=\"mw-reference-text-cite_note-367\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.gizmocrazed.com/2012/03/encyclopedia-britannica-dies-at-the-hands-of-wikipedia-infographic/\" class=\"external text\">\"<i>Encyclopedia Britannica Dies At The Hands Of Wikipedia</i>, Gizmocrazed.com (with <i>statista</i> infographic from NYTimes.com)\"</a>. Gizmocrazed.com. March 20, 2012<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-FT_impact_on_traditional_media-368\"> <span id=\"mw-reference-text-cite_note-FT_impact_on_traditional_media-368\" class=\"mw-reference-text\"><cite class=\"citation news\"><a href=\"/wiki/Christopher_Caldwell_(journalist)\" title=\"Christopher Caldwell (journalist)\">Christopher Caldwell (journalist)</a> (June 14, 2013). <a rel=\"mw:ExtLink\" href=\"http://www.ft.com/cms/s/0/ae22314a-d383-11e2-b3ff-00144feab7de.html\" class=\"external text\">\"A chapter in the Enlightenment closes\"</a>. <i><a href=\"/wiki/Financial_Times\" title=\"Financial Times\">ft.com</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 15,</span> 2013</span>. <q>Bertelsmann did not resort to euphemism this week when it announced the end of the Brockhaus encyclopedia brand. Brockhaus had been publishing reference books for two centuries when the media group bought it in 2008. [...] The internet has finished off Brockhaus altogether. [...] What Germans like is Wikipedia.</q></cite></span></li><li id=\"cite_note-RType_WP_traditional_media_impact_1-369\"> <span id=\"mw-reference-text-cite_note-RType_WP_traditional_media_impact_1-369\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.roughtype.com/archives/2005/10/the_amorality_o.php\" class=\"external text\">\"The amorality of Web 2.0\"</a>. <i>Rough Type</i>. October 3, 2005<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">July 15,</span> 2006</span>.</cite></span></li><li id=\"cite_note-nature.com_crowds_wisdom-370\"> <span id=\"mw-reference-text-cite_note-nature.com_crowds_wisdom-370\" class=\"mw-reference-text\"><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"http://www.nature.com/nature/peerreview/debate/nature04992.html\" class=\"external text\">\"Technical solutions: Wisdom of the crowds\"</a>. <i>Nature</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 10,</span> 2006</span>.</cite></span></li><li id=\"cite_note-371\"> <span id=\"mw-reference-text-cite_note-371\" class=\"mw-reference-text\"><cite class=\"citation news\">Alison Flood (February 7, 2013). <a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/books/booksblog/2013/feb/07/traditional-biography-shakespeare-breakfast\" class=\"external text\">\"Alison Flood: <i>Should traditional biography be buried alongside Shakespeare's breakfast?</i>\"</a>. <i>The Guardian</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 14,</span> 2014</span>.</cite></span></li><li id=\"cite_note-wikify-372\"> <span id=\"mw-reference-text-cite_note-wikify-372\" class=\"mw-reference-text\">Rada Mihalcea and Andras Csomai (2007). <a rel=\"mw:ExtLink\" href=\"http://www.cse.unt.edu/~tarau/teaching/NLP/papers/Mihalcea-2007-Wikify-Linking_Documents_to_Encyclopedic.pdf\" class=\"external text\">Wikify! Linking Documents to Encyclopedic Knowledge</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160218062051/http://www.cse.unt.edu/~tarau/teaching/NLP/papers/Mihalcea-2007-Wikify-Linking_Documents_to_Encyclopedic.pdf\" class=\"external text\">Archived</a><span> February 18, 2016, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> Proc. CIKM.</span></li><li id=\"cite_note-milne_witten_WP_usage_1-373\"> <span id=\"mw-reference-text-cite_note-milne_witten_WP_usage_1-373\" class=\"mw-reference-text\">David Milne and Ian H. Witten (2008). Learning to link with Wikipedia. Proc. CIKM.</span></li><li id=\"cite_note-discovering_missing_WP_links_1-374\"> <span id=\"mw-reference-text-cite_note-discovering_missing_WP_links_1-374\" class=\"mw-reference-text\">Sisay Fissaha Adafre and [Maarten de Rijke] (2005). <a rel=\"mw:ExtLink\" href=\"http://staff.science.uva.nl/~mdr/Publications/Files/linkkdd2005.pdf\" class=\"external text\">Discovering missing links in Wikipedia</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20120717054413/http://staff.science.uva.nl/~mdr/Publications/Files/linkkdd2005.pdf\" class=\"external text\">Archived</a><span> July 17, 2012, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> Proc. LinkKDD.</span></li><li id=\"cite_note-mitmining-375\"> <span id=\"mw-reference-text-cite_note-mitmining-375\" class=\"mw-reference-text\"><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"http://www.technologyreview.com/view/544266/wikipedia-mining-algorithm-reveals-worlds-most-influential-universities/\" class=\"external text\">\"Wikipedia-Mining Algorithm Reveals World's Most Influential Universities: An algorithm's list of the most influential universities contains some surprising entries\"</a>. <i><a href=\"/wiki/MIT_Technology_Review\" title=\"MIT Technology Review\">MIT Technology Review</a></i>. December 7, 2015<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 27,</span> 2015</span>.</cite></span></li><li id=\"cite_note-harvardisonlymarmow-376\"> <span id=\"mw-reference-text-cite_note-harvardisonlymarmow-376\" class=\"mw-reference-text\"><cite class=\"citation news\">Marmow Shaw, Jessica (December 10, 2015). <a rel=\"mw:ExtLink\" href=\"http://www.marketwatch.com/story/two-universities-beat-harvard-in-this-surprising-school-ranking-2015-12-09\" class=\"external text\">\"Harvard is only the 3rd most influential university in the world, according to this list\"</a>. <i><a href=\"/wiki/MarketWatch\" title=\"MarketWatch\">MarketWatch</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 27,</span> 2015</span>.</cite></span></li><li id=\"cite_note-wikipediarankingtimesworldunifranche-377\"><span></span> <span id=\"mw-reference-text-cite_note-wikipediarankingtimesworldunifranche-377\" class=\"mw-reference-text\"><cite class=\"citation news\">Bothwell, Ellie (December 15, 2015). <a rel=\"mw:ExtLink\" href=\"https://www.timeshighereducation.com/features/wikipedia-ranking-world-universities-top-100\" class=\"external text\">\"Wikipedia Ranking of World Universities: the top 100. List ranks institutions by search engine results and Wikipedia appearances\"</a>. <i><a href=\"/wiki/Times_Higher_Education\" title=\"Times Higher Education\">Times Higher Education</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 27,</span> 2015</span>.</cite></span></li><li id=\"cite_note-378\"> <span id=\"mw-reference-text-cite_note-378\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"https://www.sciencenews.org/blog/scicurious/wikipedia-science-reference-citations\" class=\"external text\">Wikipedia has become a science reference source even though scientists don't cite it</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20180210120955/https://www.sciencenews.org/blog/scicurious/wikipedia-science-reference-citations\" class=\"external text\">Archived</a><span> February 10, 2018, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> Science News, 2018</span></li><li id=\"cite_note-379\"> <span id=\"mw-reference-text-cite_note-379\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3039505\" class=\"external text\">Science Is Shaped by Wikipedia: Evidence from a Randomized Control Trial</a> <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20171221090715/https://papers.ssrn.com/sol3/papers.cfm?abstract_id=3039505\" class=\"external text\">Archived</a><span> December 21, 2017, at the </span><a href=\"/wiki/Wayback_Machine\" title=\"Wayback Machine\">Wayback Machine</a> SSRN, 2017</span></li><li id=\"cite_note-380\"> <span id=\"mw-reference-text-cite_note-380\" class=\"mw-reference-text\"><cite class=\"citation journal\">Petiška, Eduard (December 10, 2018). <a rel=\"mw:ExtLink\" href=\"https://envigogika.czp.cuni.cz/index.php/Envigogika/article/view/569\" class=\"external text\">\"Spíše Wikipedie než učebnice: Vzorce využívání otevřených vzdělávacích zdrojů studenty environmentálních oborů\"</a>. <i>Envigogika</i> (in Czech). <b>13</b> (2). <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//doi.org/10.14712%2F18023061.569\" class=\"external text\">10.14712/18023061.569</a></span>. <a href=\"/wiki/International_Standard_Serial_Number\" title=\"International Standard Serial Number\">ISSN</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/issn/1802-3061\" class=\"external text\">1802-3061</a>.</cite></span></li><li id=\"cite_note-381\"> <span id=\"mw-reference-text-cite_note-381\" class=\"mw-reference-text\">Sarabadani, A., Halfaker, A., &amp; Taraborelli, D. (2017). <a rel=\"mw:ExtLink\" href=\"https://arxiv.org/pdf/1703.03861.pdf\" class=\"external text\">Building automated vandalism detection tools for Wikidata</a>. In Proceedings of the 26th International Conference on World Wide Web Companion (pp. 1647–1654). International World Wide Web Conferences Steering Committee.</span></li><li id=\"cite_note-382\"> <span id=\"mw-reference-text-cite_note-382\" class=\"mw-reference-text\">Potthast, M., Stein, B., &amp; Gerling, R. (2008). <a rel=\"mw:ExtLink\" href=\"https://pdfs.semanticscholar.org/8805/b4d923bee9c9534373425de81a1ba296d461.pdf\" class=\"external text\">Automatic vandalism detection in Wikipedia</a>. In European conference on information retrieval (pp. 663–668). Springer, Berlin, Heidelberg.</span></li><li id=\"cite_note-383\"> <span id=\"mw-reference-text-cite_note-383\" class=\"mw-reference-text\">Asthana, S., &amp; Halfaker, A. (2018). <a rel=\"mw:ExtLink\" href=\"https://dl.acm.org/ft_gateway.cfm?id=3274290&amp;type=pdf\" class=\"external text\">With Few Eyes, All Hoaxes are Deep</a>. Proceedings of the ACM on Human-Computer Interaction, 2(CSCW), 21.</span></li><li id=\"cite_note-Domesday_Project-384\"> <span id=\"mw-reference-text-cite_note-Domesday_Project-384\" class=\"mw-reference-text\"><cite class=\"citation web\">Heart Internet. <a rel=\"mw:ExtLink\" href=\"http://www.domesday1986.com/\" class=\"external text\">\"Website discussing the emulator of the Domesday Project User Interface\"</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">September 9,</span> 2014</span>.</cite></span></li><li id=\"cite_note-385\"> <span id=\"mw-reference-text-cite_note-385\" class=\"mw-reference-text\"><cite class=\"citation news\">Frauenfelder, Mark (November 21, 2000). <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20040814034109/http://www.cnn.com/2000/TECH/computing/11/21/net.gen.encyclopedias.idg/index.html\" class=\"external text\">\"The next generation of online encyclopedias\"</a>. <i>CNN.com</i>. Archived from <a rel=\"mw:ExtLink\" href=\"http://www.cnn.com/2000/TECH/computing/11/21/net.gen.encyclopedias.idg/index.html\" class=\"external text\">the original</a> on August 14, 2004.</cite></span></li><li id=\"cite_note-gnu.org-386\"> <span id=\"mw-reference-text-cite_note-gnu.org-386\" class=\"mw-reference-text\"><a rel=\"mw:ExtLink\" href=\"https://www.gnu.org/encyclopedia/encyclopedia.html\" class=\"external text\">The Free Encyclopedia Project</a> gnu.org ( <a rel=\"mw:ExtLink\" href=\"https://www.webcitation.org/64QXgZhy2?url=http://www.gnu.org/encyclopedia/encyclopedia.html\" class=\"external text\">Archived</a><span> January 3, 2012, at </span><a href=\"/wiki/WebCite\" title=\"WebCite\">WebCite</a>)</span></li><li id=\"cite_note-Orlowski18-387\"> <span id=\"mw-reference-text-cite_note-Orlowski18-387\" class=\"mw-reference-text\"><cite class=\"citation news\"><a href=\"/wiki/Andrew_Orlowski\" title=\"Andrew Orlowski\">Orlowski, Andrew</a> (September 18, 2006). <a rel=\"mw:ExtLink\" href=\"https://www.theregister.co.uk/2006/09/18/sanger_forks_wikipedia\" class=\"external text\">\"Wikipedia founder forks Wikipedia, More experts, less fiddling?\"</a>. <i>The Register</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 27,</span> 2007</span>. <q>Larry Sanger describes the Citizendium project as a \"progressive or gradual fork\", with the major difference that experts have the final say over edits.</q></cite></span></li><li id=\"cite_note-JayLyman-388\"> <span id=\"mw-reference-text-cite_note-JayLyman-388\" class=\"mw-reference-text\"><cite class=\"citation news\">Lyman, Jay (September 20, 2006). <a rel=\"mw:ExtLink\" href=\"http://www.crmbuyer.com/story/53137.html\" class=\"external text\">\"Wikipedia Co-Founder Planning New Expert-Authored Site\"</a>. LinuxInsider<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 27,</span> 2007</span>.</cite></span></li></ol></div></div>\n\n","toclevel":1,"line":"References","anchor":"References","isReferenceSection":true},{"id":56,"text":"\n","toclevel":1,"line":"Further reading","anchor":"Further_reading","isReferenceSection":true},{"id":57,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt3074\">Main article: <a href=\"/wiki/Academic_studies_about_Wikipedia\" title=\"Academic studies about Wikipedia\">Academic studies about Wikipedia</a></div>\n<style data-mw-deduplicate=\"TemplateStyles:r886047268\" typeof=\"mw:Extension/templatestyles mw:Transclusion\">.mw-parser-output .refbegin{font-size:90%;margin-bottom:0.5em}.mw-parser-output .refbegin-hanging-indents>ul{list-style-type:none;margin-left:0}.mw-parser-output .refbegin-hanging-indents>ul>li,.mw-parser-output .refbegin-hanging-indents>dl>dd{margin-left:0;padding-left:3.2em;text-indent:-3.2em;list-style:none}.mw-parser-output .refbegin-100{font-size:100%}</style><div class=\"refbegin reflist   \" style=\"\" about=\"#mwt3075\">\n<ul><li><cite class=\"citation book\">Leitch, Thomas (2014). <i>Wikipedia U: Knowledge, authority, and a liberal education in the digital age</i>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-4214-1535-2\" title=\"Special:BookSources/978-1-4214-1535-2\"><bdi>978-1-4214-1535-2</bdi></a>.</cite></li>\n<li><cite class=\"citation journal\">Jensen, Richard (October 2012). <a rel=\"mw:ExtLink\" href=\"http://www.americanhistoryprojects.com/downloads/JMH1812.PDF\" class=\"external text\">\"Military History on the Electronic Frontier: Wikipedia Fights the War of 1812\"</a> <span class=\"cs1-format\">(PDF)</span>. <i>The Journal of Military History</i>. <b>76</b> (4): 523–556.</cite></li>\n<li><cite class=\"citation journal\">Yasseri, Taha; Robert Sumi; János Kertész (2012).  Szolnoki, Attila (ed.). <a rel=\"mw:ExtLink\" href=\"//www.ncbi.nlm.nih.gov/pmc/articles/PMC3260192\" class=\"external text\">\"Circadian Patterns of Wikipedia Editorial Activity: A Demographic Analysis\"</a>. <i>PLOS One</i>. <b>7</b> (1): e30091. <a href=\"/wiki/ArXiv\" title=\"ArXiv\">arXiv</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//arxiv.org/abs/1109.1746\" class=\"external text\">1109.1746</a></span>. <a href=\"/wiki/Bibcode\" title=\"Bibcode\">Bibcode</a>:<a rel=\"mw:ExtLink\" href=\"https://ui.adsabs.harvard.edu/abs/2012PLoSO...7E0091Y\" class=\"external text\">2012PLoSO...7E0091Y</a>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1371%2Fjournal.pone.0030091\" class=\"external text\">10.1371/journal.pone.0030091</a>. <a href=\"/wiki/PubMed_Central\" title=\"PubMed Central\">PMC</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//www.ncbi.nlm.nih.gov/pmc/articles/PMC3260192\" class=\"external text\">3260192</a></span>. <a href=\"/wiki/PubMed_Identifier\" title=\"PubMed Identifier\" class=\"mw-redirect\">PMID</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//pubmed.ncbi.nlm.nih.gov/22272279\" class=\"external text\">22272279</a>.</cite></li>\n<li><cite class=\"citation journal\">Goldman, Eric (2010). \"Wikipedia's Labor Squeeze and its Consequences\". <i>Journal of Telecommunications and High Technology Law</i>. <b>8</b>. <a href=\"/wiki/Social_Science_Research_Network\" title=\"Social Science Research Network\">SSRN</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//ssrn.com/abstract=1458162\" class=\"external text\">1458162</a></span>.</cite> (<a rel=\"mw:ExtLink\" href=\"http://blog.ericgoldman.org/archives/2010/02/catching_up_wit.htm\" class=\"external text\">A blog post by the author.</a>)</li>\n<li><cite class=\"citation journal\">Nielsen, Finn (August 2007). <a rel=\"mw:ExtLink\" href=\"http://www.firstmonday.org/issues/issue12_8/nielsen/index.html\" class=\"external text\">\"Scientific Citations in Wikipedia\"</a>. <i><a href=\"/wiki/First_Monday_(journal)\" title=\"First Monday (journal)\">First Monday</a></i>. <b>12</b> (8). <a href=\"/wiki/ArXiv\" title=\"ArXiv\">arXiv</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//arxiv.org/abs/0805.1154\" class=\"external text\">0805.1154</a></span>. <a href=\"/wiki/CiteSeerX\" title=\"CiteSeerX\">CiteSeerX</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.246.4536\" class=\"external text\">10.1.1.246.4536</a></span>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.5210%2Ffm.v12i8.1997\" class=\"external text\">10.5210/fm.v12i8.1997</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation journal\">Pfeil, Ulrike; Panayiotis Zaphiris; Chee Siang Ang (2006). <a rel=\"mw:ExtLink\" href=\"http://jcmc.indiana.edu./vol12/issue1/pfeil.html\" class=\"external text\">\"Cultural Differences in Collaborative Authoring of Wikipedia\"</a>. <i>Journal of Computer-Mediated Communication</i>. <b>12</b> (1): 88. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//doi.org/10.1111%2Fj.1083-6101.2006.00316.x\" class=\"external text\">10.1111/j.1083-6101.2006.00316.x</a></span><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation book\">Priedhorsky; Reid; Jilin Chen; Shyong (Tony) K. Lam; Katherine Panciera; <a href=\"/wiki/Loren_Terveen\" title=\"Loren Terveen\">Loren Terveen</a>; <a href=\"/wiki/John_Riedl\" title=\"John Riedl\" class=\"mw-redirect\">John Riedl</a> (2007). \"Creating, destroying, and restoring value in wikipedia\". <i>Proceedings of the 2007 international ACM conference on Conference on supporting group work—GROUP '07</i>. pp.<span>&nbsp;</span>259–268. <a href=\"/wiki/CiteSeerX\" title=\"CiteSeerX\">CiteSeerX</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.123.7456\" class=\"external text\">10.1.1.123.7456</a></span>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1145%2F1316624.1316663\" class=\"external text\">10.1145/1316624.1316663</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-59593-845-9\" title=\"Special:BookSources/978-1-59593-845-9\"><bdi>978-1-59593-845-9</bdi></a>.</cite></li>\n<li><cite class=\"citation conference\">Reagle, Joseph (2007). <a rel=\"mw:ExtLink\" href=\"http://reagle.org/joseph/2007/10/Wikipedia-Authorial-Leadership.pdf\" class=\"external text\"><i>Do as I Do: Authorial Leadership in Wikipedia</i></a> <span class=\"cs1-format\">(PDF)</span>. <i>WikiSym '07: Proceedings of the 2007 International Symposium on Wikis</i>. Montreal, Canada: ACM. <a href=\"/wiki/Handle_System\" title=\"Handle System\">hdl</a>:<a rel=\"mw:ExtLink\" href=\"//hdl.handle.net/2047%2Fd20002876\" class=\"external text\">2047/d20002876</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 26,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation book\">Rijshouwer, Emiel (2019). <i>Organizing Democracy. Power concentration and self-organization in the evolution of Wikipedia (PhD, Erasmus University Rotterdam)</i>. <a href=\"/wiki/Handle_System\" title=\"Handle System\">hdl</a>:<a rel=\"mw:ExtLink\" href=\"//hdl.handle.net/1765%2F113937\" class=\"external text\">1765/113937</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-9402813715\" title=\"Special:BookSources/978-9402813715\"><bdi>978-9402813715</bdi></a>. <a href=\"/wiki/OCLC\" title=\"OCLC\">OCLC</a><span>&nbsp;</span><a rel=\"mw:ExtLink\" href=\"//www.worldcat.org/oclc/1081174169\" class=\"external text\">1081174169</a>.</cite> (Open access)</li>\n<li><a href=\"/wiki/Roy_Rosenzweig\" title=\"Roy Rosenzweig\">Rosenzweig, Roy</a>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20090430201444/http://chnm.gmu.edu/resources/essays/d/42\" class=\"external text\">Can History be Open Source? Wikipedia and the Future of the Past</a>. (Originally published in <i><a href=\"/wiki/The_Journal_of_American_History\" title=\"The Journal of American History\">The Journal of American History</a></i> 93.1 (June 2006): 117–146.)</li>\n<li><cite class=\"citation journal\">Wilkinson, Dennis M.; Bernardo A. Huberman (April 2007). <a rel=\"mw:ExtLink\" href=\"http://www.firstmonday.org/issues/issue12_4/wilkinson/index.html\" class=\"external text\">\"Assessing the Value of Cooperation in Wikipedia\"</a>. <i>First Monday</i>. <b>12</b> (4). <a href=\"/wiki/ArXiv\" title=\"ArXiv\">arXiv</a>:<span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//arxiv.org/abs/cs/0702140\" class=\"external text\">cs/0702140</a></span>. <a href=\"/wiki/Bibcode\" title=\"Bibcode\">Bibcode</a>:<a rel=\"mw:ExtLink\" href=\"https://ui.adsabs.harvard.edu/abs/2007cs........2140W\" class=\"external text\">2007cs........2140W</a>. <a href=\"/wiki/CiteSeerX\" title=\"CiteSeerX\">CiteSeerX</a><span>&nbsp;</span><span class=\"cs1-lock-free\"><a rel=\"mw:ExtLink\" href=\"//citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.342.6933\" class=\"external text\">10.1.1.342.6933</a></span>. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.5210%2Ffm.v12i4.1763\" class=\"external text\">10.5210/fm.v12i4.1763</a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation journal\">Aaron Halfaker; R. Stuart Geiger; Jonathan T. Morgan; John Riedl (2012). \"The Rise and Decline of an Open Collaboration Community\". <i>American Behavioral Scientist</i>. <b>57</b> (5): 664. <a href=\"/wiki/Digital_object_identifier\" title=\"Digital object identifier\">doi</a>:<a rel=\"mw:ExtLink\" href=\"//doi.org/10.1177%2F0002764212469365\" class=\"external text\">10.1177/0002764212469365</a>.</cite></li></ul>\n</div>\n<ul><li>Maggio Lauren, Willinsky John, Steinberg Ryan, Mietchan Daniel, Wass Joseph, Dong Ting. \"Wikipedia as a gateway to biomedical research: The relative distribution and use of citations in the English Wikipedia\" (2017).</li></ul>\n\n","toclevel":2,"line":"Academic studies","anchor":"Academic_studies","isReferenceSection":true},{"id":58,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt3124\">Main article: <a href=\"/wiki/List_of_books_about_Wikipedia\" title=\"List of books about Wikipedia\" class=\"mw-redirect\">List of books about Wikipedia</a></div>\n<div class=\"refbegin reflist   \" style=\"\" about=\"#mwt3125\">\n<ul><li><cite class=\"citation book\">Ayers, Phoebe; Matthews, Charles; Yates, Ben (2008). <a rel=\"mw:ExtLink\" href=\"https://archive.org/details/howwikipediawork00ayer_0\" class=\"external text\"><i>How Wikipedia Works: And How You Can Be a Part of It</i></a>. San Francisco: No Starch Press. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-59327-176-3\" title=\"Special:BookSources/978-1-59327-176-3\"><bdi>978-1-59327-176-3</bdi></a>.</cite></li>\n<li><cite class=\"citation book\">Broughton, John (2008). <span class=\"new\"><i>Wikipedia—The Missing Manual</i></span>. O'Reilly Media. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-596-51516-4\" title=\"Special:BookSources/978-0-596-51516-4\"><bdi>978-0-596-51516-4</bdi></a>.</cite> (See book review by Baker, as listed hereafter.)</li>\n<li><cite class=\"citation book\">Broughton, John (2008). <span class=\"cs1-lock-registration\"><a rel=\"mw:ExtLink\" href=\"https://archive.org/details/isbn_9780596521745\" class=\"external text\"><i>Wikipedia Reader's Guide</i></a></span>. Sebastopol: Pogue Press. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-596-52174-5\" title=\"Special:BookSources/978-0-596-52174-5\"><bdi>978-0-596-52174-5</bdi></a>.</cite></li>\n<li><cite class=\"citation book\"><a href=\"/wiki/Andrew_Dalby\" title=\"Andrew Dalby\">Dalby, Andrew</a> (2009). <span class=\"cs1-lock-registration\"><a rel=\"mw:ExtLink\" href=\"https://archive.org/details/worldwikipediaho0000dalb\" class=\"external text\"><i>The World and Wikipedia: How We are Editing Reality</i></a></span>. Siduri. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-9562052-0-9\" title=\"Special:BookSources/978-0-9562052-0-9\"><bdi>978-0-9562052-0-9</bdi></a>.</cite></li>\n<li><cite class=\"citation book\">Jemielniak, Dariusz (2014). <a href=\"/wiki/Common_Knowledge%3F_An_Ethnography_of_Wikipedia\" title=\"Common Knowledge? An Ethnography of Wikipedia\" class=\"mw-redirect\"><i>Common Knowledge? An Ethnography of Wikipedia</i></a>. Stanford, California: <a href=\"/wiki/Stanford_University_Press\" title=\"Stanford University Press\">Stanford University Press</a>. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-8047-8944-8\" title=\"Special:BookSources/978-0-8047-8944-8\"><bdi>978-0-8047-8944-8</bdi></a>.</cite></li>\n<li><cite class=\"citation book\"><a href=\"/wiki/Andrew_Keen\" title=\"Andrew Keen\">Keen, Andrew</a> (2007). <a href=\"/wiki/The_Cult_of_the_Amateur\" title=\"The Cult of the Amateur\"><i>The Cult of the Amateur</i></a>. Doubleday/Currency. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-385-52080-5\" title=\"Special:BookSources/978-0-385-52080-5\"><bdi>978-0-385-52080-5</bdi></a>.</cite> (Substantial criticisms of Wikipedia and other web 2.0 projects.)\n<ul><li>Listen to:\n<ul><li><cite class=\"citation web\">Keen, Andrew (June 16, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.npr.org/templates/story/story.php?storyId=11131872\" class=\"external text\">\"Does the Internet Undermine Culture?\"</a>. National Public Radio, US.</cite> The NPR interview with A. Keen, Weekend Edition Saturday, June 16, 2007.</li></ul></li></ul></li>\n<li><cite class=\"citation book\"><a href=\"/wiki/Andrew_Lih\" title=\"Andrew Lih\">Lih, Andrew</a> (2009). <a href=\"/wiki/The_Wikipedia_Revolution:_How_a_Bunch_of_Nobodies_Created_the_World's_Greatest_Encyclopedia\" title=\"The Wikipedia Revolution: How a Bunch of Nobodies Created the World's Greatest Encyclopedia\" class=\"mw-redirect\"><i>The Wikipedia Revolution: How a Bunch of Nobodies Created the World's Greatest Encyclopedia</i></a>. New York: Hyperion. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-1-4013-0371-6\" title=\"Special:BookSources/978-1-4013-0371-6\"><bdi>978-1-4013-0371-6</bdi></a>.</cite></li>\n<li><cite class=\"citation book\">O'Sullivan, Dan (2009). <a rel=\"mw:ExtLink\" href=\"https://books.google.com/books?id=htu8A-m_Y4EC\" class=\"external text\"><i>Wikipedia: a new community of practice?</i></a>. Ashgate Publishing. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-7546-7433-7\" title=\"Special:BookSources/978-0-7546-7433-7\"><bdi>978-0-7546-7433-7</bdi></a>.</cite></li>\n<li><cite class=\"citation book\"><a href=\"/wiki/Sheizaf_Rafaeli\" title=\"Sheizaf Rafaeli\">Sheizaf Rafaeli</a>; Yaron Ariel (2008). \"Online motivational factors: Incentives for participation and contribution in Wikipedia\".  In Barak, A. (ed.). <i>Psychological aspects of cyberspace: Theory, research, applications</i>. Cambridge, UK: <a href=\"/wiki/Cambridge_University_Press\" title=\"Cambridge University Press\">Cambridge University Press</a>. pp.<span>&nbsp;</span>243–267.</cite></li>\n<li><cite class=\"citation book\">Reagle, Joseph Michael Jr. (2010). <a rel=\"mw:ExtLink\" href=\"http://reagle.org/joseph/2010/gfc\" class=\"external text\"><i>Good Faith Collaboration: The Culture of Wikipedia</i></a>. Cambridge, Massachusetts: the MIT Press. <a href=\"/wiki/International_Standard_Book_Number\" title=\"International Standard Book Number\">ISBN</a><span>&nbsp;</span><a href=\"/wiki/Special:BookSources/978-0-262-01447-2\" title=\"Special:BookSources/978-0-262-01447-2\"><bdi>978-0-262-01447-2</bdi></a><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 25,</span> 2015</span>.</cite></li></ul>\n</div>\n\n","toclevel":2,"line":"Books","anchor":"Books","isReferenceSection":true},{"id":59,"text":"\n\n<div class=\"refbegin reflist   \" style=\"\" about=\"#mwt3174\">\n<ul><li><a href=\"/wiki/Nicholson_Baker\" title=\"Nicholson Baker\">Baker, Nicholson</a>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20080303001807/http://www.nybooks.com/articles/21131\" class=\"external text\">\"The Charms of Wikipedia\"</a>. <i><a href=\"/wiki/The_New_York_Review_of_Books\" title=\"The New York Review of Books\">The New York Review of Books</a></i>, March 20, 2008. Retrieved December 17, 2008. (Book rev. of <i>The Missing Manual</i>, by John Broughton, as listed previously.)</li>\n<li><a href=\"/wiki/L._Gordon_Crovitz\" title=\"L. Gordon Crovitz\">Crovitz, L. Gordon</a>. <a rel=\"mw:ExtLink\" href=\"https://www.wsj.com/articles/SB123897399273491031\" class=\"external text\">\"Wikipedia's Old-Fashioned Revolution: The online encyclopedia is fast becoming the best.\"</a> (Originally published in <a href=\"/wiki/The_Wall_Street_Journal\" title=\"The Wall Street Journal\"><i>Wall Street Journal</i></a> online—April 6, 2009.)</li>\n<li><a href=\"/wiki/Virginia_Postrel\" title=\"Virginia Postrel\">Postrel, Virginia</a>, <a rel=\"mw:ExtLink\" href=\"https://psmag.com/social-justice/killed-wikipedia-93777\" class=\"external text\">\"Who Killed Wikipedia?<span>&nbsp;</span>: A hardened corps of volunteer editors is the only force protecting Wikipedia. They might also be killing it\"</a>, <i><a href=\"/wiki/Pacific_Standard\" title=\"Pacific Standard\">Pacific Standard</a></i> magazine, November/December 2014 issue.</li></ul>\n</div>\n\n","toclevel":2,"line":"Book review-related articles","anchor":"Book_review-related_articles","isReferenceSection":true},{"id":60,"text":"\n\n<div class=\"refbegin reflist   \" style=\"\" about=\"#mwt3179\">\n<ul><li><a href=\"https://en.wikiversity.org/wiki/wikipedia#Learning_resources\" title=\"v:wikipedia\">Wikiversity list of learning resources</a>. (Includes related courses, <a href=\"/wiki/Web_conferencing\" title=\"Web conferencing\">Web-based seminars</a>, slides, lecture notes, textbooks, quizzes, glossaries, etc.)</li>\n<li><a rel=\"mw:ExtLink\" href=\"http://www.cbc.ca/ideas/episodes/2014/01/15/the-great-book-of-knowledge-part-1/\" class=\"external text\">The Great Book of Knowledge, Part 1: A Wiki is a Kind of Bus</a>, <i><a href=\"/wiki/Ideas_(radio_show)\" title=\"Ideas (radio show)\">Ideas, with Paul Kennedy</a></i>, <a href=\"/wiki/CBC_Radio_One\" title=\"CBC Radio One\">CBC Radio One</a>, originally broadcast January 15, 2014. The webpage includes a link to the archived audio program (also <a rel=\"mw:ExtLink\" href=\"http://www.cbc.ca/ideas/popupaudio.html?clipIds=2430203709\" class=\"external text\">found here</a>). The radio documentary discusses Wikipedia's history, development and its place within the broader scope of the trend to democratized knowledge. It also includes interviews with several key Wikipedia staff and contributors, including <a href=\"/wiki/Kat_Walsh\" title=\"Kat Walsh\" class=\"mw-redirect\">Kat Walsh</a> and <a href=\"/wiki/Sue_Gardner\" title=\"Sue Gardner\">Sue Gardner</a> (audio, 53:58, Flash required).</li></ul>\n</div>\n\n","toclevel":2,"line":"Learning resources","anchor":"Learning_resources","isReferenceSection":true},{"id":61,"text":"\n","toclevel":2,"line":"Other media coverage","anchor":"Other_media_coverage","isReferenceSection":true},{"id":62,"text":"\n\n<div role=\"note\" class=\"hatnote navigation-not-searchable\" about=\"#mwt3184\">See also: <a href=\"/wiki/List_of_films_about_Wikipedia\" title=\"List of films about Wikipedia\">List of films about Wikipedia</a></div>\n<div class=\"refbegin reflist   \" style=\"\" about=\"#mwt3185\">\n<ul><li><cite class=\"citation news\">Balke, Jeff (March 2008). <a rel=\"mw:ExtLink\" href=\"http://blogs.chron.com/brokenrecord/2008/03/for_music_fans_wikipedia_myspa.html\" class=\"external text\">\"For Music Fans: Wikipedia; MySpace\"</a>. <i><a href=\"/wiki/Houston_Chronicle\" title=\"Houston Chronicle\">Houston Chronicle</a></i>. Broken Record (blog)<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">December 17,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\">Borland, John (August 14, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.wired.com/2007/08/wiki-tracker/\" class=\"external text\">\"See Who's Editing Wikipedia—Diebold, the CIA, a Campaign\"</a>. <i><a href=\"/wiki/Wired_(magazine)\" title=\"Wired (magazine)\">Wired</a></i>. <a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20151116134820/https://www.wired.com/2007/08/wiki-tracker/\" class=\"external text\">Archived</a> from the original on November 16, 2015<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 23,</span> 2018</span>.</cite></li>\n<li><cite class=\"citation news\">Dee, Jonathan (July 1, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.nytimes.com/2007/07/01/magazine/01WIKIPEDIA-t.html\" class=\"external text\">\"All the News That's Fit to Print Out\"</a>. <i>The New York Times Magazine</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\">Giles, Jim (September 20, 2007). <a rel=\"mw:ExtLink\" href=\"https://www.newscientist.com/article/mg19526226.200\" class=\"external text\">\"Wikipedia 2.0—Now with Added Trust\"</a>. <i><a href=\"/wiki/New_Scientist\" title=\"New Scientist\">New Scientist</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">January 14,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\">Miliard, Mike (December 2, 2007). <a rel=\"mw:ExtLink\" href=\"http://thephoenix.com/Boston/Life/52864-Wikipedia-rules\" class=\"external text\">\"Wikipedia Rules\"</a>. <i><a href=\"/wiki/The_Phoenix_(newspaper)\" title=\"The Phoenix (newspaper)\">The Phoenix</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\"><a href=\"/wiki/Marshall_Poe\" title=\"Marshall Poe\">Poe, Marshall</a> (September 1, 2006). <a rel=\"mw:ExtLink\" href=\"https://www.theatlantic.com/doc/200609/wikipedia\" class=\"external text\">\"The Hive\"</a>. <i><a href=\"/wiki/The_Atlantic\" title=\"The Atlantic\">The Atlantic</a> Monthly</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">March 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\">Rosenwald, Michael S. (October 23, 2009). <a rel=\"mw:ExtLink\" href=\"https://www.washingtonpost.com/wp-dyn/content/article/2009/10/22/AR2009102204715.html?hpid=topnews\" class=\"external text\">\"Gatekeeper of D.C.'s entry: Road to city's Wikipedia page goes through a DuPont Circle bedroom\"</a>. <i>The Washington Post</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">October 22,</span> 2009</span>.</cite></li>\n<li><cite class=\"citation news\">Runciman, David (May 28, 2009). <a rel=\"mw:ExtLink\" href=\"http://www.lrb.co.uk/v31/n10/runc01_.html\" class=\"external text\">\"Like Boiling a Frog\"</a>. <i>London Review of Books</i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 3,</span> 2009</span>.</cite></li>\n<li><cite class=\"citation news\">Taylor, Chris (May 29, 2005). <a rel=\"mw:ExtLink\" href=\"http://www.time.com/time/magazine/article/0,9171,1066904-1,00.html\" class=\"external text\">\"It's a Wiki, Wiki World\"</a>. <i><a href=\"/wiki/Time_(magazine)\" title=\"Time (magazine)\">Time</a></i><span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">February 22,</span> 2008</span>.</cite></li>\n<li><cite class=\"citation news\"><a rel=\"mw:ExtLink\" href=\"https://www.economist.com/science/tq/displaystory.cfm?story_id=11484062\" class=\"external text\">\"Technological Quarterly: Brain Scan: The Free-knowledge Fundamentalist\"</a>. <i><a href=\"/wiki/The_Economist\" title=\"The Economist\">The Economist</a></i>. June 5, 2008<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">June 5,</span> 2008</span>. <q>Jimmy Wales changed the world with Wikipedia, the hugely popular online encyclopedia that anyone can edit. What will he do next?</q></cite></li>\n<li><a rel=\"mw:ExtLink\" href=\"https://www.bbc.co.uk/news/technology-24613608\" class=\"external text\">\"Wikipedia probe into paid-for 'sockpuppet' entries\"</a>, BBC News, October 21, 2013.</li>\n<li><a rel=\"mw:ExtLink\" href=\"http://www.technologyreview.com/featuredstory/520446/the-decline-of-wikipedia/\" class=\"external text\">\"The Decline of Wikipedia\"</a>, <i>MIT Technology Review</i>, October 22, 2013</li>\n<li><a rel=\"mw:ExtLink\" href=\"http://www.capitalnewyork.com/article/city-hall/2015/03/8563947/edits-wikipedia-pages-bell-garner-diallo-traced-1-police-plaza\" class=\"external text\">\"Edits to Wikipedia pages on Bell, Garner, Diallo traced to 1<span class=\"nowrap\"><span>&nbsp;</span></span>Police Plaza\"</a> (March 2015), <i><a href=\"/wiki/Media_in_New_York's_Capital_District\" title=\"Media in New York's Capital District\">Capital</a></i></li>\n<li><a rel=\"mw:ExtLink\" href=\"https://motherboard.vice.com/read/wikipedia-zero-facebook-free-basics-angola-pirates-zero-rating\" class=\"external text\">Angola's Wikipedia Pirates Are Exposing Problems</a> (March 2016), <i><a href=\"/wiki/Vice_(magazine)\" title=\"Vice (magazine)\">Motherboard</a></i></li>\n<li><cite class=\"citation web\"><a rel=\"mw:ExtLink\" href=\"https://web.archive.org/web/20160804110601/http://fullmeasure.news/news/politics/dark-side-of-wikipedia\" class=\"external text\">\"Dark Side of Wikipedia\"</a>. Archived from <a rel=\"mw:ExtLink\" href=\"http://fullmeasure.news/news/politics/dark-side-of-wikipedia\" class=\"external text\">the original</a> on August 4, 2016<span class=\"reference-accessdate\">. Retrieved <span class=\"nowrap\">April 17,</span> 2016</span>.</cite> <i><a href=\"/wiki/Full_Measure_with_Sharyl_Attkisson\" title=\"Full Measure with Sharyl Attkisson\">Full Measure with Sharyl Attkisson</a></i>, April 17, 2016. <small>(Includes video.)</small></li>\n<li><cite class=\"citation web\">Wales, Jimmy (December 9, 2016). <a rel=\"mw:ExtLink\" href=\"https://www.cato.org/multimedia/cato-daily-podcast/how-wikipedia-works\" class=\"external text\">\"How Wikipedia Works\"</a>. <i>cato.org</i>. <a href=\"/wiki/Cato_Institute\" title=\"Cato Institute\">Cato Institute</a>. <q>Jimmy Wales, founder of Wikipedia, discusses the site, how it's treated by governments, and how it's fueled by its users.</q></cite></li></ul>\n</div>\n\n","toclevel":3,"line":"General articles","anchor":"General_articles","isReferenceSection":true},{"id":63,"text":"\n\n<ul><li><a rel=\"mw:ExtLink\" href=\"https://gizmodo.com/wikipedias-yearend-list-shows-what-the-internet-needed-1840690794\" class=\"external text\">Wikipedia's Year-End List Shows What the Internet Needed to Know in 2019</a>. Alyse Stanley, December 27, 2019, Gizmodo.</li>\n<li><a rel=\"mw:ExtLink\" href=\"https://www.independent.co.uk/life-style/gadgets-and-tech/features/is-wikipedia-cracking-up-1543527.html\" class=\"external text\">\"Is Wikipedia Cracking Up?\"</a> <i>The Independent</i>, February 3, 2009.</li></ul>\n\n","toclevel":3,"line":"Articles re Wikipedia usage patterns","anchor":"Articles_re_Wikipedia_usage_patterns","isReferenceSection":true},{"id":64,"text":"\n\n<div role=\"navigation\" aria-labelledby=\"sister-projects\" class=\"metadata plainlinks sistersitebox plainlist mbox-small mw-collapsible\" style=\"border:1px solid #aaa; padding:0; background:#f9f9f9; \" about=\"#mwt3239\"><div style=\"clear: both; padding: 0.75em 0; text-align: center;\"><b style=\"display:block;\">Wikipedia</b>at Wikipedia's <a href=\"/wiki/Wikipedia:Wikimedia_sister_projects\" title=\"Wikipedia:Wikimedia sister projects\"><span id=\"sister-projects\">sister projects</span></a></div><ul class=\"mw-collapsible-content\" style=\"border-top:1px solid #aaa; padding: 0.75em 0; width:217px; margin:0 auto;\"><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/0/06/Wiktionary-logo-v2.svg/27px-Wiktionary-logo-v2.svg.png\" data-file-width=\"391\" data-file-height=\"391\" data-file-type=\"drawing\" height=\"27\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/0/06/Wiktionary-logo-v2.svg/54px-Wiktionary-logo-v2.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/0/06/Wiktionary-logo-v2.svg/41px-Wiktionary-logo-v2.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wiktionary.org/wiki/Special:Search/Wikipedia\" title=\"wikt:Special:Search/Wikipedia\">Definitions</a> from Wiktionary</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/20px-Commons-logo.svg.png\" data-file-width=\"1024\" data-file-height=\"1376\" data-file-type=\"drawing\" height=\"27\" width=\"20\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/40px-Commons-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/4/4a/Commons-logo.svg/30px-Commons-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://commons.wikimedia.org/wiki/Special:Search/Wikipedia\" title=\"c:Special:Search/Wikipedia\">Media</a> from Wikimedia Commons</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/24/Wikinews-logo.svg/27px-Wikinews-logo.svg.png\" data-file-width=\"759\" data-file-height=\"415\" data-file-type=\"drawing\" height=\"15\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/2/24/Wikinews-logo.svg/54px-Wikinews-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/2/24/Wikinews-logo.svg/41px-Wikinews-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikinews.org/wiki/Category:Wikipedia\" title=\"n:Category:Wikipedia\">News</a> from Wikinews</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/23px-Wikiquote-logo.svg.png\" data-file-width=\"300\" data-file-height=\"355\" data-file-type=\"drawing\" height=\"27\" width=\"23\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/46px-Wikiquote-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikiquote-logo.svg/35px-Wikiquote-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikiquote.org/wiki/Special:Search/Wikipedia\" title=\"q:Special:Search/Wikipedia\">Quotations</a> from Wikiquote</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Wikisource-logo.svg/26px-Wikisource-logo.svg.png\" data-file-width=\"410\" data-file-height=\"430\" data-file-type=\"drawing\" height=\"27\" width=\"26\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Wikisource-logo.svg/51px-Wikisource-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Wikisource-logo.svg/39px-Wikisource-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikisource.org/wiki/Category:Wikipedia\" title=\"s:Category:Wikipedia\">Texts</a> from Wikisource</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/27px-Wikibooks-logo.svg.png\" data-file-width=\"300\" data-file-height=\"300\" data-file-type=\"drawing\" height=\"27\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/54px-Wikibooks-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/f/fa/Wikibooks-logo.svg/41px-Wikibooks-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikibooks.org/wiki/Special:Search/Wikipedia\" title=\"b:Special:Search/Wikipedia\">Textbooks</a> from Wikibooks</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Wikivoyage-Logo-v3-icon.svg/27px-Wikivoyage-Logo-v3-icon.svg.png\" data-file-width=\"193\" data-file-height=\"193\" data-file-type=\"drawing\" height=\"27\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Wikivoyage-Logo-v3-icon.svg/54px-Wikivoyage-Logo-v3-icon.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/d/dd/Wikivoyage-Logo-v3-icon.svg/41px-Wikivoyage-Logo-v3-icon.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikivoyage.org/wiki/Wikivoyage:Cooperating%20with%20Wikipedia\" title=\"voy:Wikivoyage:Cooperating with Wikipedia\">Travel guide</a> from Wikivoyage</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/27px-Wikiversity-logo-en.svg.png\" data-file-width=\"1000\" data-file-height=\"900\" data-file-type=\"drawing\" height=\"24\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/54px-Wikiversity-logo-en.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/1/1b/Wikiversity-logo-en.svg/41px-Wikiversity-logo-en.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://en.wikiversity.org/wiki/Special:Search/Wikipedia\" title=\"v:Special:Search/Wikipedia\">Resources</a> from Wikiversity</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Wikidata-logo.svg/27px-Wikidata-logo.svg.png\" data-file-width=\"1050\" data-file-height=\"590\" data-file-type=\"drawing\" height=\"15\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Wikidata-logo.svg/54px-Wikidata-logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/f/ff/Wikidata-logo.svg/41px-Wikidata-logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://www.wikidata.org/wiki/Q52\" title=\"d:Q52\">Data</a> from Wikidata</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/75/Wikimedia_Community_Logo.svg/27px-Wikimedia_Community_Logo.svg.png\" data-file-width=\"900\" data-file-height=\"900\" data-file-type=\"drawing\" height=\"27\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/75/Wikimedia_Community_Logo.svg/54px-Wikimedia_Community_Logo.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/7/75/Wikimedia_Community_Logo.svg/41px-Wikimedia_Community_Logo.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://meta.wikimedia.org/wiki/Wikipedia\" title=\"m:Wikipedia\">Discussion</a> from Meta-Wiki</span>\n            </li><li style=\"min-height: 31px;\"><span style=\"display: inline-block; width: 31px; line-height: 31px; vertical-align: middle; text-align: center;\"><figure-inline class=\"mw-valign-middle\"><span><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/bb/MediaWiki-notext.svg/27px-MediaWiki-notext.svg.png\" data-file-width=\"685\" data-file-height=\"530\" data-file-type=\"drawing\" height=\"21\" width=\"27\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/b/bb/MediaWiki-notext.svg/54px-MediaWiki-notext.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/b/bb/MediaWiki-notext.svg/41px-MediaWiki-notext.svg.png 1.5x\"></span></figure-inline></span><span style=\"display: inline-block; margin-left: 4px; width: 182px; vertical-align: middle;\"><a href=\"https://www.mediawiki.org/wiki/Wikipedia\" title=\"mw:Wikipedia\">Documentation</a> from MediaWiki</span>\n            </li></ul>\n</div>\n<ul><li><span class=\"official-website\"><span class=\"url\"><a rel=\"mw:ExtLink\" href=\"https://www.wikipedia.org\" class=\"external text\">Official website</a></span></span><span> (</span><span class=\"url\"><a rel=\"mw:ExtLink\" href=\"https://en.m.wikipedia.org\" class=\"external text\">Mobile</a></span><span>)</span>—multilingual portal (contains links to all language editions) (wikipedia.com still redirects here)</li>\n<li><a rel=\"mw:ExtLink\" href=\"https://curlie.org/Computers/Open_Source/Open_Content/Encyclopedias/Wikipedia\" class=\"external text\">Wikipedia</a><span> at </span><a href=\"/wiki/Curlie\" title=\"Curlie\" class=\"mw-redirect\">Curlie</a></li>\n<li><a rel=\"mw:ExtLink\" href=\"https://www.theguardian.com/technology/wikipedia\" class=\"external text\">Wikipedia collected news and commentary</a><span> at </span><i><a href=\"/wiki/The_Guardian\" title=\"The Guardian\">The Guardian</a></i><span> </span><figure-inline class=\"mw-valign-text-top\"><a href=\"https://www.wikidata.org/wiki/Q52#P3106\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/10px-OOjs_UI_icon_edit-ltr-progressive.svg.png\" data-file-width=\"20\" data-file-height=\"20\" data-file-type=\"drawing\" height=\"10\" width=\"10\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/20px-OOjs_UI_icon_edit-ltr-progressive.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/15px-OOjs_UI_icon_edit-ltr-progressive.svg.png 1.5x\"></a></figure-inline></li>\n<li><a rel=\"mw:ExtLink\" href=\"http://topics.nytimes.com/top/news/business/companies/wikipedia/index.html\" class=\"external text\">Wikipedia</a> topic page at <i><a href=\"/wiki/The_New_York_Times\" title=\"The New York Times\">The New York Times</a></i></li>\n<li><a rel=\"mw:ExtLink\" href=\"http://www.ted.com/index.php/talks/jimmy_wales_on_the_birth_of_wikipedia.html\" class=\"external text\">Video of TED talk by Jimmy Wales on the birth of Wikipedia</a></li></ul>\n\n<div role=\"navigation\" class=\"navbox\" aria-labelledby=\"Wikipedia\" style=\"padding:3px\" about=\"#mwt3243\"><table class=\"nowraplinks hlist mw-collapsible expanded navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th scope=\"col\" class=\"navbox-title\" colspan=\"2\"><div class=\"plainlinks hlist navbar mini\"><ul><li class=\"nv-view\"><a href=\"/wiki/Template:Wikipedia\" title=\"Template:Wikipedia\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">v</abbr></a></li><li class=\"nv-talk\"><a href=\"/wiki/Template_talk:Wikipedia\" title=\"Template talk:Wikipedia\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">t</abbr></a></li><li class=\"nv-edit\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Template:Wikipedia&amp;action=edit\" class=\"external text\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">e</abbr></a></li></ul></div><div id=\"Wikipedia\" style=\"font-size:114%;margin:0 4em\"><a href=\"/wiki/Wikipedia\" title=\"Wikipedia\">Wikipedia</a></div></th></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/Outline_of_Wikipedia\" title=\"Outline of Wikipedia\">Overview<br>(Outline)</a></th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Censorship_of_Wikipedia\" title=\"Censorship of Wikipedia\">Censorship</a></li>\n<li><a href=\"/wiki/Conflict-of-interest_editing_on_Wikipedia\" title=\"Conflict-of-interest editing on Wikipedia\">Conflict-of-interest editing</a></li>\n<li><a href=\"/wiki/Criticism_of_Wikipedia\" title=\"Criticism of Wikipedia\">Criticism</a>\n<ul><li><a href=\"/wiki/Gender_bias_on_Wikipedia\" title=\"Gender bias on Wikipedia\">gender bias</a></li>\n<li><a href=\"/wiki/Ideological_bias_on_Wikipedia\" title=\"Ideological bias on Wikipedia\">ideological bias</a></li>\n<li><a href=\"/wiki/Racial_bias_on_Wikipedia\" title=\"Racial bias on Wikipedia\">racial bias</a></li></ul></li>\n<li><a href=\"/wiki/Deletionism_and_inclusionism_in_Wikipedia\" title=\"Deletionism and inclusionism in Wikipedia\">Deletionism and inclusionism</a></li>\n<li><a href=\"/wiki/MediaWiki\" title=\"MediaWiki\">MediaWiki</a></li>\n<li><a href=\"/wiki/Notability_in_the_English_Wikipedia\" title=\"Notability in the English Wikipedia\">Notability</a></li>\n<li><a href=\"/wiki/Reliability_of_Wikipedia\" title=\"Reliability of Wikipedia\">Reliability</a></li>\n<li><a href=\"/wiki/Vandalism_on_Wikipedia\" title=\"Vandalism on Wikipedia\">Vandalism</a></li>\n<li><a href=\"/wiki/Predictions_of_the_end_of_Wikipedia\" title=\"Predictions of the end of Wikipedia\">Predictions of the project's end</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/Wikipedia_community\" title=\"Wikipedia community\">Community</a></th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wikipedia_administrators\" title=\"Wikipedia administrators\">Administrators</a></li>\n<li><a href=\"/wiki/AfroCrowd\" title=\"AfroCrowd\">AfroCrowd</a></li>\n<li><a href=\"/wiki/Arbitration_Committee\" title=\"Arbitration Committee\">Arbitration Committee</a></li>\n<li><a href=\"/wiki/Citation_needed\" title=\"Citation needed\">Citation needed</a></li>\n<li><a href=\"/wiki/Edit-a-thon\" title=\"Edit-a-thon\">Edit-a-thon</a></li>\n<li><a href=\"/wiki/Ignore_all_rules\" title=\"Ignore all rules\">\"Ignore all rules\" policy</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">List of Wikipedias</a></li>\n<li><i><a href=\"/wiki/The_Signpost\" title=\"The Signpost\">The Signpost</a></i></li>\n<li><a href=\"/wiki/Wikipedian_in_residence\" title=\"Wikipedian in residence\">Wikipedian in residence</a></li>\n<li><a href=\"/wiki/WikiConference_North_America\" title=\"WikiConference North America\">WikiConference North America</a></li>\n<li><a href=\"/wiki/Wikimania\" title=\"Wikimania\">Wikimania</a></li>\n<li><a href=\"/wiki/WikiProject\" title=\"WikiProject\">WikiProject</a></li>\n<li><a href=\"/wiki/Women_in_Red\" title=\"Women in Red\">Women in Red</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/List_of_Wikipedia_people\" title=\"List of Wikipedia people\">People</a></th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Florence_Devouard\" title=\"Florence Devouard\">Florence Devouard</a></li>\n<li><a href=\"/wiki/Sue_Gardner\" title=\"Sue Gardner\">Sue Gardner</a></li>\n<li><a href=\"/wiki/James_Heilman\" title=\"James Heilman\">James Heilman</a></li>\n<li><a href=\"/wiki/Katherine_Maher\" title=\"Katherine Maher\">Katherine Maher</a></li>\n<li><a href=\"/wiki/Magnus_Manske\" title=\"Magnus Manske\">Magnus Manske</a></li>\n<li><a href=\"/wiki/Erik_Möller\" title=\"Erik Möller\">Erik Möller</a></li>\n<li><a href=\"/wiki/Ira_Brad_Matetsky\" title=\"Ira Brad Matetsky\">Ira Brad Matetsky</a></li>\n<li><a href=\"/wiki/Larry_Sanger\" title=\"Larry Sanger\">Larry Sanger</a></li>\n<li><a href=\"/wiki/María_Sefidari\" title=\"María Sefidari\">María Sefidari</a></li>\n<li><a href=\"/wiki/Lila_Tretikov\" title=\"Lila Tretikov\">Lila Tretikov</a></li>\n<li><a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a></li>\n<li><a href=\"/wiki/Wikipedia_community\" title=\"Wikipedia community\">Wikipedians</a></li>\n<li><a href=\"/wiki/Wikimedian_of_the_Year\" title=\"Wikimedian of the Year\">Wikimedian of the Year</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/History_of_Wikipedia\" title=\"History of Wikipedia\">History</a></th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Bomis\" title=\"Bomis\">Bomis</a></li>\n<li><a href=\"/wiki/Wikipedia_logo\" title=\"Wikipedia logo\">Logo</a></li>\n<li><a href=\"/wiki/List_of_Wikipedia_controversies\" title=\"List of Wikipedia controversies\">Controversies</a>\n<ul><li><a href=\"/wiki/United_States_Congressional_staff_edits_to_Wikipedia\" title=\"United States Congressional staff edits to Wikipedia\">U.S. Congressional staff edits</a></li>\n<li><a href=\"/wiki/Essjay_controversy\" title=\"Essjay controversy\">Essjay controversy</a></li>\n<li><a href=\"/wiki/Wikipedia_Seigenthaler_biography_incident\" title=\"Wikipedia Seigenthaler biography incident\">Seigenthaler biography incident</a></li>\n<li><a href=\"/wiki/Henryk_Batuta_hoax\" title=\"Henryk Batuta hoax\">Henryk Batuta hoax</a></li>\n<li><a href=\"/wiki/Jar'Edo_Wens_hoax\" title=\"Jar'Edo Wens hoax\">Jar'Edo Wens hoax</a></li></ul></li>\n<li><a href=\"/wiki/Internet_Watch_Foundation_and_Wikipedia\" title=\"Internet Watch Foundation and Wikipedia\">Internet Watch Foundation</a></li>\n<li><a href=\"/wiki/Church_of_Scientology_editing_on_Wikipedia\" title=\"Church of Scientology editing on Wikipedia\">Scientology</a></li>\n<li><a href=\"/wiki/Italian_Wikipedia#2011_mass_blanking_protest\" title=\"Italian Wikipedia\">Italian Wikipedia blackout</a></li>\n<li><a href=\"/wiki/Protests_against_SOPA_and_PIPA#Wikimedia_community\" title=\"Protests against SOPA and PIPA\">English Wikipedia blackout</a></li>\n<li><a href=\"/wiki/Hillsborough_Wikipedia_posts\" title=\"Hillsborough Wikipedia posts\">Hillsborough Wikipedia posts</a></li>\n<li><a href=\"/wiki/MyWikiBiz\" title=\"MyWikiBiz\">MyWikiBiz</a></li>\n<li><a href=\"/wiki/Lsjbot\" title=\"Lsjbot\">Lsjbot</a></li>\n<li><a href=\"/wiki/VisualEditor\" title=\"VisualEditor\">VisualEditor</a></li>\n<li><a href=\"/wiki/Art+Feminism\" title=\"Art+Feminism\">Art+Feminism</a></li>\n<li><a href=\"/wiki/1Lib1Ref\" title=\"1Lib1Ref\">#1Lib1Ref</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Honors</th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Quadriga_(award)\" title=\"Quadriga (award)\">2008 Quadriga award</a></li>\n<li><i><a href=\"/wiki/Wikipedia_Monument\" title=\"Wikipedia Monument\">Wikipedia Monument</a></i></li>\n<li><a href=\"/wiki/Erasmus_Prize\" title=\"Erasmus Prize\">2015 Erasmus Prize</a></li>\n<li><a href=\"/wiki/Princess_of_Asturias_Awards\" title=\"Princess of Asturias Awards\">2015 Princess of Asturias Award</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">References<br>and analysis</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wikipedia_in_culture\" title=\"Wikipedia in culture\">Cultural</a></li>\n<li><a href=\"/wiki/Bibliography_of_Wikipedia\" title=\"Bibliography of Wikipedia\">Bibliography</a></li>\n<li><a href=\"/wiki/List_of_films_about_Wikipedia\" title=\"List of films about Wikipedia\">Films</a></li>\n<li><a href=\"/wiki/Academic_studies_about_Wikipedia\" title=\"Academic studies about Wikipedia\">Academic studies</a></li>\n<li><a href=\"/wiki/Listen_to_Wikipedia\" title=\"Listen to Wikipedia\">Listen to Wikipedia</a></li>\n<li><a href=\"/wiki/Wiki-Watch\" title=\"Wiki-Watch\">Wiki-Watch</a></li>\n<li><a href=\"/wiki/Wikipediocracy\" title=\"Wikipediocracy\">Wikipediocracy</a></li>\n<li><a href=\"/wiki/WikiScanner\" title=\"WikiScanner\">WikiScanner</a></li>\n<li><a href=\"/wiki/Wikipedia_Review\" title=\"Wikipedia Review\">Wikipedia Review</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Mobile access</th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedia_mobile_applications\" title=\"List of Wikipedia mobile applications\">Apps</a></li>\n<li><a href=\"/wiki/QRpedia\" title=\"QRpedia\">QRpedia</a></li>\n<li><a href=\"/wiki/Wapedia\" title=\"Wapedia\">Wapedia</a></li>\n<li><a href=\"/wiki/WikiNodes\" title=\"WikiNodes\">WikiNodes</a></li>\n<li><a href=\"/wiki/Wikipedia_Zero\" title=\"Wikipedia Zero\">Wikipedia Zero</a></li>\n<li><a href=\"/wiki/Wikiwand\" title=\"Wikiwand\">Wikiwand</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Content use</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Books_LLC\" title=\"Books LLC\">Books LLC</a></li>\n<li><a href=\"/wiki/Boundless_(company)\" title=\"Boundless (company)\">Boundless (company)</a></li>\n<li><a href=\"/wiki/DBpedia\" title=\"DBpedia\">DBpedia</a></li>\n<li><a href=\"/wiki/Deletionpedia\" title=\"Deletionpedia\">Deletionpedia</a></li>\n<li><a href=\"/wiki/Kiwix\" title=\"Kiwix\">Kiwix</a></li>\n<li><a href=\"/wiki/WikiReader\" title=\"WikiReader\">WikiReader</a></li>\n<li><a href=\"/wiki/Science_information_on_Wikipedia\" title=\"Science information on Wikipedia\">Science information</a></li>\n<li><a href=\"/wiki/Health_information_on_Wikipedia\" title=\"Health information on Wikipedia\">Health information</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Similar projects</th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Interpedia\" title=\"Interpedia\">Interpedia</a></li>\n<li><a href=\"/wiki/Nupedia\" title=\"Nupedia\">Nupedia</a></li>\n<li><a href=\"/wiki/Citizendium\" title=\"Citizendium\">Citizendium</a></li>\n<li><span style=\"font-style:normal;\"><a href=\"/wiki/Enciclopedia_Libre_Universal_en_Español\" title=\"Enciclopedia Libre Universal en Español\">Enciclopedia Libre Universal en Español</a></span></li>\n<li><a href=\"/wiki/Everipedia\" title=\"Everipedia\">Everipedia</a></li>\n<li><a href=\"/wiki/Veropedia\" title=\"Veropedia\">Veropedia</a></li>\n<li><a href=\"/wiki/List_of_online_encyclopedias\" title=\"List of online encyclopedias\">List of online encyclopedias</a></li>\n<li><a href=\"/wiki/List_of_wikis\" title=\"List of wikis\">List of wikis</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Related</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a></li>\n<li><a href=\"/wiki/Wikimedia_movement\" title=\"Wikimedia movement\">Wikimedia movement</a></li>\n<li><i><a href=\"/wiki/The_Iraq_War:_A_Historiography_of_Wikipedia_Changelogs\" title=\"The Iraq War: A Historiography of Wikipedia Changelogs\">The Iraq War: A Historiography of Wikipedia Changelogs</a></i></li>\n<li><a href=\"/wiki/Print_Wikipedia\" title=\"Print Wikipedia\">Print Wikipedia</a></li>\n<li><i><a href=\"/wiki/Magna_Carta_(An_Embroidery)\" title=\"Magna Carta (An Embroidery)\">Magna Carta (An Embroidery)</a></i></li>\n<li><a href=\"/wiki/274301_Wikipedia\" title=\"274301 Wikipedia\">274301 Wikipedia</a></li>\n<li><i><a href=\"/wiki/Viola_wikipedia\" title=\"Viola wikipedia\">Viola wikipedia</a></i></li></ul>\n</div></td></tr><tr><td class=\"navbox-abovebelow\" colspan=\"2\"><div>\n<ul><li><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/16px-Symbol_list_class.svg.png\" data-file-width=\"180\" data-file-height=\"185\" data-file-type=\"drawing\" height=\"16\" width=\"16\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/31px-Symbol_list_class.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/d/db/Symbol_list_class.svg/23px-Symbol_list_class.svg.png 1.5x\"></span></figure-inline> <a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">List</a></li>\n<li><figure-inline><span><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/16px-Folder_Hexagonal_Icon.svg.png\" data-file-width=\"36\" data-file-height=\"31\" data-file-type=\"drawing\" height=\"14\" width=\"16\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/32px-Folder_Hexagonal_Icon.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/4/48/Folder_Hexagonal_Icon.svg/24px-Folder_Hexagonal_Icon.svg.png 1.5x\"></span></figure-inline> <a href=\"/wiki/Category:Wikipedia\" title=\"Category:Wikipedia\">Category</a></li></ul>\n</div></td></tr></tbody></table></div>\n<div role=\"navigation\" class=\"navbox\" aria-labelledby=\"Wikis\" style=\"padding:3px\" about=\"#mwt3244\"><table class=\"nowraplinks mw-collapsible autocollapse navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th scope=\"col\" class=\"navbox-title\" colspan=\"2\"><div class=\"plainlinks hlist navbar mini\"><ul><li class=\"nv-view\"><a href=\"/wiki/Template:Wikis\" title=\"Template:Wikis\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">v</abbr></a></li><li class=\"nv-talk\"><a href=\"/wiki/Template_talk:Wikis\" title=\"Template talk:Wikis\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">t</abbr></a></li><li class=\"nv-edit\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Template:Wikis&amp;action=edit\" class=\"external text\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">e</abbr></a></li></ul></div><div id=\"Wikis\" style=\"font-size:114%;margin:0 4em\"><a href=\"/wiki/Wiki\" title=\"Wiki\">Wikis</a></div></th></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Types</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Personal_wiki\" title=\"Personal wiki\">Personal</a></li>\n<li><a href=\"/wiki/List_of_medical_wikis\" title=\"List of medical wikis\">Medical</a></li>\n<li><a href=\"/wiki/Semantic_wiki\" title=\"Semantic wiki\">Semantic</a></li>\n<li><a href=\"/wiki/Wiki_hosting_service\" title=\"Wiki hosting service\">Wiki farm</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Components</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wiki_software\" title=\"Wiki software\">Software</a></li>\n<li><a href=\"/wiki/Interwiki_links\" title=\"Interwiki links\">Interwiki links</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Lists</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_wikis\" title=\"List of wikis\">Wikis</a></li>\n<li><a href=\"/wiki/List_of_wiki_software\" title=\"List of wiki software\">Software</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Comparisons</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Comparison_of_wiki_software\" title=\"Comparison of wiki software\">Software</a></li>\n<li><a href=\"/wiki/Comparison_of_wiki_hosting_services\" title=\"Comparison of wiki hosting services\">Wiki farms</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">See also</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/History_of_wikis\" title=\"History of wikis\">History</a></li>\n<li><a href=\"/wiki/Creole_(markup)\" title=\"Creole (markup)\">Creole</a></li></ul>\n</div></td></tr></tbody></table></div>\n<div role=\"navigation\" class=\"navbox\" aria-labelledby=\"Wikimedia_Foundation\" style=\"padding:3px\" about=\"#mwt3245\"><table class=\"nowraplinks hlist mw-collapsible autocollapse navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th scope=\"col\" class=\"navbox-title\" colspan=\"2\"><div class=\"plainlinks hlist navbar mini\"><ul><li class=\"nv-view\"><a href=\"/wiki/Template:Wikimedia_Foundation\" title=\"Template:Wikimedia Foundation\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">v</abbr></a></li><li class=\"nv-talk\"><a href=\"/wiki/Template_talk:Wikimedia_Foundation\" title=\"Template talk:Wikimedia Foundation\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">t</abbr></a></li><li class=\"nv-edit\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Template:Wikimedia_Foundation&amp;action=edit\" class=\"external text\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">e</abbr></a></li></ul></div><div id=\"Wikimedia_Foundation\" style=\"font-size:114%;margin:0 4em\"><a href=\"/wiki/Wikimedia_Foundation\" title=\"Wikimedia Foundation\">Wikimedia Foundation</a></div></th></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">People</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\"></div><table class=\"nowraplinks navbox-subgroup\" style=\"border-spacing:0\"><tbody><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Current</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Aaron_Halfaker\" title=\"Aaron Halfaker\">Aaron Halfaker</a></li>\n<li><a href=\"/wiki/James_Heilman\" title=\"James Heilman\">James Heilman</a></li>\n<li><a href=\"/wiki/Dariusz_Jemielniak\" title=\"Dariusz Jemielniak\">Dariusz Jemielniak</a></li>\n<li><a href=\"/wiki/Katherine_Maher\" title=\"Katherine Maher\">Katherine Maher</a></li>\n<li><a href=\"/wiki/Jimmy_Wales\" title=\"Jimmy Wales\">Jimmy Wales</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Past</th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Hampton_Catlin\" title=\"Hampton Catlin\">Hampton Catlin</a></li>\n<li><a href=\"/wiki/Danese_Cooper\" title=\"Danese Cooper\">Danese Cooper</a></li>\n<li><a href=\"/wiki/Bishakha_Datta\" title=\"Bishakha Datta\">Bishakha Datta</a></li>\n<li><a href=\"/wiki/Florence_Devouard\" title=\"Florence Devouard\">Florence Devouard</a></li>\n<li><a href=\"/wiki/Oscar_van_Dillen\" title=\"Oscar van Dillen\">Oscar van Dillen</a></li>\n<li><a href=\"/wiki/Sue_Gardner\" title=\"Sue Gardner\">Sue Gardner</a></li>\n<li><a href=\"/wiki/Arnnon_Geshuri\" title=\"Arnnon Geshuri\">Arnnon Geshuri</a></li>\n<li><a href=\"/wiki/Mike_Godwin\" title=\"Mike Godwin\">Mike Godwin</a></li>\n<li><a href=\"/wiki/Guy_Kawasaki\" title=\"Guy Kawasaki\">Guy Kawasaki</a></li>\n<li><a href=\"/wiki/Erik_Möller\" title=\"Erik Möller\">Erik Möller</a></li>\n<li><a href=\"/wiki/Lila_Tretikov\" title=\"Lila Tretikov\">Lila Tretikov</a></li>\n<li><a href=\"/wiki/Luis_Villa\" title=\"Luis Villa\">Luis Villa</a></li>\n<li><a href=\"/wiki/Patricio_Lorente\" title=\"Patricio Lorente\">Patricio Lorente</a></li></ul>\n</div></td></tr></tbody></table><div></div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/Wikimedia_project\" title=\"Wikimedia project\" class=\"mw-redirect\">Content projects</a></th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wikipedia\" title=\"Wikipedia\">Wikipedia</a>\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">List of Wikipedias</a></li></ul></li>\n<li><a href=\"/wiki/Wiktionary\" title=\"Wiktionary\">Wiktionary</a>\n<ul><li><a href=\"/wiki/List_of_Wiktionaries\" title=\"List of Wiktionaries\">List of Wiktionaries</a></li></ul></li>\n<li><a href=\"/wiki/Wikimedia_Commons\" title=\"Wikimedia Commons\">Wikimedia Commons</a></li>\n<li><a href=\"/wiki/Wikidata\" title=\"Wikidata\">Wikidata</a></li>\n<li><a href=\"/wiki/Wikiquote\" title=\"Wikiquote\">Wikiquote</a></li>\n<li><a href=\"/wiki/Wikibooks\" title=\"Wikibooks\">Wikibooks</a></li>\n<li><a href=\"/wiki/Wikisource\" title=\"Wikisource\">Wikisource</a></li>\n<li><a href=\"/wiki/Wikispecies\" title=\"Wikispecies\">Wikispecies</a></li>\n<li><a href=\"/wiki/Wikinews\" title=\"Wikinews\">Wikinews</a></li>\n<li><a href=\"/wiki/Wikiversity\" title=\"Wikiversity\">Wikiversity</a></li>\n<li><a href=\"/wiki/Wikivoyage\" title=\"Wikivoyage\">Wikivoyage</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Other</th><td class=\"navbox-list navbox-even\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Wikimedia_movement\" title=\"Wikimedia movement\">Wikimedia movement</a>\n<ul><li><a href=\"/wiki/List_of_Wikimedia_chapters\" title=\"List of Wikimedia chapters\">List of Wikimedia chapters</a></li></ul></li>\n<li><a href=\"/wiki/Wikimania\" title=\"Wikimania\">Wikimania</a></li>\n<li><a href=\"/wiki/Wiki_Indaba\" title=\"Wiki Indaba\">Wiki Indaba</a></li>\n<li><a href=\"/wiki/MediaWiki\" title=\"MediaWiki\">MediaWiki</a></li>\n<li><a href=\"/wiki/Litigation_involving_the_Wikimedia_Foundation\" title=\"Litigation involving the Wikimedia Foundation\">Litigation</a>\n<ul><li><i><a href=\"/wiki/Wikimedia_Foundation_v._NSA\" title=\"Wikimedia Foundation v. NSA\">Wikimedia v. NSA</a></i></li></ul></li>\n<li><a href=\"/wiki/Knowledge_Engine_(Wikimedia_Foundation)\" title=\"Knowledge Engine (Wikimedia Foundation)\">Knowledge Engine</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">Related</th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><i><a href=\"/wiki/The_Signpost\" title=\"The Signpost\">The Signpost</a></i></li>\n<li><i><a href=\"/wiki/Wikipedia_Monument\" title=\"Wikipedia Monument\">Wikipedia Monument</a></i></li></ul>\n</div></td></tr></tbody></table></div>\n<div role=\"navigation\" class=\"navbox\" aria-labelledby=\"List_of_Wikipedias_by_article_count\" style=\"padding:3px\" about=\"#mwt3246\"><table class=\"nowraplinks mw-collapsible autocollapse navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th scope=\"col\" class=\"navbox-title\" colspan=\"2\"><div class=\"plainlinks hlist navbar mini\"><ul><li class=\"nv-view\"><a href=\"/wiki/Template:Wikipedias\" title=\"Template:Wikipedias\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">v</abbr></a></li><li class=\"nv-talk\"><a href=\"/wiki/Template_talk:Wikipedias\" title=\"Template talk:Wikipedias\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">t</abbr></a></li><li class=\"nv-edit\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Template:Wikipedias&amp;action=edit\" class=\"external text\"><abbr style=\";;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">e</abbr></a></li></ul></div><div id=\"List_of_Wikipedias_by_article_count\" style=\"font-size:114%;margin:0 4em\"><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">List of Wikipedias</a> by article count</div></th></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">6,000,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><b><a href=\"/wiki/English_Wikipedia\" title=\"English Wikipedia\">English</a></b></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">5,000,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Cebuano_Wikipedia\" title=\"Cebuano Wikipedia\" class=\"mw-redirect\">Cebuano</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">3,000,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Swedish_Wikipedia\" title=\"Swedish Wikipedia\">Swedish</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">2,000,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/German_Wikipedia\" title=\"German Wikipedia\">German</a></li>\n<li><a href=\"/wiki/French_Wikipedia\" title=\"French Wikipedia\">French</a></li>\n<li><a href=\"/wiki/Dutch_Wikipedia\" title=\"Dutch Wikipedia\">Dutch</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">1,000,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Russian_Wikipedia\" title=\"Russian Wikipedia\">Russian</a></li>\n<li><a href=\"/wiki/Italian_Wikipedia\" title=\"Italian Wikipedia\">Italian</a></li>\n<li><a href=\"/wiki/Spanish_Wikipedia\" title=\"Spanish Wikipedia\">Spanish</a></li>\n<li><a href=\"/wiki/Polish_Wikipedia\" title=\"Polish Wikipedia\">Polish</a></li>\n<li><a href=\"/wiki/Waray_Wikipedia\" title=\"Waray Wikipedia\">Waray</a></li>\n<li><a href=\"/wiki/Vietnamese_Wikipedia\" title=\"Vietnamese Wikipedia\">Vietnamese</a></li>\n<li><a href=\"/wiki/Japanese_Wikipedia\" title=\"Japanese Wikipedia\">Japanese</a></li>\n<li><a href=\"/wiki/Chinese_Wikipedia\" title=\"Chinese Wikipedia\">Chinese</a></li>\n<li><a href=\"/wiki/Arabic_Wikipedia\" title=\"Arabic Wikipedia\">Arabic</a></li>\n<li><a href=\"/wiki/Portuguese_Wikipedia\" title=\"Portuguese Wikipedia\">Portuguese</a></li>\n<li><a href=\"/wiki/Ukrainian_Wikipedia\" title=\"Ukrainian Wikipedia\">Ukrainian</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">500,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Persian_Wikipedia\" title=\"Persian Wikipedia\">Persian</a></li>\n<li><a href=\"/wiki/Catalan_Wikipedia\" title=\"Catalan Wikipedia\">Catalan</a></li>\n<li><a href=\"/wiki/Serbian_Wikipedia\" title=\"Serbian Wikipedia\">Serbian</a></li>\n<li><a href=\"/wiki/Norwegian_Wikipedia\" title=\"Norwegian Wikipedia\">Norwegian (bokmål/riksmål)</a></li>\n<li><a href=\"/wiki/Indonesian_Wikipedia\" title=\"Indonesian Wikipedia\">Indonesian</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">200,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Korean_Wikipedia\" title=\"Korean Wikipedia\">Korean</a></li>\n<li><a href=\"/wiki/Finnish_Wikipedia\" title=\"Finnish Wikipedia\">Finnish</a></li>\n<li><a href=\"/wiki/Hungarian_Wikipedia\" title=\"Hungarian Wikipedia\">Hungarian</a></li>\n<li><a href=\"/wiki/Serbo-Croatian_Wikipedia\" title=\"Serbo-Croatian Wikipedia\">Serbo-Croatian</a></li>\n<li><a href=\"/wiki/Czech_Wikipedia\" title=\"Czech Wikipedia\">Czech</a></li>\n<li><a href=\"/wiki/Romanian_Wikipedia\" title=\"Romanian Wikipedia\">Romanian</a></li>\n<li><a href=\"/wiki/Southern_Min_Wikipedia\" title=\"Southern Min Wikipedia\">Southern Min</a></li>\n<li><a href=\"/wiki/Basque_Wikipedia\" title=\"Basque Wikipedia\">Basque</a></li>\n<li><a href=\"/wiki/Turkish_Wikipedia\" title=\"Turkish Wikipedia\">Turkish</a></li>\n<li><a href=\"/wiki/Malay_Wikipedia\" title=\"Malay Wikipedia\">Malay</a></li>\n<li><a href=\"/wiki/Egyptian_Arabic_Wikipedia\" title=\"Egyptian Arabic Wikipedia\">Egyptian Arabic</a></li>\n<li><a href=\"/wiki/Esperanto_Wikipedia\" title=\"Esperanto Wikipedia\">Esperanto</a></li>\n<li><a href=\"/wiki/Armenian_Wikipedia\" title=\"Armenian Wikipedia\">Armenian</a></li>\n<li><a href=\"/wiki/Hebrew_Wikipedia\" title=\"Hebrew Wikipedia\">Hebrew</a></li>\n<li><a href=\"/wiki/Bulgarian_Wikipedia\" title=\"Bulgarian Wikipedia\">Bulgarian</a></li>\n<li><a href=\"/wiki/Danish_Wikipedia\" title=\"Danish Wikipedia\">Danish</a></li>\n<li><a href=\"/wiki/Chechen_Wikipedia\" title=\"Chechen Wikipedia\" class=\"mw-redirect\">Chechen</a></li>\n<li><a href=\"/wiki/Southern_Azerbaijani_Wikipedia\" title=\"Southern Azerbaijani Wikipedia\" class=\"mw-redirect\">Southern Azerbaijani</a></li>\n<li><a href=\"/wiki/Slovak_Wikipedia\" title=\"Slovak Wikipedia\">Slovak</a></li>\n<li><a href=\"/wiki/Kazakh_Wikipedia\" title=\"Kazakh Wikipedia\">Kazakh</a></li>\n<li><a href=\"/wiki/Minangkabau_Wikipedia\" title=\"Minangkabau Wikipedia\">Minangkabau</a></li>\n<li><a href=\"/wiki/Croatian_Wikipedia\" title=\"Croatian Wikipedia\">Croatian</a></li>\n<li><a href=\"/wiki/Estonian_Wikipedia\" title=\"Estonian Wikipedia\">Estonian</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">100,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Lithuanian_Wikipedia\" title=\"Lithuanian Wikipedia\">Lithuanian</a></li>\n<li><a href=\"/wiki/Belarusian_Wikipedia\" title=\"Belarusian Wikipedia\">Belarusian</a></li>\n<li><a href=\"/wiki/Greek_Wikipedia\" title=\"Greek Wikipedia\">Greek</a></li>\n<li><a href=\"/wiki/Slovene_Wikipedia\" title=\"Slovene Wikipedia\">Slovene</a></li>\n<li><a href=\"/wiki/Galician_Wikipedia\" title=\"Galician Wikipedia\" class=\"mw-redirect\">Galician</a></li>\n<li><a href=\"/wiki/Simple_English_Wikipedia\" title=\"Simple English Wikipedia\">Simple English</a></li>\n<li><a href=\"/wiki/Azerbaijani_Wikipedia\" title=\"Azerbaijani Wikipedia\">Azerbaijani</a></li>\n<li><a href=\"/wiki/Urdu_Wikipedia\" title=\"Urdu Wikipedia\">Urdu</a></li>\n<li><a href=\"/wiki/Norwegian_Wikipedia\" title=\"Norwegian Wikipedia\">Norwegian (nynorsk)</a></li>\n<li><a href=\"/wiki/Hindi_Wikipedia\" title=\"Hindi Wikipedia\">Hindi</a></li>\n<li><a href=\"/wiki/Thai_Wikipedia\" title=\"Thai Wikipedia\">Thai</a></li>\n<li><a href=\"/wiki/Georgian_Wikipedia\" title=\"Georgian Wikipedia\">Georgian</a></li>\n<li><a href=\"/wiki/Uzbek_Wikipedia\" title=\"Uzbek Wikipedia\">Uzbek</a></li>\n<li><a href=\"/wiki/Latin_Wikipedia\" title=\"Latin Wikipedia\">Latin</a></li>\n<li><a href=\"/wiki/Tamil_Wikipedia\" title=\"Tamil Wikipedia\">Tamil</a></li>\n<li><a href=\"/wiki/Volapük_Wikipedia\" title=\"Volapük Wikipedia\">Volapük</a></li>\n<li><a href=\"/wiki/Welsh_Wikipedia\" title=\"Welsh Wikipedia\">Welsh</a></li>\n<li><a href=\"/wiki/Macedonian_Wikipedia\" title=\"Macedonian Wikipedia\">Macedonian</a></li>\n<li><a href=\"/wiki/Asturian_Wikipedia\" title=\"Asturian Wikipedia\">Asturian</a></li>\n<li><a href=\"/wiki/Latvian_Wikipedia\" title=\"Latvian Wikipedia\">Latvian</a></li>\n<li><a href=\"/wiki/Tajik_Wikipedia\" title=\"Tajik Wikipedia\" class=\"mw-redirect\">Tajik</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">50,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Malagasy_Wikipedia\" title=\"Malagasy Wikipedia\">Malagasy</a></li>\n<li><a href=\"/wiki/Afrikaans_Wikipedia\" title=\"Afrikaans Wikipedia\">Afrikaans</a></li>\n<li><a href=\"/wiki/Tatar_Wikipedia\" title=\"Tatar Wikipedia\">Tatar</a></li>\n<li><a href=\"/wiki/Occitan_Wikipedia\" title=\"Occitan Wikipedia\">Occitan</a></li>\n<li><a href=\"/wiki/Bengali_Wikipedia\" title=\"Bengali Wikipedia\">Bengali</a></li>\n<li><a href=\"/wiki/Bosnian_Wikipedia\" title=\"Bosnian Wikipedia\">Bosnian</a></li>\n<li><a href=\"/wiki/Cantonese_Wikipedia\" title=\"Cantonese Wikipedia\">Cantonese</a></li>\n<li><a href=\"/wiki/Kyrgyz_Wikipedia\" title=\"Kyrgyz Wikipedia\">Kyrgyz</a></li>\n<li><a href=\"/wiki/Albanian_Wikipedia\" title=\"Albanian Wikipedia\">Albanian</a></li>\n<li><a href=\"/wiki/Nepal_Bhasa_Wikipedia\" title=\"Nepal Bhasa Wikipedia\">Newar</a></li>\n<li><a href=\"/wiki/Tagalog_Wikipedia\" title=\"Tagalog Wikipedia\">Tagalog</a></li>\n<li><a href=\"/wiki/Telugu_Wikipedia\" title=\"Telugu Wikipedia\">Telugu</a></li>\n<li><a href=\"/wiki/Belarusian_Wikipedia\" title=\"Belarusian Wikipedia\">Belarusian (Taraškievica)</a></li>\n<li><a href=\"/wiki/Malayalam_Wikipedia\" title=\"Malayalam Wikipedia\">Malayalam</a></li>\n<li><a href=\"/wiki/Breton_Wikipedia\" title=\"Breton Wikipedia\">Breton</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Piedmontese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Low Saxon</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sundanese</a></li>\n<li><a href=\"/wiki/Swahili_Wikipedia\" title=\"Swahili Wikipedia\">Swahili</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Haitian</a></li>\n<li><a href=\"/wiki/Luxembourgish_Wikipedia\" title=\"Luxembourgish Wikipedia\">Luxembourgish</a></li>\n<li><a href=\"/wiki/Javanese_Wikipedia\" title=\"Javanese Wikipedia\">Javanese</a></li>\n<li><a href=\"/wiki/Scots_Wikipedia\" title=\"Scots Wikipedia\">Scots</a></li>\n<li><a href=\"/wiki/Marathi_Wikipedia\" title=\"Marathi Wikipedia\">Marathi</a></li>\n<li><a href=\"/wiki/Punjabi_Wikipedia\" title=\"Punjabi Wikipedia\">Western Punjabi</a></li>\n<li><a href=\"/wiki/Irish_Wikipedia\" title=\"Irish Wikipedia\">Irish</a></li>\n<li><a href=\"/wiki/Silesian_Wikipedia\" title=\"Silesian Wikipedia\">Silesian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Bashkir</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">20,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Icelandic_Wikipedia\" title=\"Icelandic Wikipedia\" class=\"mw-redirect\">Icelandic</a></li>\n<li><a href=\"/wiki/Burmese_Wikipedia\" title=\"Burmese Wikipedia\">Burmese</a></li>\n<li><a href=\"/wiki/West_Frisian_Wikipedia\" title=\"West Frisian Wikipedia\" class=\"mw-redirect\">West Frisian</a></li>\n<li><a href=\"/wiki/Chuvash_Wikipedia\" title=\"Chuvash Wikipedia\">Chuvash</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lombard</a></li>\n<li><a href=\"/wiki/Aragonese_Wikipedia\" title=\"Aragonese Wikipedia\">Aragonese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Nepali</a></li>\n<li><a href=\"/wiki/Punjabi_Wikipedia\" title=\"Punjabi Wikipedia\">Punjabi</a></li>\n<li><a href=\"/wiki/Yoruba_Wikipedia\" title=\"Yoruba Wikipedia\" class=\"mw-redirect\">Yoruba</a></li>\n<li><a href=\"/wiki/Bavarian_Wikipedia\" title=\"Bavarian Wikipedia\" class=\"mw-redirect\">Bavarian</a></li>\n<li><a href=\"/wiki/Wu_Wikipedia\" title=\"Wu Wikipedia\" class=\"mw-redirect\">Wu</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Ido</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Gujarati</a></li>\n<li><a href=\"/wiki/Kurdish_(Kurmanji)_Wikipedia\" title=\"Kurdish (Kurmanji) Wikipedia\" class=\"mw-redirect\">Kurdish (Kurmanji)</a></li>\n<li><a href=\"/wiki/Alemannic_Wikipedia\" title=\"Alemannic Wikipedia\">Alemannic</a></li>\n<li><a href=\"/wiki/Sicilian_Wikipedia\" title=\"Sicilian Wikipedia\">Sicilian</a></li>\n<li><a href=\"/wiki/Kannada_Wikipedia\" title=\"Kannada Wikipedia\">Kannada</a></li>\n<li><a href=\"/wiki/Kurdish_(Sorani)_Wikipedia\" title=\"Kurdish (Sorani) Wikipedia\" class=\"mw-redirect\">Kurdish (Sorani)</a></li>\n<li><a href=\"/wiki/Bishnupriya_Manipuri_Wikipedia\" title=\"Bishnupriya Manipuri Wikipedia\" class=\"mw-redirect\">Bishnupriya Manipuri</a></li>\n<li><a href=\"/wiki/Venetian_Wikipedia\" title=\"Venetian Wikipedia\" class=\"mw-redirect\">Venetian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Interlingua</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Quechua</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">10,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Mongolian_Wikipedia\" title=\"Mongolian Wikipedia\">Mongolian</a></li>\n<li><a href=\"/wiki/Samogitian_Wikipedia\" title=\"Samogitian Wikipedia\">Samogitian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Walloon</a></li>\n<li><a href=\"/wiki/Odia_Wikipedia\" title=\"Odia Wikipedia\">Odia</a></li>\n<li><a href=\"/wiki/Sinhalese_Wikipedia\" title=\"Sinhalese Wikipedia\" class=\"mw-redirect\">Sinhalese</a></li>\n<li><a href=\"/wiki/Eastern_Min_Wikipedia\" title=\"Eastern Min Wikipedia\" class=\"mw-redirect\">Eastern Min</a></li>\n<li><a href=\"/wiki/Scottish_Gaelic_Wikipedia\" title=\"Scottish Gaelic Wikipedia\">Scottish Gaelic</a></li>\n<li><a href=\"/wiki/Yiddish_Wikipedia\" title=\"Yiddish Wikipedia\">Yiddish</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Amharic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Neapolitan</a></li>\n<li><a href=\"/wiki/Ilocano_Wikipedia\" title=\"Ilocano Wikipedia\" class=\"mw-redirect\">Ilokano</a></li>\n<li><a href=\"/wiki/Buginese_Wikipedia\" title=\"Buginese Wikipedia\">Buginese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Zazaki</a></li>\n<li><a href=\"/wiki/Megrelian_Wikipedia\" title=\"Megrelian Wikipedia\">Mingrelian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Upper Sorbian</a></li>\n<li><a href=\"/wiki/Maithili_Wikipedia\" title=\"Maithili Wikipedia\">Maithili</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Navajo</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Banyumasan</a></li>\n<li><a href=\"/wiki/Faroese_Wikipedia\" title=\"Faroese Wikipedia\" class=\"mw-redirect\">Faroese</a></li>\n<li><a href=\"/wiki/Sindhi_Wikipedia\" title=\"Sindhi Wikipedia\">Sindhi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Mazandarani</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Limburgish</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Emilian-Romagnol</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sakha</a></li>\n<li><a href=\"/wiki/Ossetian_Wikipedia\" title=\"Ossetian Wikipedia\">Ossetian</a></li>\n<li><a href=\"/wiki/Sanskrit_Wikipedia\" title=\"Sanskrit Wikipedia\">Sanskrit</a></li>\n<li><a href=\"/wiki/Pashto_Wikipedia\" title=\"Pashto Wikipedia\">Pashto</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">North Frisian</a></li>\n<li><a href=\"/wiki/Acehnese_Wikipedia\" title=\"Acehnese Wikipedia\" class=\"mw-redirect\">Acehnese</a></li>\n<li><a href=\"/wiki/Hill_Mari_Wikipedia\" title=\"Hill Mari Wikipedia\" class=\"mw-redirect\">Hill Mari</a></li>\n<li><a href=\"/wiki/Central_Bicolano_Wikipedia\" title=\"Central Bicolano Wikipedia\" class=\"mw-redirect\">Central Bicolano</a></li>\n<li><a href=\"/wiki/Classical_Chinese_Wikipedia\" title=\"Classical Chinese Wikipedia\" class=\"mw-redirect\">Classical Chinese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Meadow Mari</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">5,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/Fiji_Hindi_Wikipedia\" title=\"Fiji Hindi Wikipedia\" class=\"mw-redirect\">Fiji Hindi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Hakka</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tarantino</a></li>\n<li><a href=\"/wiki/Kapampangan_Wikipedia\" title=\"Kapampangan Wikipedia\">Kapampangan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Northern Sotho</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Khmer</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">West Armenian</a></li>\n<li><a href=\"/wiki/Northern_Sami_Wikipedia\" title=\"Northern Sami Wikipedia\">Northern Sami</a></li>\n<li><a href=\"/wiki/Rusyn_Wikipedia\" title=\"Rusyn Wikipedia\" class=\"mw-redirect\">Rusyn</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Maori</a></li>\n<li><a href=\"/wiki/Crimean_Tatar_Wikipedia\" title=\"Crimean Tatar Wikipedia\">Crimean Tatar</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">West Flemish</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Bihari</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Shan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Nahuatl</a></li>\n<li><a href=\"/wiki/Dutch_Low_Saxon_Wikipedia\" title=\"Dutch Low Saxon Wikipedia\">Dutch Low Saxon</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sardinian</a></li>\n<li><a href=\"/wiki/Assamese_Wikipedia\" title=\"Assamese Wikipedia\">Assamese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Vepsian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Gan</a></li>\n<li><a href=\"/wiki/Abkhazian_Wikipedia\" title=\"Abkhazian Wikipedia\" class=\"mw-redirect\">Abkhazian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Gilaki</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Erzya</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tibetan</a></li>\n<li><a href=\"/wiki/Corsican_Wikipedia\" title=\"Corsican Wikipedia\" class=\"mw-redirect\">Corsican</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Somali</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Turkmen</a></li>\n<li><a href=\"/wiki/Võro_Wikipedia\" title=\"Võro Wikipedia\" class=\"mw-redirect\">Võro</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Northern Luri</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Komi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kashubian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Shona</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Manx</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">2,000+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Udmurt</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Interlingue</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Hausa</a></li>\n<li><a href=\"/wiki/Gorontalo_Wikipedia\" title=\"Gorontalo Wikipedia\" class=\"mw-redirect\">Gorontalo</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Zeelandic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Picardi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Aymara</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kabyle</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Norman</a></li>\n<li><a href=\"/wiki/Uyghur_Wikipedia\" title=\"Uyghur Wikipedia\">Uyghur</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lezgian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Saterland Frisian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Cornish</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Hawaiian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lingua Franca Nova</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Mirandese</a></li>\n<li><a href=\"/wiki/Guarani_Wikipedia\" title=\"Guarani Wikipedia\">Guarani</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Ligurian</a></li>\n<li><a href=\"/wiki/Konkani_Wikipedia\" title=\"Konkani Wikipedia\">Konkani</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Romansh</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lao</a></li>\n<li><a href=\"/wiki/Judaeo-Spanish_Wikipedia\" title=\"Judaeo-Spanish Wikipedia\">Ladino</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Franco-Provençal</a></li>\n<li><a href=\"/wiki/Divehi_Wikipedia\" title=\"Divehi Wikipedia\" class=\"mw-redirect\">Divehi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Maltese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Komi-Permyak</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Friulian</a></li>\n<li><a href=\"/wiki/Livvi-Karelian_Wikipedia\" title=\"Livvi-Karelian Wikipedia\" class=\"mw-redirect\">Livvi-Karelian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lower Sorbian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Doteli</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Anglo-Saxon</a></li>\n<li><a href=\"/wiki/Extremaduran_Wikipedia\" title=\"Extremaduran Wikipedia\">Extremaduran</a></li>\n<li><a href=\"/wiki/Chavacano_Wikipedia\" title=\"Chavacano Wikipedia\">Chavacano</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lingala</a></li>\n<li><a href=\"/wiki/Santali_Wikipedia\" title=\"Santali Wikipedia\">Santali</a></li>\n<li><a href=\"/wiki/Ripuarian_Wikipedia\" title=\"Ripuarian Wikipedia\">Ripuarian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Gagauz</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Palatinate German</a></li>\n<li><a href=\"/wiki/Pali_Wikipedia\" title=\"Pali Wikipedia\" class=\"mw-redirect\">Pali</a></li>\n<li><a href=\"/wiki/Pangasinan_Wikipedia\" title=\"Pangasinan Wikipedia\">Pangasinan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Balinese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Avar</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Buryat</a></li>\n<li><a href=\"/wiki/Tuvan_Wikipedia\" title=\"Tuvan Wikipedia\" class=\"mw-redirect\">Tuvan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kalmyk</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Karachay-Balkar</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">1,000+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Papiamentu</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Zhuang</a></li>\n<li><a href=\"/wiki/Karakalpak_Wikipedia\" title=\"Karakalpak Wikipedia\" class=\"mw-redirect\">Karakalpak</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Pennsylvania German</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kinyarwanda</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sakizaya</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tongan</a></li>\n<li><a href=\"/wiki/Aramaic_Wikipedia\" title=\"Aramaic Wikipedia\" class=\"mw-redirect\">Aramaic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Novial</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Greenlandic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Jamaican Patios</a></li>\n<li><a href=\"/wiki/Tok_Pisin_Wikipedia\" title=\"Tok Pisin Wikipedia\" class=\"mw-redirect\">Tok Pisin</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kabiye</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kabardian Circassian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Nauruan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tetum</a></li>\n<li><a href=\"/wiki/Igbo_Wikipedia\" title=\"Igbo Wikipedia\" class=\"mw-redirect\">Igbo</a></li>\n<li><a href=\"/wiki/Zulu_Wikipedia\" title=\"Zulu Wikipedia\">Zulu</a></li>\n<li><a href=\"/wiki/Wolof_Wikipedia\" title=\"Wolof Wikipedia\">Wolof</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kikuyu</a></li>\n<li><a href=\"/wiki/Tulu_Wikipedia\" title=\"Tulu Wikipedia\">Tulu</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Ingush</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lojban</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Aromanian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Bislama</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Lak</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kongo</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tahitian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Moksha</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Luganda</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Atikamekw</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sranan</a></li>\n<li><a href=\"/wiki/Xhosa_Wikipedia\" title=\"Xhosa Wikipedia\">Xhosa</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Guianan Creole</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">500+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Samoan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Latgalian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Fijian</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Cherokee</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Gothic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Akan</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Norfolk</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Oromo</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tswana</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Old Church Slavonic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Twi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sesotho</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tsonga</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Romani</a></li>\n<li><a href=\"/wiki/Bambara_Wikipedia\" title=\"Bambara Wikipedia\">Bambara</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Cheyenne</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kirundi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tumbuka</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Chamorro</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">N’Ko</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Chichewa</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Mon</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Swati</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">200+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Pontic</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Adyghe</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Inuktitut</a></li>\n<li><a href=\"/wiki/Kashmiri_Wikipedia\" title=\"Kashmiri Wikipedia\" class=\"mw-redirect\">Kashmiri</a></li>\n<li><a href=\"/wiki/Venda_Wikipedia\" title=\"Venda Wikipedia\" class=\"mw-redirect\">Venda</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Ewe</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Inupiak</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sango</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Fula</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Tigrinya</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Dzongkha</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">100+</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Dinka</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Cree</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"width:1%\">0+</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Ndonga</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Choctaw</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kuanyama</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Marshallese</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Hiri Motu</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Sichuan Yi</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Afar</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Muscogee</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Herero</a></li>\n<li><a href=\"/wiki/List_of_Wikipedias\" title=\"List of Wikipedias\">Kanuri</a></li></ul>\n</div></td></tr></tbody></table></div>\n<div role=\"navigation\" class=\"navbox\" aria-labelledby=\"Laureates_of_the_Prince/Princess_of_Asturias_Award_for_International_Cooperation\" style=\"padding:3px\" about=\"#mwt3247\"><table class=\"nowraplinks mw-collapsible autocollapse navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th scope=\"col\" class=\"navbox-title\" colspan=\"3\" style=\"background:#99d6ff;\"><div class=\"plainlinks hlist navbar mini\"><ul><li class=\"nv-view\"><a href=\"/wiki/Template:Princess_of_Asturias_Award_for_International_Cooperation\" title=\"Template:Princess of Asturias Award for International Cooperation\"><abbr style=\"background:#99d6ff;;;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">v</abbr></a></li><li class=\"nv-talk\"><span class=\"new\"><abbr style=\"background:#99d6ff;;;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">t</abbr></span></li><li class=\"nv-edit\"><a rel=\"mw:ExtLink\" href=\"//en.wikipedia.org/w/index.php?title=Template:Princess_of_Asturias_Award_for_International_Cooperation&amp;action=edit\" class=\"external text\"><abbr style=\"background:#99d6ff;;;background:none transparent;border:none;-moz-box-shadow:none;-webkit-box-shadow:none;box-shadow:none; padding:0;\">e</abbr></a></li></ul></div><div id=\"Laureates_of_the_Prince/Princess_of_Asturias_Award_for_International_Cooperation\" style=\"font-size:114%;margin:0 4em\">Laureates of the <a href=\"/wiki/Princess_of_Asturias_Awards\" title=\"Princess of Asturias Awards\">Prince/Princess of Asturias Award</a> for International Cooperation</div></th></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"background:#99d6ff;;width:1%\">1980s</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li>1981: <a href=\"/wiki/José_López_Portillo\" title=\"José López Portillo\">José López Portillo</a></li>\n<li>1982: <a href=\"/wiki/Enrique_V._Iglesias\" title=\"Enrique V. Iglesias\">Enrique V. Iglesias</a></li>\n<li>1983: <a href=\"/wiki/Belisario_Betancur\" title=\"Belisario Betancur\">Belisario Betancur</a></li>\n<li>1984: <a href=\"/wiki/Contadora_group\" title=\"Contadora group\">Contadora group</a></li>\n<li>1985: <a href=\"/wiki/Raúl_Alfonsín\" title=\"Raúl Alfonsín\">Raúl Alfonsín</a></li>\n<li>1986: <a href=\"/wiki/University_of_Salamanca\" title=\"University of Salamanca\">University of Salamanca</a> and <a href=\"/wiki/University_of_Coimbra\" title=\"University of Coimbra\">University of Coimbra</a></li>\n<li>1987: <a href=\"/wiki/Javier_Pérez_de_Cuéllar\" title=\"Javier Pérez de Cuéllar\">Javier Pérez de Cuéllar</a></li>\n<li>1988: <a href=\"/wiki/Óscar_Arias\" title=\"Óscar Arias\">Óscar Arias</a></li>\n<li>1989: <a href=\"/wiki/Jacques_Delors\" title=\"Jacques Delors\">Jacques Delors</a> and <a href=\"/wiki/Mikhail_Gorbachev\" title=\"Mikhail Gorbachev\">Mikhail Gorbachev</a></li></ul>\n</div></td><td class=\"navbox-image\" rowspan=\"4\" style=\"width:1px;padding:0px 0px 0px 2px\"><div><figure-inline><a href=\"/wiki/File:Princess_of_Asturias_Foundation_Emblem.svg\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/70/Princess_of_Asturias_Foundation_Emblem.svg/50px-Princess_of_Asturias_Foundation_Emblem.svg.png\" data-file-width=\"952\" data-file-height=\"1296\" data-file-type=\"drawing\" height=\"68\" width=\"50\" srcset=\"//upload.wikimedia.org/wikipedia/commons/thumb/7/70/Princess_of_Asturias_Foundation_Emblem.svg/100px-Princess_of_Asturias_Foundation_Emblem.svg.png 2x, //upload.wikimedia.org/wikipedia/commons/thumb/7/70/Princess_of_Asturias_Foundation_Emblem.svg/75px-Princess_of_Asturias_Foundation_Emblem.svg.png 1.5x\"></a></figure-inline></div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"background:#99d6ff;;width:1%\">1990s</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li>1990: <a href=\"/wiki/Hans-Dietrich_Genscher\" title=\"Hans-Dietrich Genscher\">Hans-Dietrich Genscher</a></li>\n<li>1991: UNHCR (<a href=\"/wiki/United_Nations_High_Commissioner_for_Refugees\" title=\"United Nations High Commissioner for Refugees\">United Nations High Commissioner for Refugees</a>)</li>\n<li>1992: <a href=\"/wiki/F._W._de_Klerk\" title=\"F. W. de Klerk\">Frederik W. de Klerk</a> and <a href=\"/wiki/Nelson_Mandela\" title=\"Nelson Mandela\">Nelson Mandela</a></li>\n<li>1993: <a href=\"/wiki/United_Nations_Protection_Force\" title=\"United Nations Protection Force\">United Nations Blue Berets stationed in Ex-Yugoslavia</a></li>\n<li>1994: <a href=\"/wiki/Yitzhak_Rabin\" title=\"Yitzhak Rabin\">Yitzhak Rabin</a> and <a href=\"/wiki/Yasser_Arafat\" title=\"Yasser Arafat\">Yasser Arafat</a></li>\n<li>1995: <a href=\"/wiki/Mário_Soares\" title=\"Mário Soares\">Mário Soares</a></li>\n<li>1996: <a href=\"/wiki/Helmut_Kohl\" title=\"Helmut Kohl\">Helmut Kohl</a></li>\n<li>1997: <a href=\"/wiki/Government_of_Guatemala\" title=\"Government of Guatemala\" class=\"mw-redirect\">Government of Guatemala</a> and <a href=\"/wiki/Guatemalan_National_Revolutionary_Unity\" title=\"Guatemalan National Revolutionary Unity\">Guatemalan National Revolutionary Unity</a></li>\n<li>1998: <a href=\"/wiki/Emma_Bonino\" title=\"Emma Bonino\">Emma Bonino</a>, <a href=\"/wiki/Olayinka_Koso-Thomas\" title=\"Olayinka Koso-Thomas\">Olayinka Koso-Thomas</a>, <a href=\"/wiki/Graça_Machel\" title=\"Graça Machel\">Graça Machel</a>, <a href=\"/wiki/Fatiha_Boudiaf\" title=\"Fatiha Boudiaf\">Fatiha Boudiaf</a>,  <a href=\"/wiki/Rigoberta_Menchú\" title=\"Rigoberta Menchú\">Rigoberta Menchú</a>, <span class=\"new\">Fatana Ishaq Gailani</span>  and <a href=\"/wiki/Somaly_Mam\" title=\"Somaly Mam\">Somaly Mam</a></li>\n<li>1999: <a href=\"/wiki/Pedro_Duque\" title=\"Pedro Duque\">Pedro Duque</a>, <a href=\"/wiki/John_Glenn\" title=\"John Glenn\">John Glenn</a>, <a href=\"/wiki/Chiaki_Mukai\" title=\"Chiaki Mukai\">Chiaki Mukai</a> and <a href=\"/wiki/Valeri_Polyakov\" title=\"Valeri Polyakov\">Valeri Polyakov</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"background:#99d6ff;;width:1%\">2000s</th><td class=\"navbox-list navbox-odd hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li>2000: <a href=\"/wiki/Fernando_Henrique_Cardoso\" title=\"Fernando Henrique Cardoso\">Fernando Henrique Cardoso</a></li>\n<li>2001: <a href=\"/wiki/International_Space_Station\" title=\"International Space Station\">International Space Station</a></li>\n<li>2002: The <a href=\"/wiki/Scientific_Committee_on_Antarctic_Research\" title=\"Scientific Committee on Antarctic Research\">Scientific Committee on Antarctic Research</a></li>\n<li>2003: <a href=\"/wiki/Luiz_Inácio_Lula_da_Silva\" title=\"Luiz Inácio Lula da Silva\">Luiz Inácio Lula da Silva</a></li>\n<li>2004: The <a href=\"/wiki/European_Union\" title=\"European Union\">European Union</a>'s <a href=\"/wiki/Erasmus_Programme\" title=\"Erasmus Programme\">Erasmus Programme</a></li>\n<li>2005: <a href=\"/wiki/Simone_Veil\" title=\"Simone Veil\">Simone Veil</a></li>\n<li>2006: <a href=\"/wiki/Bill_&amp;_Melinda_Gates_Foundation\" title=\"Bill &amp; Melinda Gates Foundation\">Bill &amp; Melinda Gates Foundation</a></li>\n<li>2007: <a href=\"/wiki/Al_Gore\" title=\"Al Gore\">Al Gore</a></li>\n<li>2008: <span class=\"new\">Manhiça Centre of Health Research</span> (<a href=\"/wiki/Mozambique\" title=\"Mozambique\">Mozambique</a>), <a href=\"/wiki/Ifakara_Health_Institute\" title=\"Ifakara Health Institute\">Ifakara Health Institute</a> (<a href=\"/wiki/Tanzania\" title=\"Tanzania\">Tanzania</a>), <span class=\"new\">Malaria Research and Training Centre</span> (<a href=\"/wiki/Mali\" title=\"Mali\">Mali</a>) and <span class=\"new\">Kintampo Health Research Centre</span> (<a href=\"/wiki/Ghana\" title=\"Ghana\">Ghana</a>)</li>\n<li>2009: <a href=\"/wiki/World_Health_Organization\" title=\"World Health Organization\">World Health Organization</a></li></ul>\n</div></td></tr><tr><th scope=\"row\" class=\"navbox-group\" style=\"background:#99d6ff;;width:1%\">2010s</th><td class=\"navbox-list navbox-even hlist\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li>2010: <span class=\"new\">The Transplantation Society</span> and the Spanish <a href=\"/wiki/National_Transplant_Organization\" title=\"National Transplant Organization\">National Transplant Organization</a></li>\n<li>2011: <a href=\"/wiki/Bill_Drayton\" title=\"Bill Drayton\">Bill Drayton</a></li>\n<li>2012: <a href=\"/wiki/International_Red_Cross_and_Red_Crescent_Movement\" title=\"International Red Cross and Red Crescent Movement\">International Red Cross and Red Crescent Movement</a></li>\n<li>2013: <a href=\"/wiki/Max_Planck_Society\" title=\"Max Planck Society\">Max Planck Society</a> for the Advancement of Science</li>\n<li>2014: <a href=\"/wiki/Fulbright_Program\" title=\"Fulbright Program\">Fulbright Program</a></li>\n<li>2015: <a href=\"/wiki/Wikipedia\" title=\"Wikipedia\">Wikipedia</a></li>\n<li>2016: <a href=\"/wiki/United_Nations_Framework_Convention_on_Climate_Change\" title=\"United Nations Framework Convention on Climate Change\">United Nations Framework Convention on Climate Change</a> and the <a href=\"/wiki/Paris_Agreement\" title=\"Paris Agreement\">Paris Agreement</a></li>\n<li>2017: The <a href=\"/wiki/Hispanic_Society_of_America\" title=\"Hispanic Society of America\">Hispanic Society of America</a></li>\n<li>2018: <a href=\"/wiki/Amref_Health_Africa\" title=\"Amref Health Africa\">Amref Health Africa</a></li>\n<li>2019: <a href=\"/wiki/Sal_Khan\" title=\"Sal Khan\">Salman Khan</a> and the <a href=\"/wiki/Khan_Academy\" title=\"Khan Academy\">Khan Academy</a></li></ul>\n</div></td></tr></tbody></table></div>\n<div role=\"navigation\" class=\"navbox authority-control\" aria-labelledby=\"Authority_control_frameless_&amp;#124;text-top_&amp;#124;10px_&amp;#124;alt=Edit_this_at_Wikidata_&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q52&amp;#124;Edit_this_at_Wikidata\" style=\"padding:3px\" about=\"#mwt3248\"><table class=\"nowraplinks hlist navbox-inner\" style=\"border-spacing:0;background:transparent;color:inherit\"><tbody><tr><th id=\"Authority_control_frameless_&amp;#124;text-top_&amp;#124;10px_&amp;#124;alt=Edit_this_at_Wikidata_&amp;#124;link=https&amp;#58;//www.wikidata.org/wiki/Q52&amp;#124;Edit_this_at_Wikidata\" scope=\"row\" class=\"navbox-group\" style=\"width:1%\"><a href=\"/wiki/Help:Authority_control\" title=\"Help:Authority control\">Authority control</a> <figure-inline class=\"mw-valign-text-top\"><a href=\"https://www.wikidata.org/wiki/Q52\" class=\"image\"><img src=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/10px-OOjs_UI_icon_edit-ltr-progressive.svg.png\" data-file-width=\"20\" data-file-height=\"20\" data-file-type=\"drawing\" height=\"10\" width=\"10\" srcset=\"//upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/20px-OOjs_UI_icon_edit-ltr-progressive.svg.png 2x, //upload.wikimedia.org/wikipedia/en/thumb/8/8a/OOjs_UI_icon_edit-ltr-progressive.svg/15px-OOjs_UI_icon_edit-ltr-progressive.svg.png 1.5x\"></a></figure-inline></th><td class=\"navbox-list navbox-odd\" style=\"text-align:left;border-left-width:2px;border-left-style:solid;width:100%;padding:0px\"><div style=\"padding:0em 0.25em\">\n<ul><li><span class=\"nowrap\"><a href=\"/wiki/Bibsys\" title=\"Bibsys\">BIBSYS</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://authority.bibsys.no/authority/rest/authorities/html/8030646\" class=\"external text\">8030646</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/Bibliothèque_nationale_de_France\" title=\"Bibliothèque nationale de France\">BNF</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://catalogue.bnf.fr/ark:/12148/cb165741116\" class=\"external text\">cb165741116</a> <a rel=\"mw:ExtLink\" href=\"https://data.bnf.fr/ark:/12148/cb165741116\" class=\"external text\">(data)</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/Integrated_Authority_File\" title=\"Integrated Authority File\">GND</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://d-nb.info/gnd/7545251-0\" class=\"external text\">7545251-0</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/International_Standard_Name_Identifier\" title=\"International Standard Name Identifier\">ISNI</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"http://isni.org/isni/000000044914788X\" class=\"external text\">0000 0004 4914 788X</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/Library_of_Congress_Control_Number\" title=\"Library of Congress Control Number\">LCCN</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://id.loc.gov/authorities/names/no2008072801\" class=\"external text\">no2008072801</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/National_Library_of_the_Czech_Republic\" title=\"National Library of the Czech Republic\">NKC</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://aleph.nkp.cz/F/?func=find-c&amp;local_base=aut&amp;ccl_term=ica=kn20090528031&amp;CON_LNG=ENG\" class=\"external text\">kn20090528031</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/National_Library_of_Israel\" title=\"National Library of Israel\">NLI</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"http://uli.nli.org.il/F/?func=direct&amp;doc_number=001395032&amp;local_base=nlx10\" class=\"external text\">001395032</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/National_and_University_Library_in_Zagreb\" title=\"National and University Library in Zagreb\">NSK</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"http://katalog.nsk.hr/F/?func=direct&amp;doc_number=000625468&amp;local_base=nsk10\" class=\"external text\">000625468</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/LIBRIS\" title=\"LIBRIS\">SELIBR</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://libris.kb.se/auth/319345\" class=\"external text\">319345</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/Système_universitaire_de_documentation\" title=\"Système universitaire de documentation\">SUDOC</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://www.idref.fr/11109383X\" class=\"external text\">11109383X</a></span></span></li>\n<li><span class=\"nowrap\"><a href=\"/wiki/Virtual_International_Authority_File\" title=\"Virtual International Authority File\">VIAF</a>: <span class=\"uid\"><a rel=\"mw:ExtLink\" href=\"https://viaf.org/viaf/195846295\" class=\"external text\">195846295</a></span></span></li>\n<li><span class=\"nowrap\"> <a href=\"/wiki/WorldCat_Identities\" title=\"WorldCat Identities\" class=\"mw-redirect\">WorldCat Identities</a>: <a rel=\"mw:ExtLink\" href=\"https://www.worldcat.org/identities/viaf-220417855\" class=\"external text\">viaf-220417855</a></span></li></ul>\n\n</div></td></tr></tbody></table></div>\n\n\n\n\n\n\n\n\n<style data-mw-deduplicate=\"TemplateStyles:r935243608\" typeof=\"mw:Extension/templatestyles\">.mw-parser-output cite.citation{font-style:inherit}.mw-parser-output .citation q{quotes:\"\\\"\"\"\\\"\"\"'\"\"'\"}.mw-parser-output .id-lock-free a,.mw-parser-output .citation .cs1-lock-free a{background:url(\"//upload.wikimedia.org/wikipedia/commons/thumb/6/65/Lock-green.svg/9px-Lock-green.svg.png\")no-repeat;background-position:right .1em center}.mw-parser-output .id-lock-limited a,.mw-parser-output .id-lock-registration a,.mw-parser-output .citation .cs1-lock-limited a,.mw-parser-output .citation .cs1-lock-registration a{background:url(\"//upload.wikimedia.org/wikipedia/commons/thumb/d/d6/Lock-gray-alt-2.svg/9px-Lock-gray-alt-2.svg.png\")no-repeat;background-position:right .1em center}.mw-parser-output .id-lock-subscription a,.mw-parser-output .citation .cs1-lock-subscription a{background:url(\"//upload.wikimedia.org/wikipedia/commons/thumb/a/aa/Lock-red-alt-2.svg/9px-Lock-red-alt-2.svg.png\")no-repeat;background-position:right .1em center}.mw-parser-output .cs1-subscription,.mw-parser-output .cs1-registration{color:#555}.mw-parser-output .cs1-subscription span,.mw-parser-output .cs1-registration span{border-bottom:1px dotted;cursor:help}.mw-parser-output .cs1-ws-icon a{background:url(\"//upload.wikimedia.org/wikipedia/commons/thumb/4/4c/Wikisource-logo.svg/12px-Wikisource-logo.svg.png\")no-repeat;background-position:right .1em center}.mw-parser-output code.cs1-code{color:inherit;background:inherit;border:inherit;padding:inherit}.mw-parser-output .cs1-hidden-error{display:none;font-size:100%}.mw-parser-output .cs1-visible-error{font-size:100%}.mw-parser-output .cs1-maint{display:none;color:#33aa33;margin-left:0.3em}.mw-parser-output .cs1-subscription,.mw-parser-output .cs1-registration,.mw-parser-output .cs1-format{font-size:95%}.mw-parser-output .cs1-kern-left,.mw-parser-output .cs1-kern-wl-left{padding-left:0.2em}.mw-parser-output .cs1-kern-right,.mw-parser-output .cs1-kern-wl-right{padding-right:0.2em}</style>","toclevel":1,"line":"External links","anchor":"External_links"}]}} + http_version: null + recorded_at: Thu, 16 Apr 2020 10:36:06 GMT +recorded_with: VCR 5.1.0 diff --git a/spec/support/fixtures/vcr_cassettes/wikipedia_tag.yml b/spec/support/fixtures/vcr_cassettes/wikipedia_tag.yml new file mode 100644 index 000000000..ff92feb75 --- /dev/null +++ b/spec/support/fixtures/vcr_cassettes/wikipedia_tag.yml @@ -0,0 +1,86 @@ +--- +http_interactions: +- request: + method: get + uri: https://en.wikipedia.org/api/rest_v1/page/summary/Wikipedia + body: + encoding: US-ASCII + string: '' + headers: + Accept-Encoding: + - gzip;q=1.0,deflate;q=0.6,identity;q=0.3 + Accept: + - "*/*" + User-Agent: + - Ruby + response: + status: + code: 200 + message: OK + headers: + Content-Type: + - application/json; charset=utf-8; profile="https://www.mediawiki.org/wiki/Specs/Summary/1.4.2" + Cache-Control: + - s-maxage=1209600, max-age=300 + Content-Language: + - en + Vary: + - Accept-Encoding + Content-Location: + - https://en.wikipedia.org/api/rest_v1/page/summary/Wikipedia + Access-Control-Allow-Origin: + - "*" + Access-Control-Allow-Methods: + - GET,HEAD + Access-Control-Allow-Headers: + - accept, content-type, content-length, cache-control, accept-language, api-user-agent, + if-match, if-modified-since, if-none-match, dnt, accept-encoding + Access-Control-Expose-Headers: + - etag + X-Content-Type-Options: + - nosniff + X-Frame-Options: + - SAMEORIGIN + Referrer-Policy: + - origin-when-cross-origin + X-Xss-Protection: + - 1; mode=block + Content-Security-Policy: + - default-src 'none'; frame-ancestors 'none' + X-Content-Security-Policy: + - default-src 'none'; frame-ancestors 'none' + X-Webkit-Csp: + - default-src 'none'; frame-ancestors 'none' + X-Request-Id: + - 7bc92964-a2bd-4f08-b9b6-7f718282848d + Server: + - restbase1016 + Date: + - Mon, 13 Apr 2020 17:02:54 GMT + Etag: + - W/"949289700/5ae95970-7cf7-11ea-86c0-dbb91750f4b9" + Age: + - '58602' + X-Cache: + - cp3062 hit, cp3060 hit/430 + X-Cache-Status: + - hit-front + Server-Timing: + - cache;desc="hit-front" + Strict-Transport-Security: + - max-age=106384710; includeSubDomains; preload + X-Client-Ip: + - 77.13.172.109 + Accept-Ranges: + - bytes + Content-Length: + - '893' + Connection: + - keep-alive + body: + encoding: ASCII-8BIT + string: !binary |- + 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 + http_version: null + recorded_at: Tue, 14 Apr 2020 09:19:35 GMT +recorded_with: VCR 5.1.0