docs: R7 Doc Release

BotProject/CSharp/README.md

@@ -1,5 +1,5 @@
 ## Bot Project
-Bot project is the launcher project for the bots written in declarative form (JSON), using the Composer, for the Bot Framework SDK. They follow pattern defined in [OBI](https://github.com/Microsoft/botframework-obi) format. 
+Bot project is the launcher project for the bots written in declarative form (JSON), using the Composer, for the Bot Framework SDK.
 
 ## Instructions for setting up the Bot Project runtime
 The Bot Project is a regular Bot Framework SDK V4 project. Before you can launch it from the emulator, you need to make sure you can run the bot. 

BotProject/Templates/CSharp/README.md

@@ -1,5 +1,5 @@
 ## Bot Project
-Bot project is the launcher project for the bots written in declarative form (JSON), using the Composer, for the Bot Framework SDK. They follow pattern defined in [OBI](https://github.com/Microsoft/botframework-obi) format. 
+Bot project is the launcher project for the bots written in declarative form (JSON), using the Composer, for the Bot Framework SDK.
 
 ## Instructions for setting up the Bot Project runtime
 The Bot Project is a regular Bot Framework SDK V4 project. Before you can launch it from the emulator, you need to make sure you can run the bot. 

Composer/packages/lib/eslint-plugin-bfcomposer/src/index.js

@@ -6,7 +6,10 @@ const reduce = require('lodash/reduce');
 const zipObject = require('lodash/zipObject');
 
 const ruleNames = map(fs.readdirSync(path.resolve(__dirname, 'rules')), f => f.replace(/\.js$/, ''));
-const allRules = zipObject(ruleNames, map(ruleNames, r => require(`./rules/${r}`)));
+const allRules = zipObject(
+  ruleNames,
+  map(ruleNames, r => require(`./rules/${r}`))
+);
 
 module.exports = {
   rules: allRules,

docs/Deploying-Composer.md

@@ -6,7 +6,7 @@ The  Composer is designed to be a hosted web app. Currently, you need to run the
 For overview of Composer, read [Introduction to Bot Framewrok Composer](./introduction-to-Composer)  
 
 
-## Deplyment options 
+## Deployment options 
 You have two options  running Composer locally:
 * [Using a docker image](#Using-a-docker-image) 
 * [Build and run Composer locally](#Build-the-Composer-project-and-run-it-locally)
@@ -18,7 +18,7 @@ git clone https://github.com/microsoft/BotFramework-Composer.git
 
 ## Using a docker image 
 
-Using a docker image provides a more controled and isolated environment for you to run the composer.  There are two docker images, one for the Composer web app - where you create assests in the form of dialogs and lanage files, and one for the bot project runtime - which loads assets created by Composer and execuite them.
+Using a docker image provides a more controled and isolated environment for you to run the composer.  There are two docker images, one for the Composer web app - where you create assets in the form of dialogs and language files, and one for the bot project runtime - which loads assets created by Composer and execute them.
 
 ### Prerequisites
 - [docker-compose](https://docs.docker.com/compose/install/)
@@ -123,7 +123,7 @@ This will build and run a Bot Framework bot that the Composer connects to.
 The bot is running on http://localhost:3979/api/messages.
 
 
-Alternativally you can use one command to start both the Composer and the Bot runtime
+Alternatively you can use one command to start both the Composer and the Bot runtime
 ```
 yarn startall
 ```

docs/bfcomposer-intro.md

@@ -1,46 +1,45 @@
 # Introduction to Bot Framework Composer
-Bot Framework Composer is an integrated development tool for developers and multi-disciplinary teams to build bots and other types of conversational software with the [Microsoft Bot Framework](https://dev.botframework.com/). Composer enables teams to create bots that use the latest features from the [Bot Framework SDK](https://github.com/microsoft/botframework-sdk).
+Bot Framework Composer is an integrated development tool that developers and multi-disciplinary teams can use to build bots. Bot Framework Composer is built using the latest features of the [Bot Framework SDK](https://github.com/microsoft/botframework-sdk).
 
 ![BF Composer](./media/introduction/composer-overview.png)
 
  Within this tool, you'll find everything you need to build a sophisticated conversational experience:
-* A visual dialog editor 
-* Tools to train and manage Language Understanding (LU)
-* A powerful language generation and templating system
-* A ready-to-use bot runtime executable 
+* a visual dialog editor 
+* tools to train and manage Language Understanding (LU)
+* powerful language generation and templating systems
+* a ready-to-use bot runtime executable 
 
 ## Advantage of developing bots with Composer
-Developers familiar with the Bot Framework SDK will notice differences between bots developed with it and the Bot Framwork Composer. Below are some of the advantages of developing bots in Composer:
-- Adaptive dialogs allow for Language Generation (LG), which can simplify interruption handling and give bots character
-- The visual representation and editing in Composer eliminates the need for boilerplate code and makes bot development more accessible
-- No longer need to navigate between experiences to maintain LU model as it is editable within the app
-- Time saved with fewer steps to set up your environment and start bots
+Developers familiar with the Bot Framework SDK will notice differences between bots developed with it and the Bot Framwork Composer. Some of the advantages of developing bots in Composer include:
+- use of Adaptive Dialogs allow for Language Generation (LG), which can simplify interruption handling and give bots character
+- visual design surface in Composer eliminates the need for boilerplate code and makes bot development more accessible. You no longer need to navigate between experiences to maintain LU model as it is editable within the app.
+- time saved with fewer steps to set up your environment
 
 A major difference between the current version of the Bot Framework SDK and Composer is that the apps created using Composer uses the Adaptive dialog format, a JSON specification shared by many tools provided by the Bot Framework. You can find more information about Adaptive dialog [here](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/adaptive-dialog).
 
-You can manage Composer assests, such as Dialogs, LU training data, and message templates like normal developer assets - files that can be committed to source control and deployed alongside code updates.
+You can manage Composer assets, such as Dialogs, Language Understanding (LU) training data, and message templates like normal developer assets - files that can be committed to source control and deployed alongside code updates.
 
 ## Language Understanding
 
 Language Understanding (LU) is a core component of Composer, allowing developers and conversation designers to train language understanding directly in the context of editing a dialog.  
 
-As dialogs are edited in Composer developers can continuously add to their bot's natural language capabilities through a simple markdown-like format that makes it easy to define new intents and provide sample utterances.
+As dialogs are edited in Composer developers can continuously add to their bots' natural language capabilities through a simple markdown-like format that makes it easy to define new intents and provide sample utterances.
 
 ![BF Composer NLU](./media/introduction/intro-nlu.png)
 
  Composer detects changes and updates the bot's cloud-based NLU model automatically so it is always up to date.
 
 ## Language Generation
 
-Creating grammatically correct, data-driven responses that also use a consistent tone and convey a clear brand voice has always been a challenge for bot developers. Composer's integrated [Language Generation](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/language-generation) (LG) system allows developers, and the writers who work with them, to create replies with a great deal of flexibility.
+Creating grammatically correct, data-driven responses that have a consistent tone and convey a clear brand voice has always been a challenge for bot developers. Composer's integrated [Language Generation](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/language-generation) (LG) system allows developers to create bot replies with a great deal of flexibility.
 
 ![BF Composer LG](.//media/language_generation/bot_responses.png)
 
 With Language Generation, previously complex tasks can be quickly achieved, like:
-* Including dynamic elements in messages
-* Generating grammatically correct lists, pronouns, articles
-* Providing context-sensitive variation in messages
-* Creating Adaptive Cards attachments, as seen above
+* including dynamic elements in messages
+* generating grammatically correct lists, pronouns, articles
+* providing context-sensitive variation in messages
+* creating Adaptive Cards attachments, as seen above
 
 ## Unified toolset
 

docs/concept-dialog.md

@@ -52,7 +52,7 @@ As the bot takes actions and sends messages, the **language generator** is calle
 
 When you create a bot in Composer you also create its main dialog by default. Follow the steps to create a bot project and its main dialog:
 
-1. On the left side of the Composer home screen, click **+ New** from the upper left corner (or the big **+ ** sign under "Bot Framework Composer" in the middle part of the home screen).
+1. On the left side of the Composer home screen, click **+ New** from the upper left corner (or the big `+` sign in the middle part of the home screen). 
 
 ![create_new_bot](./media/dialog/create_new_bot.png)
 
@@ -62,12 +62,12 @@ When you create a bot in Composer you also create its main dialog by default. Fo
 
 ![new_bot](./media/dialog/new_bot.png)
 
-When your bot is created successfully you will see a **.Main** dialog in the dialog navigation pane. Congratulations! You have created your first bot and its main dialog using Composer. Below is a screenshot of a bot named `Greeting` and its main dialog named `Greeting.Main`:
+When your bot is created successfully you will see a **.Main** dialog in the dialog navigation pane. Congratulations! You have created your first bot! Below is a screenshot of a bot named `GreetingBot` and its main dialog named `GreetingBot.Main`: 
 
 ![main_dialog](./media/dialog/main_dialog.png)
 
 > [!NOTE]
-> After you create a bot a **ConversationUpdate** trigger will be created by default as well. It is a trigger to handle activities such as sending a welcome message. For details please read [events and triggers](concept-events-and-triggers.md).
+> After you create a bot a **Greeting** trigger will be created by default. It is a trigger to handle activities such as sending a welcome message. For details please read [events and triggers](concept-events-and-triggers.md). 
 
 ## Add a dialog
 
@@ -77,15 +77,15 @@ After you create a bot you are also creating its main dialog by default. The mai
 
 ![weather_dialog](./media/dialog/weather_dialog.png)
 
-After that, you will see an empty dialog you created on the navigation pane. When creating a child dialog you also create a **Dialog started (Begin dialog event)** trigger by default. The new dialog named `Weather` may look like this:
+After that, you will see an empty dialog on the navigation pane and a pre-configured **BeginDialog** trigger. The new dialog named `Weather` looks like the following: 
 
 ![new_weather_dialog](./media/dialog/new_weather_dialog.png)
 
-2. Define an action in the **BeginDialog** trigger. Click the `+` sign under **Dialog started (Begin dialog event)** in the new dialog and select **Send a response**. In the Language Generation editor put a sentence: "The weather dialog is calle with success!"
+2. Define an action in the **BeginDialog** trigger. In the new dialog's authoring canvas, click the `+` sign under **BeginDialog** trigger node and select **Send a response**. In the Language Generation editor put such a sentence: `The weather dialog is calle with success!`
 
 ![send_response](./media/dialog/send_response.gif)
 
-3. Wire up the new dialog. Click the main dialog in navigation pane and select **ConversationUpdate**. In the authoring canvas, click the **+** sign under **ConversationUpdate** and select **Dialog management** and then **Begin a new dialog** which is a dialog action that begins another dialog. When that dialog is completed, it will return to the caller.
+3. Wire up the new dialog. Click the main dialog in navigation pane and select **Greeting** trigger. In the authoring canvas, click the `+` sign under **Greeting** trigger node and select **Dialog management** and then **Begin a new dialog**. This is a dialog action that begins another dialog. When that dialog is completed, it will return to the caller. 
 
 ![begin_dialog_action](./media/dialog/begin_dialog_action.png)
 
@@ -96,8 +96,10 @@ Now in the properties panel on the right side select the dialog you want to wire
 When the bot runs, the pattern of this simple design is as follows:
 
 - The main dialog `Greeting.Main` is called at bot runtime.
-- The **ConversationUpdate** trigger in the main dialog is activated and begins to execute the **Begin a new dialog** action which begins `Weather` dialog.
-- When `Weather` dialog becomes active, the **BeginDialog** trigger in the child dialog is fired and send the response "The weather dialog is called with success!" to users.
+- The **Greeting** trigger in the main dialog is activated and begins to execute the **Begin a new dialog** action which begins `Weather` dialog. 
+- When `Weather` dialog becomes active, the **BeginDialog** trigger in the child dialog is fired and send the response "The weather dialog is called with success!" to users. 
+
+You can test the result by clicking **Start** on the upper right corner and then click **Test in Emulator**. You should be able to see the following result in the emulator: 
 
 You can test the result by clicking **Start** on the upper right corner and then click **Test in Emulator**. You should be able to see the following result in the emulator:
 
@@ -126,6 +128,5 @@ With these dialog actions, we can easily build a pluggable and extensible dialog
 
 [Adaptive dialogs](https://github.com/Microsoft/BotBuilder-Samples/tree/master/experimental/adaptive-dialog#readme)
 
-## Next
-
-[Events and triggers](./concept-events-and-triggers.md)
+## Next 
+- [Events and triggers](./concept-events-and-triggers.md)