edit pass on T3,4,5, updated images

src/site/docs/tutorials/get-started/index.markdown

 ---
 layout: default
 title: "Get Started"
 description: "Get Dart and run two Dart applications"
 has-permalinks: true
 tutorial:
   id: get-started
 js:
 - url: /js/os-switcher.js
   defer: true
@@ skipping 14 matching lines @@
 * Run Dart web apps directly in Dartium.
 * Compile Dart apps to JavaScript for other browsers.
 * All Dart apps have a main() function.
 * Dart supports top-level functions.
 
 {% endcapture %}
 
 {% capture sample_links %}
 
 <p>
-Get the source code for the samples featured in this target:</p>
+Get the source code for the samples featured in this tutorial:</p>
 
 <ul>
   <li>
-    <a href="https://github.com/dart-lang/dart-tutorials-samples/tree/master/web/target01/helloworld"
+    <a href="https://github.com/dart-lang/dart-tutorials-samples/tree/master/web/get-started/helloworld"
        target="_blank">helloworld</a>
   </li>
   <li>
-    <a href="https://github.com/dart-lang/dart-tutorials-samples/tree/master/web/target01/clickme"
+    <a href="https://github.com/dart-lang/dart-tutorials-samples/tree/master/web/get-started/clickme"
        target="_blank">clickme</a>
   </li>
 </ul>
 
 {% endcapture %}
 
 {% capture content %}
 
 <div class="tute-target-title">
 <h1>{{page.title}}</h1>
 <h3>Get Dart. Run two apps.</h3>
 </div>
 
-This target gets you ready
+This tutorial gets you ready
 to begin writing web apps in Dart.
 Here you will download the Dart software,
 and use Dart Editor to
 create and run two small applications.
 
 * [Download the Dart software bundle](#download-dart)
 * [What did you get?](#what-did-you-get)
 * [Start Dart Editor](#start-dart-editor)
 * [About Dart applications](#what-is-app)
 * [Create a command-line app](#create-cmd-line)
 * [Run a command-line app](#run-cmd-line)
 * [Create a web app](#create-web-app)
-* [Run a web app in Dartium](#run-web-app)
+* [Run a web app](#run-web-app)
 * [About the HTML, CSS, and Dart triumvirate](#source-files)
 * [About main() and other top-level functions](#top-level-functions)
 * [About file naming conventions](#file-names)
 * [Other resources](#other-resources)
+* [What next?](#what-next)
 
 ##Download the Dart software bundle {#download-dart}
 
 Get Dart.
 The Dart download includes Dart Editor,
 which you'll be using
 throughout this tutorial.
 
 <div align="center">
   {% include downloads/_dart-editor.html %}
@@ skipping 93 matching lines @@
 ## Start Dart Editor {#start-dart-editor}
 
 Invoke Dart Editor by double-clicking its icon
 in your Dart installation directory
 <img src="/imgs/Dart_Logo_21.png"
      width="21" height="21" alt="Dart Editor icon">.
 
 Dart Editor displays its Welcome Page
 in a tab in the **Editor pane**.
 The following diagram highlights
-the features you need to know about now.
+some of the features of the editor.
 
 <img src="images/dart-editor-items.png"
      alt="Dart Editor's basic features">
 
 Send feedback button
 : Allows you to share bugs and requests
 directly with the Dart Editor team
 as well as the larger Dart team.
 
 Search field
 : Searches every file in your **Files view** for the entered text.
 Results for text searches are displayed in a **Search view**.
 Within that view,
 double-click a file to see it in the **Editor pane**.
 All occurrences of the search string in the **Editor pane** are highlighted.
 
 Run button
 : Runs the application associated with the file
 that is currently selected in the **Files view**.
 
 New application button
 : Creates a directory and, within it,
 the files for a new application.
 Alternatively, you can use the
 **File > New Application** menu item
-or the **Create a new application** button
+or the **Create an application** button
 on the Welcome page.
 
+Files view
+: Shows a hierarchical view of your Dart applications
+and their associated files.
+Double-click a file in the **Files view** to see its contents
+in the **Editor pane**.
+If you single-click a file in the **Files view**,
+the file is selected,
+but not necessarily displayed in the **Editor pane**.
+You must double-click the file.
+
 Editor pane
 : Provides the basic editing functionality you'd expect,
 plus features such as Dart code completion,
 API browsing, and support for refactoring.
 The first time you use Dart Editor,
 it shows the Welcome Page in the Editor pane,
 which provides quick access to Dart resources
 and some nifty samples.
 The Welcome Page is also available under the **Tools** menu.
 
-Files view
-: Shows a hierarchical view of your Dart applications
-and their associated files.
-Double-click a file in the **Files view** to see its contents
-in the **Editor pane**.
-If you single-click a file in the **Files view**,
-the file is selected,
-but not necessarily displayed in the **Editor pane**.
-You must double-click the file.
+Problems pane
+: Displays warning and error messages.
 
 <aside class="alert alert-info">
 <b> Problems? </b>
 See <a href="/tools/editor/troubleshoot.html">Troubleshooting Dart Editor</a>.
 </aside>
 
 ##About Dart applications {#what-is-app}
 
 At minimum, a Dart application has
 
 * one Dart source file&mdash;a
   file with the .dart suffix that contains Dart code
 * one top-level main() function.
   This is the entry point for your application.
-  main() is typically in a Dart source file whose basename is the app name.
 
 There are two kinds of Dart applications:
 command-line applications and web applications.
 A command-line application is a standalone program
-that you run in the Dart VM from the command-line.
+that you run in the Dart VM from the command-line in a terminal window.
 Web applications are hosted on a web page and run in a browser
 (either directly in a browser that supports Dart
 or by compiling to JavaScript).
 
 ###Command-line applications
 
 Dart command-line applications
 run standalone from the command-line,
 independent of a web browser.
 Command-line apps are often used
 to provide server-side support to a web app,
 but they can also be scripts.
 
 The Dart VM runs Dart code directly without intermediate compilation.
 
 <img src="images/dartvm-cmd-line.png"
      alt="Run a command-line application without compilation">
 
 Conveniently, you can run command-line apps
 directly in Dart Editor with the click of the Run button
 <img src="images/run.png" width="16" height="16"
      alt="Run button">.
 Alternatively,
 use the Dart VM tool
-in the dart-sdk/bin directory in your Dart installation directory.
+in the `dart-sdk/bin` directory in your Dart installation directory.
 
 ###Web applications
 
 Dart web applications run inside of a browser page.
-In addition to a .dart file,
-a web app requires a .html file to host the app.
+In addition to a Dart file,
+a web app requires an HTML file to host the app.
 Often, a web app provides the client-side
 user interface for a server.
 
 You can run your Dart web app from Dart Editor
 by clicking the Run button
 <img src="images/run.png" width="16" height="16"
      alt="Run button">.
 By default, Dart Editor will invoke Dartium,
 which has the Dart VM embedded in it,
-and loads your .html file,
+and loads your HTML file,
 which in turn loads your app.
 
 <img src="images/dartvm-web-app.png"
      alt="Run a web application directly in a Dart-savvy browser">
 
 If you want to see your web app in a browser
 that does not yet support Dart,
 you can compile your Dart code to JavaScript
 using the Dart-to-JavaScript compiler,
-which is in the dart-sdk/bin directory in your Dart installation directory.
-You then load the resulting .js file
+which is in the `dart-sdk/bin` directory in your Dart installation directory.
+You then load the resulting JavaScript file
 into your browser of choice.
-Dart Editor makes this easy with launches,
-which you will learn about in the next target.
+Dart Editor provides a convenient menu option for
+running web apps as JavaScript.
 
 <img src="images/dartvm-js.png"
      alt="Run a web application by compiling to JavaScript">
 
-The rest of this target steps you through
+The rest of this tutorial steps you through
 creating and running first a command-line application
 and then a web application.
 
 ##Create a command-line app {#create-cmd-line}
 
-In Dart Editor, click the New Application button
+In Dart Editor, choose **File->New Application** from the menu
+or click the New Application button
 <img src="images/newapp.png" width="17" height="16" alt="New App button"/>.
-A dialog appears.
+A dialog appears that looks like this:
 
-Follow these steps to create a command-line application:
 <img src="images/new-helloworld.png"
      alt="Create a new command-line application"/>
 
 <ol>
 <li markdown="1">
-Type helloworld in the **Application Name** text field.
+Type `helloworld` in the **Application Name** text field.
 By convention, application names are lowercase.
 This name is used for the app's directory
 and the basename for the files it creates.
 </li>
 
 <li markdown="1">
 Type or browse to the directory where you want to save the files.
 By default, Dart Editor creates a new directory named `dart`
 in your home directory.
 </li>
 
 <li markdown="1">
 Select **Generate sample content**.
-Dart Editor will generate sample code
+Dart Editor generates sample code
 appropriate for the type of application you are creating.
 For a command-line application,
 the sample code implements the standard 'Hello World' program.
 </li>
 
 <li markdown="1">
 Select **Command-line application** from the list.
 </li>
 
 <li markdown="1">
 Click **Finish**.
 </li>
 </ol>
 
-Dart Editor creates a directory called `helloworld`
-that contains boilerplate files and directories for a
-simple command-line app.
-The main source file is named after the application and
-is in a directory called `bin`.
-The rest of the files and directories
-are there for pub support; 
-they come into play if your application needs to use extra libraries.
-You can ignore these files for now.
-
-The main Dart source file for the app
-contains the top-level main() function
-and is named after the app itself.
-In this case, `helloworld.dart`.
-The file hierarchy is displayed in the **Files view**.
+Dart Editor creates a directory for the application
+and boilerplate files for a small command-line app.
+The **Files view** displays
+the file hierarchy for the application.
 
 <img src="images/helloworld-files.png"
      alt="Dart Editor with new command-line app files"/>
 
-The contents of helloworld.dart is shown in the **Editor pane**.
-You might recognize it as the canonical Hello World program.
-This program prints
-`Hello, World!` to the standard output stream
+Some of the files and directories in the helloworld application
+include the following:
+
+helloworld
+: Contains boilerplate files and directories for a
+simple command-line app.
+
+pubspec.yaml
+: Declares which libraries
+your application needs.
+The `packages` directories contain those libraries.
+The `pubspec.lock` file specifies the version numbers
+of the libraries on which the application depends.
+
+bin
+: Contains the source files for the application.
+The main source file for this example is `helloworld.dart`.
+
+helloworld.dart
+: Contains the Dart source code for this app.
+
+The **Editor pane** shows
+the contents of `helloworld.dart`.
+The program prints
+'Hello, World!' to the standard output stream
 using the print() function,
 which is provided by the dart:core library.
 The functions and objects defined in the core library
 are automatically available to all Dart applications.
 
 ##Run a command-line app {#run-cmd-line}
 
-Make sure either the helloworld directory or the helloworld.dart file
-is selected in the **Files view**,
-then click the Run button
+To run the helloworld app from Dart Editor:
+
+* Select the helloworld.dart file in the **Files view**.
+* Click the Run button
 <img src="images/run.png" width="16" height="16"
      alt="Run button">.
 
 Dart Editor opens a new panel,
 called the **Output view**,
 and displays the output of the helloworld app.
 
 <img src="images/helloworld-output.png"
      alt="Dart Editor with helloworld output view"/>
 
 ##Create a web app {#create-web-app}
 
 Now let's create a web application.
 As you did when creating a command-line application,
 click the **New Application** button
 <img src="images/newapp.png" width="17" height="16" alt="New App button"/>.
+Name the application `clickme`.
 This time you are creating a web app,
-so select **Web application** from the list.
+so select **Web application** from the list
+in the New Application dialog window:
 
 <img src="images/new-click-me.png"
      alt="Create a new web application"/>
 
 Dart Editor creates the directory and files needed
 for a boilerplate web application.
 
 <img src="images/click-me-files.png"
      alt="Dart Editor with new web application files"/>
 
 As before, the directory is named after your application.
 So is the Dart source file that contains the main() function.
 In addition, Dart Editor creates an HTML file that hosts the app.
 
 The main() function in the clickme app
 contains Dart code 
 that puts text on the browser page
 and registers an *event handler*&mdash;a function
 that responds to user-generated events like a mouse click.
-This code uses API defined in the Dart HTML library.
+This code uses API defined in the dart:html library.
 
-In the next target,
+In the next tutorial,
 you will build a mini app from scratch,
 creating the Dart source, the HTML source,
 and the CSS source yourself.
 Afterward, you can re-visit the code for clickme.
 
-##Run a web app in Dartium {#run-web-app}
+##Run a web app {#run-web-app}
 
-To run clickme from Dart Editor,
-make sure either the clickme directory or any of its files
-is selected,
-then click the Run button
+To run the clickme app from Dart Editor:
+
+* Select `clickme.html`.
+* Click the Run button
 <img src="images/run.png" width="16" height="16"
      alt="Run button">.
-Dart Editor invokes Dartium,
-which loads the clickme app's HTML file,
-and thus, loads the app.
 
-Here is the clickme app running in a frame.
-**Try it!** Click the text.
+Dart Editor invokes Dartium providing it with
+the URL for the clickme app's HTML file.
+Dartium loads the clickme app's HTML file
+and the embedded app, which looks like this:
 
 <iframe class="running-app-frame"
         style="height:510px;width:500px;"
-        src="http://dart-lang.github.io/dart-tutorials-samples/web/target01/clickme/web/clickme.html">
+        src="examples/clickme/clickme.html">
 </iframe>
 
+###Run as JavaScript
+
 You can run Dart web applications in other browsers
 by compiling to JavaScript.
-You will do this in the next target,
-when you learn about runtime configurations called launches.
+Dart Editor provides a convenient menu option for doing so.
+Right click on `clickme.html`
+and select **Run as JavaScript** from the menu.
+
+<img src="images/run-as-javascript-screenshot.png"
+     alt="Run a web app as JavaScript"/>
+
+Dart Editor compiles the app to JavaScript and
+invokes your default browser,
+which runs the app.
 
 ##About the HTML, CSS and Dart triumvirate {#source-files}
 
 Typically three files&mdash;an HTML file, a Dart file,
 and a CSS file&mdash;together implement a Dart web application.
 Each is written in a different language
 and each is responsible for a different aspect of the program:
 
 | Language | Purpose |
 |---|---|
@@ skipping 22 matching lines @@
 manipulate the elements on a web page dynamically,
 and can save information.
 
 ##About main() and other top-level functions {#top-level-functions}
 
 Dart lets you define _top-level_ functions,
 that is, functions that are not encapsulated within a class or object.
 All apps have at least one top-level function,
 namely the main() function.
 
-The two apps you've seen in this target have other top-level functions.
+The two apps you've seen in this tutorial have other top-level functions.
 The Hello World example calls print(),
 a top-level function defined in dart:core.
 And the clickme app defines a top-level function called reverseText().
 
 A function declaration
 has two parts: a _signature_ and a _body_.
 
 <img src="images/function-parts.png"
      alt="Two parts of a function, the signature and the body"/>
 
@@ skipping 38 matching lines @@
 
 You should also follow these conventions
 when creating applications outside of Dart Editor.
 
 ##Other resources
 
 <ul>
   <li>
     <a href="/docs/dart-up-and-running/contents/ch04-tools-editor.html">Dart Editor</a>,
     an excerpt from
-    <a href="/docs/dart-up-and-running/">Dart Up and Running</a>,
+    <a href="/docs/dart-up-and-running/">Dart: Up and Running</a>,
     provides details about using Dart Editor.
     The excerpt includes, for example,
     how to set up run-time environments,
-    how to use power features such as autocompletion and refactoring,
+    how to use power features such as autocompletion,
+    debugging, refactoring,
     and so on.
   </li>
   <li>
     The <a href="/docs/">Programmer's Guide</a>
     points you to docs, articles,
     and other resources to help you as you create,
     test, and deploy Dart code.
   </li>
 </ul>
 
+##What next?
+
+The next tutorial, [Connect Dart & HTML](/docs/tutorials/connect-dart-html/),
+steps you through writing a tiny web app from scratch.
+
 {% endcapture %}
 
 {% include tutorial.html %}