Assignment: GitHub and Visual Studio Instructions: Answer the following questions based on your understanding of GitHub and Visual Studio. Provide detailed explanations and examples where appropriate.
Questions: Introduction to GitHub:
What is GitHub, and what are its primary functions and features? Explain how it supports collaborative software development.
GitHub is a web-based platform that provides version control and collaborative software development using Git. It offers a range of features that facilitate project management, code review, and collaboration among developers. Here are some of its primary functions and features:
Primary Functions and Features Version Control:
Git Integration: GitHub is built around Git, a distributed version control system. It allows developers to track changes in their codebase, manage versions, and revert to previous states if needed. Repositories:
Public and Private Repositories: Users can create repositories to store their projects. Public repositories are accessible to everyone, while private repositories are accessible only to specified users. Forking: Users can fork (copy) a repository to their own account to experiment or contribute without affecting the original project. Branching and Merging:
Branches: Developers can create branches to work on features, bug fixes, or experiments separately from the main codebase. This allows multiple versions of a project to exist simultaneously. Pull Requests: When a branch is ready to be merged into the main codebase, a pull request can be created. This allows other developers to review the changes before they are integrated. Collaboration Tools:
Code Review: Pull requests enable code reviews, where team members can comment on specific lines of code, discuss changes, and suggest improvements. Issues and Project Management: GitHub issues can be used to track bugs, enhancements, or tasks. Project boards help organize and prioritize work. Continuous Integration/Continuous Deployment (CI/CD):
GitHub Actions: This feature allows developers to automate workflows, including testing, building, and deploying code. Documentation and Wikis:
README Files: Repositories often include a README file to provide an overview of the project, installation instructions, and usage guidelines. Wikis: GitHub provides wikis for more detailed project documentation. Community and Networking:
Stars and Watchers: Users can star repositories to show appreciation and watch repositories to receive updates. Social Networking Features: GitHub profiles showcase users' contributions, followers, and repositories. Supporting Collaborative Software Development Distributed Development:
GitHub allows multiple developers to work on the same project from different locations. By cloning repositories, they can contribute without being in the same physical location. Code Review and Quality Assurance:
Pull requests and code reviews ensure that multiple sets of eyes review code changes, leading to higher code quality and fewer bugs. Issue Tracking and Project Management:
Issues and project boards help teams organize their work, assign tasks, and track progress, improving collaboration and project management. Community Contributions:
Open source projects can receive contributions from developers worldwide. Forking and pull requests make it easy for external contributors to propose changes. Automation and Integration:
GitHub Actions and integrations with other CI/CD tools streamline the development process, reducing manual work and enabling faster releases.
Repositories on GitHub:
What is a GitHub repository? Describe how to create a new repository and the essential elements that should be included in it.
A GitHub repository (repo) is a digital storage space where a project's files, history, and collaborative activities are managed. It can host anything from simple text files to complex codebases, making it a versatile tool for developers.
Creating a New GitHub Repository To create a new repository on GitHub, follow these steps:
Log In to GitHub:
Ensure you have a GitHub account and log in at github.com. Navigate to Your Profile or Organization:
Click on your profile picture in the top-right corner and select "Your repositories" from the dropdown menu. Alternatively, if creating a repository under an organization, navigate to the organization's page. Click the "New" Button:
On your repositories page, click the green "New" button on the right side. Fill in Repository Details:
Repository Name: Choose a unique and descriptive name for your repository. Description (optional): Add a brief description of your project. Public or Private: Decide whether the repository will be public (visible to everyone) or private (visible only to you and invited collaborators). Initialize Repository (optional but recommended):
Add a README file: A README file provides an overview of the project and is a good place to start documentation. Add a .gitignore file: A .gitignore file specifies which files or directories to ignore in the repository. You can choose a template based on your project's needs (e.g., Node, Python, Java). Choose a License: Select an open-source license if applicable. This helps others understand how they can use your code. Create Repository:
Click the green "Create repository" button. Essential Elements of a GitHub Repository README File:
The README file is the first thing users see when they visit the repository. It should include: Project title and description. Installation instructions. Usage examples. Contribution guidelines. License information. .gitignore File:
This file tells Git which files or directories to ignore in the repository. Common examples include compiled code, dependency directories, and sensitive data. LICENSE File:
If you choose an open-source license, include a LICENSE file detailing the terms under which others can use, modify, and distribute your code. Source Code:
The actual code files for your project, organized in a meaningful directory structure. Commits:
A history of changes made to the codebase. Each commit represents a snapshot of the project at a given point in time. Branches:
Separate lines of development. The default branch is usually main or master, but additional branches can be created for features, fixes, or experiments. Issues:
A way to track tasks, enhancements, and bugs. Issues can be assigned to collaborators, labeled, and organized with milestones. Pull Requests:
Proposals to merge changes from one branch to another. Pull requests facilitate code reviews and discussions around specific changes. Wikis:
Optional, but useful for detailed project documentation, tutorials, and FAQs. Releases:
Packaged versions of the project, often including compiled binaries, source code, and release notes. Actions:
Automated workflows for continuous integration/continuous deployment (CI/CD), testing, and other tasks.
Version Control with Git:
Explain the concept of version control in the context of Git. How does GitHub enhance version control for developers?
Version Control in Git Version control is a system that tracks changes to a file or set of files over time so that you can recall specific versions later. In the context of Git, version control offers several key features:
Tracking Changes: Git records changes made to files, allowing developers to revert to previous states, compare changes over time, and understand the history of a project. Branching and Merging: Git allows the creation of branches, which are separate lines of development. This facilitates experimenting with new features or fixing bugs in isolation. Merging combines branches together, integrating changes. Distributed System: Unlike centralized version control systems, Git is distributed, meaning every developer has a full copy of the repository, including its history. This allows for faster access and better redundancy. Commit History: Each set of changes is stored in a commit, which includes a message describing the changes. This history helps in tracking the evolution of the project. Collaboration: Multiple developers can work on the same project simultaneously. Git handles conflicts that arise when merging changes from different developers. GitHub Enhancements for Version Control GitHub is a platform built around Git that provides additional features to enhance version control and facilitate collaboration among developers:
Remote Repositories: GitHub hosts repositories in the cloud, making them accessible from anywhere. This enables easy sharing and collaboration on projects. Pull Requests: A pull request is a proposed change to a repository. Developers can review and discuss changes before merging them into the main branch. This fosters code review and collaborative development. Issues and Project Management: GitHub includes issue tracking and project management tools, allowing teams to track bugs, plan features, and organize tasks. Actions and CI/CD: GitHub Actions provide continuous integration and continuous deployment (CI/CD) capabilities. Developers can automate workflows, such as running tests and deploying code, directly from the repository. Community and Documentation: GitHub hosts a vast community of developers. It supports Markdown for documentation, making it easy to create and maintain project documentation. Security and Permissions: GitHub offers various security features, including vulnerability alerts, dependency management, and fine-grained access control, ensuring that repositories are secure and managed properly.
Branching and Merging in GitHub:
What are branches in GitHub, and why are they important? Describe the process of creating a branch, making changes, and merging it back into the main branch.
Branches in GitHub (and Git, the version control system it uses) are pointers to snapshots of your changes. They are essential for managing and developing features, fixing bugs, and experimenting without affecting the main codebase. Branches allow multiple developers to work on different tasks simultaneously without interfering with each other's work.
Why Branches are Important Isolation: Each branch is an independent line of development, enabling you to work on new features or bug fixes without affecting the main code. Collaboration: Multiple team members can work on different branches and merge their changes back into the main codebase when ready. Versioning: Branches help keep the history of changes organized and make it easier to manage different versions of a project. Experimentation: Developers can create branches to try out new ideas and discard them if they don't work out, without impacting the main codebase. Process of Working with Branches Creating a Branch:
Using Command Line:
git checkout -b new-branch-name This command creates a new branch named new-branch-name and switches to it.
Using GitHub Interface:
Go to your repository on GitHub. Click the branch dropdown menu. Enter a unique branch name in the field. Click "Create branch: new-branch-name" from main. Making Changes:
Once on the new branch, you can make changes to the files, add new features, or fix bugs. After making changes, you need to commit them:
git add . git commit -m "Description of changes" Pushing Changes to GitHub:
Push your branch to GitHub to share your changes with others or to back them up:
git push origin new-branch-name Creating a Pull Request:
Go to your repository on GitHub. Click the "Pull requests" tab. Click the "New pull request" button. Select the branch you want to merge from and the branch you want to merge into (usually main). Review the changes, add a descriptive title and comments, and click "Create pull request". Review and Merge:
Team members can review the pull request, discuss any issues, and request changes. Once the pull request is approved, you can merge it into the main branch: Click "Merge pull request". Confirm the merge by clicking "Confirm merge". Optionally, delete the branch after merging to keep the repository clean.
Pull Requests and Code Reviews:
What is a pull request in GitHub, and how does it facilitate code reviews and collaboration? Outline the steps to create and review a pull request.
A pull request (PR) in GitHub is a feature that enables developers to notify project maintainers about changes they'd like to be merged into the codebase. It's a crucial part of collaborative software development and code review processes, allowing team members to propose, discuss, and integrate changes efficiently.
How a Pull Request Facilitates Code Reviews and Collaboration Centralized Discussion: Pull requests provide a centralized platform where team members can discuss the proposed changes. This includes inline comments, general feedback, and approval/rejection of the changes.
Code Quality: Through code reviews, team members can ensure that the proposed changes adhere to the project's coding standards and best practices.
Continuous Integration: Pull requests can be integrated with continuous integration (CI) tools to automatically test changes before they are merged. This helps in identifying issues early.
Documentation: Pull requests often include descriptions, links to relevant issues, and other documentation that helps team members understand the context and purpose of the changes.
Version Control: By using pull requests, it's easier to track what changes were made, by whom, and why. This creates a clear history and audit trail for the project.
Steps to Create and Review a Pull Request Creating a Pull Request Fork the Repository: If you don't have write access to the repository, fork it to your own GitHub account.
Clone the Repository: Clone the repository (original or forked) to your local machine.
git clone https://github.com/username/repository.git cd repository Create a New Branch: Create a new branch for your changes.
git checkout -b feature-branch Make Changes: Implement the changes you want to propose. This could include new features, bug fixes, documentation updates, etc.
Commit Changes: Commit your changes with a descriptive message.
git add . git commit -m "Description of changes" Push Changes: Push your branch to your GitHub repository.
git push origin feature-branch Open a Pull Request:
Navigate to the original repository on GitHub. Click on the "Pull Requests" tab. Click the "New pull request" button. Select the branch you want to merge from (feature-branch) and the branch you want to merge into (usually main or master). Provide a title and description for your pull request. Click "Create pull request". Reviewing a Pull Request Open the Pull Request: Navigate to the "Pull Requests" tab in the repository and select the pull request you want to review.
Examine the Changes:
Review the list of commits. Look at the files changed and examine the diffs (differences between the old and new code). Add Comments: You can add comments on specific lines of code or general comments on the pull request. This is where you can ask questions, suggest improvements, and discuss the changes.
Request Changes or Approve:
If changes are needed, request changes and provide specific feedback. If the changes look good, approve the pull request. Run CI Tests: Ensure that all CI tests pass (if applicable).
Merge the Pull Request:
Once the pull request is approved and all tests pass, you can merge it into the main branch. You can choose to "Merge pull request" (create a merge commit), "Squash and merge" (combine all commits into one), or "Rebase and merge" (rebase commits on top of the base branch). Close the Branch: After merging, delete the feature branch to keep the repository clean.
GitHub Actions:
Explain what GitHub Actions are and how they can be used to automate workflows. Provide an example of a simple CI/CD pipeline using GitHub Actions.
GitHub Actions is a feature within GitHub that allows you to automate tasks related to your software development lifecycle. It provides a way to create custom workflows directly within your GitHub repository using a combination of predefined and custom actions. These workflows can be triggered by various events such as code pushes, pull requests, releases, and more.
Key Features of GitHub Actions: Automation: Automate tasks like building, testing, and deploying code. Customizable Workflows: Define workflows using YAML syntax to suit your specific needs. Event-Driven: Trigger workflows based on events such as push, pull request, issue creation, etc. Extensibility: Use pre-built actions from the GitHub Marketplace or create your own. Integration: Seamlessly integrates with GitHub repositories and other services. Example of a Simple CI/CD Pipeline using GitHub Actions Let's create a simple CI/CD pipeline for a Node.js project. This pipeline will run tests and deploy the code whenever changes are pushed to the main branch.
Step 1: Create a Workflow File Create a directory named .github/workflows in your repository if it doesn't already exist. Inside this directory, create a file named ci-cd-pipeline.yml.
Step 2: Define the Workflow Add the following content to ci-cd-pipeline.yml:
name: CI/CD Pipeline
on: push: branches: - main pull_request: branches: - main
jobs: build: runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v2
- name: Set up Node.js
uses: actions/setup-node@v2
with:
node-version: '14'
- name: Install dependencies
run: npm install
- name: Run tests
run: npm test
- name: Build project
run: npm run build
- name: Deploy to production
if: github.ref == 'refs/heads/main'
run: |
echo "Deploying to production server"
# Add your deployment script/commands here
Explanation: Workflow Name: The name of the workflow is CI/CD Pipeline. Triggers: The workflow triggers on push events to the main branch. The workflow also triggers on pull_request events to the main branch. Jobs: The build job runs on the latest version of Ubuntu. Steps: Checkout code: Uses the actions/checkout action to clone the repository. Set up Node.js: Uses the actions/setup-node action to set up Node.js version 14. Install dependencies: Runs npm install to install project dependencies. Run tests: Runs npm test to execute tests. Build project: Runs npm run build to build the project. Deploy to production: Deploys the code to the production server if the code is pushed to the main branch. You can replace the echo command with your actual deployment script. Introduction to Visual Studio:
What is Visual Studio, and what are its key features? How does it differ from Visual Studio Code?
Visual Studio and Visual Studio Code are both products from Microsoft, but they serve different purposes and target different user bases. Here's a breakdown of each:
Visual Studio Visual Studio is an integrated development environment (IDE) designed primarily for professional developers working on large-scale, enterprise-level applications. It supports a wide range of programming languages, including C#, VB.NET, C++, Python, JavaScript, and more.
Key Features: Comprehensive IDE: Full-fledged development environment with extensive features for managing large codebases and multiple projects. Debugging and Diagnostics: Advanced debugging tools, including IntelliTrace, a historical debugging tool that allows developers to record and replay the execution of their application. Code Analysis and Refactoring: Built-in tools for code analysis, refactoring, and maintaining code quality. Team Collaboration: Integrated tools for team collaboration, including Azure DevOps (formerly known as Team Foundation Server), Git, and other version control systems. Windows Development: Extensive support for Windows development, including Universal Windows Platform (UWP) and WPF (Windows Presentation Foundation) applications. Extensions and Customization: A rich ecosystem of extensions and plugins available through the Visual Studio Marketplace. Database Integration: Tools for database development and management, including SQL Server integration. Cloud Development: Integrated support for Azure development, making it easier to build and deploy cloud-based applications. Testing Tools: Comprehensive testing tools, including unit testing, load testing, and automated UI testing.
Visual Studio Code Visual Studio Code (VS Code) is a lightweight, open-source code editor designed for a wide range of development tasks. It is particularly popular among web developers and those working with scripting languages and small to medium-sized projects.
Differences Between Visual Studio and Visual Studio Code Purpose and Target Audience:
Visual Studio: Aimed at professional developers working on large, complex projects requiring extensive tooling and support for enterprise-level development. Visual Studio Code: Aimed at developers who need a fast, lightweight, and highly customizable code editor for a wide range of development tasks. Features and Functionality:
Visual Studio: Offers a comprehensive set of tools for end-to-end application development, including advanced debugging, testing, and collaboration features. Visual Studio Code: Focuses on providing a streamlined and flexible editing experience with essential coding and debugging features, and relies on extensions for additional functionality. Performance:
Visual Studio: More resource-intensive due to its extensive feature set, making it better suited for powerful development machines. Visual Studio Code: Optimized for speed and performance, making it suitable for less powerful hardware and quick development tasks. Platform Support:
Visual Studio: Primarily focused on Windows development but also supports macOS with Visual Studio for Mac. Visual Studio Code: Fully cross-platform, supporting Windows, macOS, and Linux equally. Cost:
Visual Studio: Comes in various editions, including Community (free for small teams and open-source projects), Professional, and Enterprise (paid versions with additional features). Visual Studio Code: Completely free and open-source.
Integrating GitHub with Visual Studio:
Describe the steps to integrate a GitHub repository with Visual Studio. How does this integration enhance the development workflow?
Steps to Integrate a GitHub Repository with Visual Studio Install Git for Windows:
Download and install Git from git-scm.com. Ensure Git is added to the system PATH during installation. Install Visual Studio:
Download and install Visual Studio from the official website. During installation, make sure to include the “Git for Windows” and “GitHub Extension for Visual Studio” components. Sign In to GitHub:
Open Visual Studio. Go to View > Team Explorer. In the Team Explorer pane, click on the plug icon to connect to a repository. Select Manage Connections and then Connect to GitHub. Sign in to your GitHub account using your credentials. Clone a Repository:
In Team Explorer, click on the Clone button under the Local Git Repositories section. Enter the URL of the GitHub repository you want to clone and choose a local path for the repository. Click Clone to download the repository to your local machine. Create a New Repository:
If you want to create a new repository, go to File > New > Repository. Choose the GitHub option, enter the repository name, and provide a description. Select a local path and click Create and Push to create the repository on GitHub and push your initial commit. Work with the Repository:
After cloning or creating a repository, you can manage your code using the Team Explorer pane. Use the Changes section to view and commit changes. Use the Sync section to push and pull changes from GitHub. Use the Branches section to create, switch, and manage branches. Collaborate and Manage Issues:
Visual Studio integrates with GitHub Issues and Pull Requests. Use the GitHub pane in Team Explorer to view and manage issues and pull requests. Create new branches and pull requests directly from within Visual Studio. Enhancing the Development Workflow Seamless Version Control:
Git integration allows developers to track changes, revert to previous states, and collaborate efficiently. Branching and merging become more manageable with Visual Studio’s graphical interface. Efficient Collaboration:
Developers can work on different branches simultaneously, making it easier to manage features and bug fixes. Pull requests facilitate code reviews and discussions, ensuring code quality and consistency. Integrated Issue Tracking:
Direct integration with GitHub Issues helps manage tasks, bugs, and feature requests within the development environment. Developers can link commits and pull requests to specific issues, providing better context and traceability. Streamlined Workflow:
The integration reduces context switching by providing all necessary tools within a single application. Automated workflows and continuous integration (CI) can be triggered from GitHub actions, enhancing the development lifecycle. Improved Code Quality:
Built-in tools for linting, testing, and debugging within Visual Studio help maintain high code standards. Continuous integration with GitHub allows automated testing and deployment, catching issues early in the development process.
Debugging in Visual Studio:
Explain the debugging tools available in Visual Studio. How can developers use these tools to identify and fix issues in their code?
Visual Studio offers a comprehensive set of debugging tools that developers can use to identify and fix issues in their code. Here are some of the key tools and features:
- Breakpoints Function: Allow developers to pause the execution of their program at specific points. Usage: Click in the left margin next to a line of code or use the F9 key. Conditional breakpoints can be set to pause execution only when certain conditions are met.
- Watch Windows Function: Monitor the values of variables and expressions as you step through the code. Usage: Add variables or expressions to the Watch window by right-clicking and selecting "Add Watch" or by typing directly into the window.
- Immediate Window Function: Evaluate expressions, execute statements, and print variable values during debugging. Usage: Open via Debug > Windows > Immediate or press Ctrl+Alt+I.
- Locals Window Function: Displays variables that are in the current scope, along with their values. Usage: Automatically populated and updated as you step through the code.
- Autos Window Function: Displays variables used around the current breakpoint or the current statement. Usage: Automatically shows relevant variables without needing to add them manually.
- Call Stack Window Function: Shows the sequence of function calls that led to the current point in the execution. Usage: Navigate through the call stack to inspect the state of the program at different levels.
- Threads Window Function: View and control the threads running in the application. Usage: Switch between threads to debug multithreaded applications.
- Exception Settings Function: Configure how the debugger handles exceptions. Usage: Specify which exceptions to break on and which to ignore via Debug > Windows > Exception Settings.
- Diagnostic Tools Function: Provides performance and diagnostic information, such as memory usage and CPU utilization. Usage: Open via Debug > Windows > Show Diagnostic Tools.
- Memory Windows Function: Inspect memory values directly. Usage: Access Memory 1, Memory 2, etc., through Debug > Windows > Memory.
- Data Tips Function: Hover over variables during debugging to see their current value. Usage: Simply hover over a variable with the mouse pointer. Using These Tools to Identify and Fix Issues Set Breakpoints: Begin by setting breakpoints at strategic locations in your code where you suspect issues might be occurring.
Run the Debugger: Start the application in Debug mode (F5) and let it run until it hits a breakpoint.
Inspect Variables: Use the Locals, Autos, and Watch windows to inspect variable values. Use Data Tips for quick checks.
Step Through Code: Use step over (F10), step into (F11), and step out (Shift+F11) to navigate through your code line by line and see how the program state changes.
Analyze Call Stack: If an issue seems to originate from a different part of the program, use the Call Stack window to trace back through the function calls.
Handle Exceptions: Use Exception Settings to break on specific exceptions, helping you pinpoint where and why an exception is thrown.
Evaluate Expressions: Use the Immediate window to test and evaluate expressions, check values, and even modify variables at runtime.
Monitor Performance: Use Diagnostic Tools to monitor application performance and identify memory leaks or CPU-intensive operations.
Collaborative Development using GitHub and Visual Studio:
Discuss how GitHub and Visual Studio can be used together to support collaborative development. Provide a real-world example of a project that benefits from this integration.
GitHub and Visual Studio (VS) are powerful tools that, when used together, greatly enhance collaborative development. Here's how they support collaborative workflows:
Integration and Features Version Control with GitHub:
Repository Management: GitHub hosts code repositories, enabling version control through Git. Developers can clone repositories, create branches, and manage pull requests. Pull Requests: Developers can review, comment on, and merge changes, facilitating collaboration and ensuring code quality. Issues and Project Boards: GitHub issues and project boards help in tracking tasks, bugs, and features, enhancing project management and collaboration. Development Environment with Visual Studio:
Git Integration: Visual Studio provides built-in Git support, allowing developers to perform Git operations such as cloning, committing, branching, and pushing without leaving the IDE. Code Review and Collaboration: Developers can work on code reviews directly from Visual Studio, leveraging GitHub’s pull request system. Extensions: Visual Studio supports various extensions that enhance GitHub integration, such as GitHub Extension for Visual Studio, which provides additional functionalities like creating and reviewing pull requests. Continuous Integration/Continuous Deployment (CI/CD):
GitHub Actions: Automate workflows with GitHub Actions, enabling CI/CD pipelines. These can trigger builds, tests, and deployments automatically on code changes. Azure DevOps Integration: Visual Studio integrates seamlessly with Azure DevOps, providing more advanced CI/CD pipelines and project management tools. Real-World Example: Microsoft’s Visual Studio Code (VS Code) Project Overview: Visual Studio Code (VS Code) is a popular open-source code editor developed by Microsoft. The development of VS Code is a prime example of how GitHub and Visual Studio can be used together for collaborative development.
How Integration Supports Development:
Repository Management and Collaboration:
GitHub Repository: VS Code's source code is hosted on GitHub, allowing developers worldwide to contribute. The repository includes documentation, issue tracking, and project boards to manage features and bugs. Community Contributions: Developers can fork the repository, make changes, and submit pull requests. Maintainers review these pull requests, provide feedback, and merge approved changes. Development Workflow:
Cloning and Branching: Developers clone the VS Code repository locally using Visual Studio. They create branches for new features or bug fixes. Local Development: Using Visual Studio, developers code, debug, and test their changes. They can leverage the integrated terminal and debugging tools in VS. Commit and Push: Changes are committed to the local branch and pushed to GitHub. Visual Studio’s Git integration simplifies these steps. Code Review and Continuous Integration:
Pull Requests and Code Reviews: Developers submit pull requests on GitHub. Code reviews are conducted using both GitHub’s web interface and Visual Studio’s tools. Automated checks and CI pipelines (set up with GitHub Actions or Azure DevOps) validate the code changes. CI/CD Pipelines: GitHub Actions run automated tests and builds on every pull request and push. This ensures code quality and readiness for deployment. Community and Documentation:
Issue Tracking and Discussion: GitHub issues are used to track bugs, feature requests, and discussions. Contributors and maintainers engage with the community to improve the project. Documentation: Project documentation is hosted in the GitHub repository, making it accessible for contributors to update and improve.
Submission Guidelines: Your answers should be well-structured, concise, and to the point. Provide real-world examples or case studies wherever possible. Cite any references or sources you use in your answers. Submit your completed assignment by [due date].