docs: composer review 1-29

docs/how-to-ask-for-user-input.md

@@ -15,7 +15,7 @@ As seen in the **TextInput** dialog the user is prompted for their name in the *
 
 ![Text prompt bot says](./media/ask-for-input/text-bot-asks.png)
 
-The user's response is stored in **Property to fill** in the **User Asks** section as `user.name`. Note that you can change the **Output Format** if you want to save the text as trimmed (leading and trailing whitespace removed), uppercase, or lowercase. 
+The user's response is stored in **Property to fill** in the **User Input** section as `user.name`. Note that you can change the **Output Format** if you want to save the text as trimmed (leading and trailing whitespace removed), uppercase, or lowercase. 
 
 ![Text prompt user input](./media/ask-for-input/text-user-input.png)
 
@@ -51,7 +51,9 @@ In the **ChoiceInput** dialog you will see the **Property to fill** is set to `u
 | Suggested Action | ![list suggested action](./media/ask-for-input/multichoice-list-suggestedactions.png) | displays options as Suggested Action buttons                                   |
 | Hero Card        | ![list hero card](./media/ask-for-input/multichoice-list-herocard.png)                | displays Hero Card with options as buttons **within** card                     |
 
-In the **User Answers** section in the Property panel you will also notice **Choice Options**, which can be used to add more choices and their synonyms. You'll also see three boxes related to inline separation, or how your bot separates the text of your choices:
+In the **User Input** section in the properties panel you will notice **Choice Options**, which can be used to add more choices and their synonyms. You can set the choice options in **Static** or **Dynamic** format. For **Static** format, you need to write each choice option manually; for **Dynamic** format, you can set the options to an array and then retrieve the value dynamically. 
+
+You'll also see three boxes related to inline separation, or how your bot separates the text of your choices:
   - **Inline separator** - character used to separate individual choices when there are more than two choices, usually `,`.
   - **Inline or** - separator used when there are only two choices, usually `or`.
   - **Inline or more** - separator between last two choices when there are more than two options, usually `, or`. 

docs/how-to-publish-bot.md

@@ -6,7 +6,7 @@ To publish a bot, you will need to use Az CLI tool and Bot Framework LuBuild too
 - A subscription to [Microsoft Azure](https://azure.microsoft.com/en-us/free/)
 - To install **Az CLI**, follow [Install the Azure CLI](https://docs.microsoft.com/en-us/cli/azure/install-azure-cli?view=azure-cli-latest) instructions
 - To install **PowerShell 6.0**, follow [Install PowerShell 6.0](https://docs.microsoft.com/en-us/powershell/scripting/install/installing-powershell?view=powershell-6) instructions
-- To install **LuBuild**, run the following command 
+- To install **[LuBuild](https://botbuilder.myget.org/feed/botbuilder-declarative/package/npm/lubuild)**, run the following command 
 ```
 npm install -g https://botbuilder.myget.org/F/botbuilder-declarative/npm/lubuild/-/1.0.3-preview.tgz
 ```

docs/how-to-send-cards.md

@@ -1,5 +1,5 @@
 # Sending responses with cards 
-A bot communicates with users through message activities which are multi-modal. There are messages which simply consist of plain text and there are also richer message content such as cards. Bot Framework Composer supports [structured response template](https://github.com/microsoft/BotBuilder-Samples/blob/vishwac/master-4.6/experimental/language-generation/docs/structured-response-template.md) with which you can add rich cards to your bot and enhance your bot's design. If you are looking for examples about sending text messages to users please read the [sending messages to users](./how-to-send-messages.md) article. 
+A bot communicates with users through message activities which are multi-modal. There are messages which simply consist of plain text and there are also richer message content such as cards. Bot Framework Composer supports [structured response template](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/structured-response-template.md) with which you can add rich cards to your bot and enhance your bot's design. If you are looking for examples about sending text messages to users please read the [sending messages to users](./how-to-send-messages.md) article. 
 
 In this article, we will cover different types of cards you can define in Composer using [structured response template](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/structured-response-template.md). We use the examples provided in the [RespondingWithCardsSample](https://github.com/microsoft/BotFramework-Composer/tree/master/Composer/packages/server/assets/projects/RespondingWithCardsSample) throughout this article. 
 
@@ -141,12 +141,12 @@ This template "#AllCards" is defined to display all cards when the template is c
 
 ## References
 - [Bot Framework - Cards](https://github.com/microsoft/botframework-sdk/blob/master/specs/botframework-activity/botframework-cards.md)
-- [Add media to messages](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-add-media-attachments?view=azure-bot-service-4.0&tabs=csharp)
+- [Add media to messages](https://docs.microsoft.com/azure/bot-service/bot-builder-howto-add-media-attachments)
 - [Language Generation](./concept-language-generation.md) 
 - [Structured response template](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/structured-response-template.md)
-- [Adaptive Cards overview](https://docs.microsoft.com/en-us/adaptive-cards/)
+- [Adaptive Cards overview](https://docs.microsoft.com/adaptive-cards/)
 - [Adaptive Cards Sample](https://github.com/microsoft/BotBuilder-Samples/tree/master/samples/csharp_dotnetcore/07.using-adaptive-cards)
-- [Adaptive Cards for bot developers](https://docs.microsoft.com/en-us/adaptive-cards/getting-started/bots)
+- [Adaptive Cards for bot developers](https://docs.microsoft.com/adaptive-cards/getting-started/bots)
 
 ## Next
 - Learn [how to define triggers and events](./how-to-define-triggers.md). 

docs/how-to-send-messages.md

@@ -38,10 +38,10 @@ To define a simple text message, use a "-" before the text that you want your bo
 
 You can also define a simple text message with multiple variations. Bot will respond with any of the simple text messages by random. For example: 
 
-     > Greeting template with 2 variations. 
-     # GreetingPrefix
-     - Hi
-     - Hello
+     # SimpleText
+     - Hi, this is simple text
+     - Hey, this is simple text
+     - Hello, this is simple text
 
 ### Text with memory
 To define a text message with memory, you need to **Set a Property** first and then use an expression response like this: 
@@ -127,7 +127,7 @@ Similar to If/Else conditional template, you can define a Switch conditional tem
 In this Switch conditional template, bot will respond in text message `Happy Sunday!`, `Happy Saturday` or `Working day!` based on the returned value of days of the week for a given timestamp. `utcNow()`is a pre-built function which returns current timestamp as string. `dayOfWeek()` is a pre-built function which returns the day of the week from a timestamp. Read more about [pre-built functions](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/common-expression-language/prebuilt-functions.md) in [common expression language](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language). 
 
 ## References 
-- [Send and receive text message](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-send-messages?view=azure-bot-service-4.0)
+- [Send and receive text message](https://docs.microsoft.com/azure/bot-service/bot-builder-howto-send-messages)
 - [Language generation](./concept-language-generation.md)
 - [.lg file format](https://github.com/microsoft/BotBuilder-Samples/blob/master/experimental/language-generation/docs/lg-file-format.md)
 - [Common language expression](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language#readme)

docs/how-to-use-LUIS.md

@@ -67,7 +67,7 @@ To test your bot which you just added LUIS to, click the **Test in Emulator** bu
 
 ## References 
 - [LUIS.ai](https://www.luis.ai/home)
-- [Add natural language understanding to your bot](https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-v4-luis?view=azure-bot-service-4.0&tabs=csharp)
+- [Add natural language understanding to your bot](https://docs.microsoft.com/azure/bot-service/bot-builder-howto-v4-luis)
 - [Events and triggers](./concept-events-and-triggers.md) 
 - [Language Understanding](./concept-language-understanding.md)
 

docs/introduction.md

@@ -0,0 +1,65 @@
+# Introduction to the Bot Framework Composer
+
+The Bot Framework Composer is an integrated development tool that developers and multi-disciplinary teams can use to build bots. It is built using the latest features of the Bot Framework SDK. Within Composer, you'll find everything you need to build a sophisticated conversational experience:
+
+* 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 .
+
+![BF Composer](./media/introduction/composer-overview.png)
+
+Under the hood, Composer harnesses the power of many of the components from the Bot Framework SDK. When building bots in Composer, developers will have access to:
+
+**Adaptive dialogs**
+
+Dialogs provide a way for the bot to manage conversations with the user. The new [Adaptive dialog](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/adaptive-dialog) and the event model simplify sophisticated conversation modelling and helps you focus on the model of the conversation rather than the mechanics of dialog management. 
+
+**Language Understanding (LU)**
+
+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 bots' natural language capabilities using the [lu file format](https://aka.ms/lu-file-format), a simple markdown-like format that makes it easy to define new [intents](concept-language-understanding.md#intents) and provide sample [utterances](concept-language-understanding.md#utterances). In Composer, you can use both regular expression or [LUIS](https://docs.microsoft.com/azure/cognitive-services/luis/what-is-luis) service. 
+
+  ![BF Composer NLU](./media/introduction/intro-nlu.png)
+
+Composer detects changes and updates the bot's cloud-based natural-language understanding (NLU) model automatically so it is always up to date.
+
+**Language Generation (LG)** 
+
+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) system allows developers to create bot replies with a great deal of flexibility.
+
+  ![BF Composer LG](./media/introduction/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.
+
+**QnA Maker**
+
+[QnA Maker](https://docs.microsoft.com/azure/cognitive-services/qnamaker/overview/overview) is a cloud-based Natural Language Processing (NLP) service that easily creates a natural conversational layer over your data. It can be used to find the most appropriate answer for any given natural language input, from your custom knowledge base (KB) of information.
+
+**Bot Framework Emulator**
+
+[Emulator](https://github.com/Microsoft/BotFramework-Emulator/blob/master/README.md) is a desktop application that allows bot developers to test and debug bots built using Composer.
+
+
+## Advantage of developing bots with Composer
+Developers familiar with the Bot Framework SDK will notice differences between bots developed with it and the Bot Framework 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. More information about Adaptive dialog is available on [GitHub](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/adaptive-dialog).
+
+<!--Composer assets such as Dialogs, Language Understanding (LU) training data, and message templates can be managed like any other developer asset. They are files that can be committed to source control and deployed with code updates.-->
+
+The Composer bot projects contain reusable assets in the form of JSON and Markdown files that can be bundled and packaged with a bot's source code. These can be checked into source control systems and deployed along with code updates, such as dialogs, language understanding (LU) training data, and message templates.
+
+## Additional resources
+- [Bot Framework SDK](https://github.com/microsoft/botframework-sdk/blob/master/README.md)
+- [Common Expression Language](https://github.com/microsoft/BotBuilder-Samples/tree/master/experimental/common-expression-language)
+
+## Next steps
+
+* Learn how to [create an echo bot](./quickstart-create-bot.md) using Composer.

docs/tutorial-create-echobot.md → docs/quickstart-create-bot.md

@@ -29,5 +29,5 @@ After opening Composer in a browser click the **Echo Bot** button at the top of
 You've successfully created an echo bot!  
 
 ## Next Steps
-Create a [weather bot](tutorial/bot-tutorial-introduction.md) using Composer.
+Create a [weather bot](tutorial/tutorial-introduction.md) using Composer.
 

docs/setup-yarn.md

@@ -11,32 +11,43 @@ Bot Framework Composer is designed to be a hosted web app. Currently, you need t
 - [Bot Framework Emulator](https://github.com/microsoft/BotFramework-Emulator/releases/latest): latest stable version
 - [.NET Core SDK 2.2](https://dotnet.microsoft.com/download/dotnet-core/2.2): required to test your bot
 
-## Set up yarn for Composer
-To start, clone the Composer GitHub repository. 
-```
-git clone https://github.com/microsoft/BotFramework-Composer.git
-```
-
-After cloning the repo open a terminal and navigate to the Bot Framework Composer folder. Navigate to the **Composer** folder and run the following commands:
-```
-cd Composer 
-yarn 
-```
-  This command gets all dependent packages.
-
-```
-yarn build 
-```
-  This command builds the Composer app. The build process can take few minutes.
+## Installation instructions
+1. To start, open a terminal and clone the Composer GitHub repository. You will use this terminal for the rest of the steps in this section.
+
+    ```
+    git clone https://github.com/microsoft/BotFramework-Composer.git
+    ```
+
+2. After cloning the repository, navigate to the **Bot Framework Composer** folder. Then run the following commands to navigate to the **Composer** folder and get all required packages:
+
+    ```
+    cd Composer
+    yarn 
+    ```
+
+3. Next, run the following command to build the Composer application, this command can take several minutes to finish:
+
+    ```
+    yarn build 
+    ```
 
- If you are having trouble intalling or building Composer run `yarn tableflip`, which removes all of the Composer application's dependencies (node_modules) and reinstalls and rebuilds the application's dependencies. After running `yarn tableflip` run `yarn install` and `yarn build` again. This process can take anywhere from 5-10 minutes.
+   > [!NOTE]
+   > If you are having trouble installing or building Composer run `yarn tableflip`. This will remove all of the Composer application's dependencies (node_modules) and then it reinstalls and rebuilds all of its dependencies. Once completed, run `yarn install` and `yarn build` again. This process generally takes 5-10 minutes.
+
+4. Again using Yarn, start the Composer authoring application and the bot runtime:
+
+    ```
+    yarn startall
+    ```
+
+5. Once you see **Composer now running at:** appear in your terminal, you can run Composer in your browser using the address http://localhost:3000.
+
+    ![browser address](./media/setup-yarn/address.png)
+
+Keep the terminal open as long as you plan to work with the Composer. If you close it, Composer will stop running. 
 
-```
-yarn startall
-```
-  This command starts the Composer authoring application and the bot runtime. 
+The next time you need to run the Composer, all you will need is to run `yarn startall` from the **Composer** directory.
 
-## Open Composer in a browser
-To use Composer open a browser and navigate to the address after the message `Compiled successfully`, as seen below where the address is http://localhost:3000.
+## Next steps
 
-![browser address](./media/setup-yarn/address.png)
+- Create a [echo bot](./quickstart-create-bot.md) using Composer.