removing Web UI tutorials, updating remaining 4 to current release, + review pass

src/site/docs/tutorials/fetchdata/index.markdown

 ---
 layout: default
 title: "Fetch Data Dynamically"
 description: "Use HttpRequest to fetch data from a file or a server."
 has-permalinks: true
 tutorial:
   id: fetchdata
 next: forms/
 next-title: "Get Input from a Form"
 prev: polymer-intro/
 prev-title: "Define a Custom Element"
 ---
 
 {% capture whats_the_point %}
 
 * Data on the web is often formatted in JSON.
 * JSON is text based and human readable.
-* The dart:json library provides support for JSON.
+* The dart:convert library provides support for JSON.
 * Use HttpRequest to dynamically load data.
 
 {% endcapture %}
 
 {% capture sample_links %}
 
 <p>
 Get the source code for the samples featured in this tutorial:</p>
 
 <ul>
@@ skipping 20 matching lines @@
 <h3>Get data from a file or server.</h3>
 </div>
 
 Web applications often use
 <a href="http://www.json.org/" target="_blank">JSON</a> (JavaScript Object Notation)
 to pass data between clients and servers.
 Data can be _serialized_ into a JSON string,
 which is then passed between a client and server,
 and revived as an object at its destination.
 This tutorial shows you how to use functions in the
-<a href="https://api.dartlang.org/dart_json.html"
-   target="_blank">dart:json</a>
+<a href="https://api.dartlang.org/dart_convert.html"
+   target="_blank">dart:convert</a>
 library to produce and consume JSON data.
 Because JSON data is typically loaded dynamically,
 this tutorial also shows how a web app
 can use an HTTP request to get data from an HTTP server.
 For web apps,
 HTTP requests are served by the browser in which the app is running,
 and thus are subject to the browser's security restrictions.
 
 * [About JSON](#about-json)
 * [Serializing data into JSON](#serializing-data-into-json)
 * [Parsing JSON data](#parsing-json-data)
 * [About URIs and HTTP requests](#about-uris)
 * [Using the getString() function to load a file](#using-getString-function)
 * [Using an HttpRequest object to load a file](#making-a-get-request)
 * [Other resources](#other-resources)
+* [What next?](#what-next)
 
 ##About JSON
 
 The JSON data format is easy for humans
 to write and read because it is lightweight and text based.
 With JSON, various data types
 and simple data structures such as lists and maps
 can be serialized and represented by strings.
 
 **Try it!**
 The app running below, `its_all_about_you`,
 displays the JSON string for data of various types.
 Change the values of the input elements
 and check out the JSON format for each data type.
 
 <iframe class="running-app-frame"
         style="height:500px;width:700px;"
         src="examples/its_all_about_you/out/web/index.html">
 </iframe>
 
 The complete source code is available on github:
 <a href="https://github.com/dart-lang/dart-tutorials-samples/tree/master/web/fetchdata/its_all_about_you"
    target="_blank">its_all_about_you</a>.
 
-The dart:json library contains two top-level functions
+The dart:convert library contains two convenient functions
 for working with JSON strings:
 
-| dart:json function | Description |
+| dart:convert function | Description |
 |---|---|
-| <a href="https://api.dartlang.org/dart_json.html" target="_blank">parse()</a> | Builds Dart objects from a string containing JSON data. |
-| <a href="https://api.dartlang.org/dart_json.html" target="_blank">stringify()</a> |  Serializes a Dart object into a JSON string. |
+| <a href="https://api.dartlang.org/dart_convert.html" target="_blank">JSON.decode()</a> | Builds Dart objects from a string containing JSON data. |
+| <a href="https://api.dartlang.org/dart_convert.html" target="_blank">JSON.encode()</a> |  Serializes a Dart object into a JSON string. |
 {: .table}
 
-The parse() and stringify() functions can handle these Dart types automatically:
+To use these functions,
+you need to import dart:convert into your Dart code:
+
+{% highlight dart %}
+import 'dart:convert';
+{% endhighlight %}
+
+The JSON.encode() and JSON.decode() functions can handle these Dart types automatically:
 <ul>
 <li> num</li>
 <li> String</li>
 <li> bool</li>
 <li> null</li>
 <li> List</li>
 <li> Map</li>
 </ul>
 
-Import dart:json using the `as` clause
-to give your code clarity
-and to avoid naming conflicts.
-
-{% highlight dart %}
-import 'dart:json' as json;
-{% endhighlight %}
-
 ##Serializing data into JSON
 
-Use the stringify() function to serialize an object that supports JSON.
-Here's the function from the previous example that
+Use the JSON.encode() function to serialize an object that supports JSON.
+Here's the function, `showJson`, from the its_all_about_you example that
 converts all of the data to JSON strings.
 
-![Use stringify() to convert objects into JSON](images/stringify.png)
+![Use JSON.encode() to convert objects into JSON](images/stringify.png)
 
 Below is the JSON string that results from the code
 using the original values from the its_all_about_you app.
 
 ![The JSON string for the its_all_about_you app](images/jsonstring.png)
 
 Boolean and numeric values
 appear as they would if they were literal values in code,
 without quotes or other delineating marks.
 A boolean value is either `true` or `false`.
 A null object is represented with `null`.
 
 Strings are contained within double quotes.
 A list is delineated with square brackets;
 its items are comma-separated.
 The list in this example contains strings.
 A map is delineated with curly brackets;
 it contains comma-separated key/value pairs,
 where the key appears first, followed by a colon,
 followed by the value.
 In this example,
 the keys in the map are strings.
 The values in the map vary in type but they are all JSON-parsable.
 
 ##Parsing JSON data
 
-Use the parse() function from the dart:json library to
+Use the JSON.decode() function from the dart:convert library to
 create Dart objects from a JSON string.
-The example above initially populates the values in the form
+The its_all_about_you example initially populates the values in the form
 from this JSON string:
 
 {% highlight dart %}
 String jsonDataAsString = '''
 { "favoriteNumber":44,
   "valueOfPi":3.141592,
   "chocolate":true,
   "horrorScope":"virgo",
   "favoriteThings":["raindrops",
                     "whiskers",
                     "mittens"]
 }
 ''';
 
-Map jsonData = json.parse(jsonDataAsString);
+Map jsonData = JSON.decode(jsonDataAsString);
 {% endhighlight %}
 
-This code calls the parse() function with a properly formatted JSON string.
+This code calls the JSON.decode() function with a properly formatted JSON string.
 <strong>Note that Dart strings can use either single or double quotes to denote strings.
 JSON requires double quotes.</strong>
 
 In this example, the full JSON string is hard coded into the Dart code,
 but it could be created by the form itself
 or read from a static file or received from a server.
 An example later on this page shows how to dynamically fetch
 JSON data from a file that is co-located with the code for the app.
 
-The parse() function reads the string and
+The JSON.decode() function reads the string and
 builds Dart objects from it.
 In this example, 
-the parse() function creates a Map object based on
+the JSON.decode() function creates a Map object based on
 the information in the JSON string.
 The Map contains objects of various types
 including an integer, a double, a boolean value, a regular string,
 and a list.
 All of the keys in the map are strings.
 
 ##About URIs and HTTP requests {#about-uris}
 
 To make an HTTP GET request from within a web app,
 you need to provide a URI (Uniform Resource Identifier) for the resource.
@@ skipping 211 matching lines @@
 
 ![Set up a callback function for request completion](images/set-callback.png)
 
 The callback function for our example,
 requestComplete(),
 checks the status code for the request.
 If the status code is 200,
 the file was found and loaded successfully,
 The contents of the requested file, `portmanteaux.json`, are
 returned in the `responseText` property of an HttpRequest object.
-Using the `parse()` function from the dart:json library,
+Using the `JSON.decode()` function from the dart:convert library,
 the code easily converts the JSON-formatted list of words
 to a Dart list of strings,
 creates a new LIElement for each one,
 and adds it to the &lt;ul&gt; element on the page.
 
 ![Getting the response text from an HTTP GET request](images/portmanteaux-callback.png)
 
 ###Populating the UI from JSON
 
 The data file in the portmanteaux example,
 <a href="https://github.com/dart-lang/dart-tutorials-samples/master/web/fetchdata/portmanteaux/web/portmanteaux.json"
    target="_blank">portmanteaux.json</a>,
 contains a JSON-formatted list of strings.
 
 {% highlight dart %}
 [
   "portmanteau", "fantabulous", "spork", "smog",
   "spanglish", "gerrymander", "turducken", "stagflation",
   "Brangelina", "freeware", "oxbridge", "palimony",
   "brunch", "blog", "chortle", "Hassenpfeffer", "Schnitzelbank"
 ]
 {% endhighlight %}
 
 Upon request, the server reads this data from the file
 and sends it as a single string
 to the client program.
 The client program receives the JSON string
-and uses the parse() function from the dart:json library
+and uses JSON.decode() 
 to create the String objects specified by the JSON string.
 
-![Parse a JSON formatted list of strings](images/json-parse.png)
+![Decode a JSON formatted list of strings](images/json-parse.png)
 
 ##Other resources
 
 Check out Chris Buckett's article,
 <a href="/articles/json-web-service/"
    target="_blank">Using Dart with JSON Web Services</a>,
 for more information and an example with source code for both
 client and server programs.
 
+##What Next?
+
+The next tutorial,
+[Get Input from a Form](/docs/tutorials/forms/),
+contains a client/server example that
+shows you how to use a form to get data from the user,
+and using JSON, send that form to a server,
+and handle the server's response.
+
 {% endcapture %}
 
 {% include tutorial.html %}