s/Actions/actions, closes #2

Author: hectorsector

responses/01_explain-environment.md

@@ -1,6 +1,6 @@
 ## Anatomy of GitHub Actions
 
-GitHub Actions is a unique world that lives alongside your repository.  It is one made up of many moving parts and having a general understanding of these parts will help us understand the behavior we are going to program into our Action.
+GitHub Actions is a unique world that lives alongside your repository.  It is one made up of many moving parts and having a general understanding of these parts will help us understand the behavior we are going to program into our action.
 
 From 30,000 feet GitHub Actions is made up of the following components, with each component having its own complexities:
 
@@ -24,7 +24,7 @@ When a repository is configured with a **workflow** file, like we just created,
 1.  Your GitHub repository listens for an event
 2.  That event triggers a workflow run which starts a runner
 3.  The runner, regardless of the hosting method, is responsible for carrying out the jobs which are defined.
-4.  A job is series of steps, which can be Actions or commands
+4.  A job is series of steps, which can be actions or commands
 5.  When the steps complete a report is generated and can be viewed by anyone with access to the repository.
 
 

responses/01_explain-syntax.md

@@ -37,7 +37,7 @@ Let's take a second to talk about each of the pieces that we see here:
   - This is our first block of instructions.  We are defining our first job for this workflow.
   - In this case, the job has been named `build`
   - We also define the runner for the job as `runs-on: ubuntu-latest`
-  - Finally we define the steps for this job which can either rely on specific Actions, or run commands directly.  As we can see there are three steps which show a mixed usage of Actions and Commands.
+  - Finally we define the steps for this job which can either rely on specific actions, or run commands directly.  As we can see there are three steps which show a mixed usage of actions and commands.
     - `uses: actions/checkout@v1`
     - ```
       name: Run a one-line script

responses/01_welcome-issue.md

@@ -29,15 +29,15 @@ Currently, there are **two** supported ways to create your own GitHub Actions:
 As you can see we aren't necessarily limited to JavaScript even though it is the focal point for this course.
 
 
-### Creating vs consuming Actions
+### Creating vs consuming actions
 
 Although we are going to focus on creating and consuming a custom action, in this course we will also be consuming some actions that have been made public to us.  Because your workflows will most likely do the same, I found it important to show you where to look for actions that already exist.
 
 After all, for each time we need to reinvent the wheel for our specific use-case there are a handful of times when we are better off using a wheel that's already made!
 
 - The [GitHub Actions Marketplace](https://github.com/marketplace?type=actions) is the primary place to find open-source actions that the community has written and released.  Your action, should you choose to release it, could also reside here one day, ready to be consumed by the world!
 - The [GitHub Actions Repository](https://github.com/actions) is where you can find actions that are written by GitHub.  We will leverage an action named `[checkout](https://github.com/actions/checkout)` from this repository as we go through this course.  I'll explain more about what it does when we use it!
-- Your repositories may also contain **private actions** and they will most likely be located in the `.github/actions` directory in the root of your repository.  **This is the convention we will be using as we learn how to create our own Action.**
+- Your repositories may also contain **private actions** and they will most likely be located in the `.github/actions` directory in the root of your repository.  **This is the convention we will be using as we learn how to create our own action.**
 
 ### Using actions and Learning Lab
 

responses/02_explain-steps.md

@@ -1,31 +1,31 @@
 ## Digging into a step
 
-As I mentioned earlier, a step is a task that is either an Action or a Command.  This can be slightly confusing, so I want to take a little time to ensure I explain it to you before moving on.
+As I mentioned earlier, a step is a task that is either an action or a command.  This can be slightly confusing, so I want to take a little time to ensure I explain it to you before moving on.
 
 #### Actions
 
 Actions are powerful.  They are small programs written in either JavaScript or running inside of Docker containers, that add some functionality to your repository.
 
-The things you can do with Actions are limited only by your imagination.  Want to send a tweet every time you tag a release?  What about ordering 🍕just by creating an issue?
+The things you can do with actions are limited only by your imagination.  Want to send a tweet every time you tag a release?  What about ordering 🍕just by creating an issue?
 
-Let's not forget the more practical usage of Actions, testing the source code of a repository or letting your team know that you are out of office 🏝 when they @ mention your name in issues or pull requests.
+Let's not forget the more practical usage of actions, testing the source code of a repository or letting your team know that you are out of office 🏝 when they @ mention your name in issues or pull requests.
 
 You can define an action's inputs, outputs, and environment variables to create reusable building blocks for your workflow.
 
-Actions are portable.  You are free to publish your Actions to the [Actions Marketplace](https://github.com/marketplace?type=actions) where others can use your creation in their workflows!  You can also share actions without publishing them to the marketplace by referencing the repository that contains the Actions code!
+Actions are portable.  You are free to publish your actions to the [Actions Marketplace](https://github.com/marketplace?type=actions) where others can use your creation in their workflows!  You can also share actions without publishing them to the marketplace by referencing the repository that contains the actions code!
 
 Actions can even run commands 😏
 
 📖Learn more [About Actions](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/about-actions)
 
 #### Commands
 
-Commands are useful in the own respect, but are much more limited than Actions.  
+Commands are useful in the own respect, but are much more limited than actions.  
 
 Think about the tasks you might do from the command line of your local machine.  Maybe you run `npm install` to install all of the dependencies for your project before running your unit tests.  Maybe you run `docker build` to execute a Dockerfile.
 
 You can accomplish the same set of tasks inside of a workflow but using `run` as a step in your job.  
 
 Commands are not easily shareable.  There is no central location where you can consume the popular commands used in workflows.  You do not have access to fine tuning the inputs, outputs or environment variables.
 
-This does not mean commands offer no value in a workflow, but you should use them wisely and if you find yourself reusing the same commands repeatedly, consider turning them into Actions.
+This does not mean commands offer no value in a workflow, but you should use them wisely and if you find yourself reusing the same commands repeatedly, consider turning them into actions.

responses/02_modify-workflow.md

@@ -1,6 +1,6 @@
 ## Edit the current workflow
 
-Currently `my-workflow.yml` is not set up correctly for our use-case.  It worked great for allowing us to take a high-level look at workflows, but if we want to use our custom Actions there are some changes that we have to make to it.
+Currently `my-workflow.yml` is not set up correctly for our use-case.  It worked great for allowing us to take a high-level look at workflows, but if we want to use our custom actions there are some changes that we have to make to it.
 
 ### :keyboard: Activity: Modify my-workflow.yml to remove boilerplate steps
 

responses/02_workflow-results.md

@@ -18,7 +18,7 @@ The right-hand panel shows real-time logging of the steps executed by the `build
 
 GitHub Actions will **always** add the `Set up job` and `Complete job` steps to each job in a workflow.  These steps are what configure the [virtual environment](https://help.github.com/en/actions/automating-your-workflow-with-github-actions/virtual-environments-for-github-hosted-runners) before running your steps and shut it down properly before moving onto the next job in your workflow.
 
-If you recall, we had 1 step that used an Action and 2 steps that ran commands, can you identify which step used the Action?
+If you recall, we had 1 step that used an action and 2 steps that ran commands, can you identify which step used the action?
 
 If you said `actions/checkout@v1` you'd be correct 😄!
 

responses/03_reference-actions.md

@@ -1,6 +1,6 @@
 ## Finishing the workflow
 
-@{{user.login}} you're doing great so far 😄!  You've had to do a lot of workflow set up so we can begin writing custom Actions.  We have just one more thing to add to our `my-workflow.yml` file before we get to the Action side of things.
+@{{user.login}} you're doing great so far 😄!  You've had to do a lot of workflow set up so we can begin writing custom actions.  We have just one more thing to add to our `my-workflow.yml` file before we get to the action side of things.
 
 #### Recap
 
@@ -10,18 +10,18 @@ Before we make our final workflow change let's do a quick recap about what we've
 | ----------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | Created `my-workflow.yml` inside of `.github/workflows` directory | GitHub repositories look in the `.github/workflows` folder for workflow files.                                                                                                                                                                           |
 | Used a templated workflow                                         | GitHub provides many templates for workflow files.  This is a great spot to look when setting up a new workflow.  If you can't find what you are looking for, you can always click the `setup a workflow yourself` button for a minimal starter template |
-| Workflow environment                                              | You learned, from a high level, how a repository uses a workflow file to run commands or Actions based on triggers.  You also learned that where these commands or Actions execute is something that can be specified                                    |
+| Workflow environment                                              | You learned, from a high level, how a repository uses a workflow file to run commands or actions based on triggers.  You also learned that where these commands or actions execute is something that can be specified                                    |
 | Workflow syntax                                                   | You were briefly introduced to the workflow YAML syntax.                                                                                                                                                                                                 |
 
 If that seems like a lot of things just to get started... well, it is!  GitHub Actions is a robust platform designed to automate a wide range of tasks for your repositories.
 
-If you'd like to see more examples of workflows and Actions then check out these Learning Lab courses all about GitHub Actions:
+If you'd like to see more examples of workflows and actions then check out these Learning Lab courses all about GitHub Actions:
 
 - [GitHub Actions: Continuous Integration](https://lab.github.com/githubtraining/github-actions:-continuous-integration)
 - [GitHub Actions: Continuous Delivery](https://lab.github.com/githubtraining/github-actions:-continuous-delivery)
 - [GitHub Actions: Publish to GitHub Packages](https://lab.github.com/githubtraining/github-actions:-publish-to-github-packages)
 
-### :keyboard: Activity: Modify my-workflow.yml to run our custom Action
+### :keyboard: Activity: Modify my-workflow.yml to run our custom action
 
 1. [Edit]({{workflowFile}}) the `my-workflow.yml`.
 1. Add a new `step:` and `name:` it `hello-action`

responses/04_on-to-actions.md

@@ -1,7 +1,7 @@
 ## Great Job 👍
 
-Your workflow is now set up to execute two Actions when any `push` event happens on this repository.
+Your workflow is now set up to execute two actions when any `push` event happens on this repository.
 
-For now, this workflow will fail.  It fails because we have not yet created the `hello-world` Action, so this is expected.
+For now, this workflow will fail.  It fails because we have not yet created the `hello-world` action, so this is expected.
 
-Head [over here]({{issueUrl}}) to get started in creating the `hello-world` Action!
+Head [over here]({{issueUrl}}) to get started in creating the `hello-world` action!

responses/05_create-metadata.md

@@ -1,26 +1,26 @@
 ## Enough talk, lets do this!
 
-Now that we know what Action metadata is, let's create the metadata for our current **hello-world** Action.
+Now that we know what action metadata is, let's create the metadata for our current **hello-world** action.
 
 I will be doing this from within [Visual Studio Code](https://code.visualstudio.com/) and that will be reflected in the images that I show you.  If you are using a different editor then your screen may look different.
 
 ### :keyboard: Activity: Create the metadata file
 
 💡All of the following steps take place inside of the `.github/actions/hello-world` directory. 
 
-We will start with using the parameters that are **required** and later implement some optional parameters as our Action evolves.
+We will start with using the parameters that are **required** and later implement some optional parameters as our action evolves.
 
 1. Create a file named `action.yml`
-2. Use the `name` parameter to name your Action `"my hello action"`
-3. Next, add a `description` parameter and give it a value of `"say hello with Actions"`
+2. Use the `name` parameter to name your action `"my hello action"`
+3. Next, add a `description` parameter and give it a value of `"say hello with GitHub Actions"`
 4. Lastly, define the `run` parameter to use `"node12"` to execute the `"main.js"`
 
     <details><summary>View the complete file</summary>
 
     ```yaml
     name: "my hello action"
 
-    description: "say hello with Actions"
+    description: "say hello with GitHub Actions"
 
     runs:
       using: "node12"

responses/05_explain-metadata.md

@@ -1,36 +1,36 @@
 ## Action metadata
 
 #### The failing workflow
-Before we jump into the details of Action metadata, it might be helpful to examine our workflow to understand the order that things happen.  I have attached a screenshot below of the most recent workflow run, you can also follow along by clicking on the [Actions tab]({{actionsUrl}}) for your repository.
+Before we jump into the details of action metadata, it might be helpful to examine our workflow to understand the order that things happen.  I have attached a screenshot below of the most recent workflow run, you can also follow along by clicking on the [Actions tab]({{actionsUrl}}) for your repository.
 
 ![](https://i.imgur.com/FPOjK3R.png)
 
-Notice that our third workflow step, the one that is looking for our Action is failing.  We expect this, but the magic ✨is in the error message!  
+Notice that our third workflow step, the one that is looking for our action is failing.  We expect this, but the magic ✨is in the error message!  
 
 That step is looking for a specific file, and in our case it's looking for the `action.yml` file.  It's not looking for a JavaScript file or a `config.yml` file.
 
 Because that file is non-existent in the `hello-world` directory we see this error.  So let's start by talking about, and creating, that `action.yml` file.
 
-#### The need to know of Action metadata
+#### The need to know of action metadata
 
 
 Every GitHub Action that we write needs to be accompanied by a metadata file.  This file has a few rules to it, lets outline those now:
 
 - Filename **must** be `action.yml`
-- Required for both Docker container and JavaScript Actions
+- Required for both Docker container and JavaScript actions
 - Written in YAML syntax
 
-This file defines the following information about your Action:
+This file defines the following information about your action:
 
 
 
 | Parameter   | Description                                                                                                                                            |      Required      |
 | ----------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | :----------------: |
-| Name        | The name of your Action. Helps visually identify the Actions in a job.                                                                                 | :white_check_mark: |
-| Description | A summary of what your Action does.                                                                                                                    | :white_check_mark: |
+| Name        | The name of your action. Helps visually identify the actions in a job.                                                                                 | :white_check_mark: |
+| Description | A summary of what your action does.                                                                                                                    | :white_check_mark: |
 | Inputs      | Input parameters allow you to specify data that the action expects to use during runtime. These parameters become environment variables in the runner. |         ❌          |
 | Outputs     | Specifies the data that subsequent actions can use later in the workflow after the action that defines these outputs has run.                          |         ❌          |
-| Runs        | The command to run when the Action executes.                                                                                                           | :white_check_mark: |
+| Runs        | The command to run when the action executes.                                                                                                           | :white_check_mark: |
 | Branding    | You can use a color and Feather icon to create a badge to personalize and distinguish your action in GitHub Marketplace.                               |         ❌          |
 
 ---