{"id":19199,"date":"2026-09-22T12:16:11","date_gmt":"2026-09-22T12:16:11","guid":{"rendered":"https:\/\/www.examlabs.com\/certification\/?p=19199"},"modified":"2026-09-22T12:16:11","modified_gmt":"2026-09-22T12:16:11","slug":"microsoft-gh-900-practice-test-questions-and-exam-dumps-part10-q181-200","status":"publish","type":"post","link":"https:\/\/www.examlabs.com\/certification\/microsoft-gh-900-practice-test-questions-and-exam-dumps-part10-q181-200\/","title":{"rendered":"Microsoft GH-900 Practice Test Questions and Exam Dumps Part10 Q181-200"},"content":{"rendered":"

View Full <\/b>Microsoft GH-900 Exam Dumps<\/b><\/a> and Practice Test Dumps<\/b><\/h2>\n

 <\/p>\n

Question 181<\/b><\/h3>\n

Which GitHub setting controls whether a repository permits forking?<\/b><\/p>\n

    \n
  1. Discussion moderation<\/span><\/li>\n
  2. Issue type configuration<\/span><\/li>\n
  3. Forking policy<\/span><\/li>\n
  4. Release retention<\/span><\/li>\n<\/ol>\n

    Correct Answer: 3<\/b><\/p>\n

    Explanation:<\/b><\/p>\n

    A repository\u2019s forking policy determines whether users can create forks and, depending on the configuration, where those forks may be created. Forks provide separate copies of repositories that can be used for independent development while maintaining a relationship with the upstream repository. Forking controls are especially relevant for organizations that need to manage how source code is duplicated or shared. Other repository settings address different capabilities, such as discussions, issues, or releases. Understanding repository-level policies helps users configure collaboration according to organizational requirements while preserving appropriate control over source-code distribution.<\/span><\/p>\n

    Question 182<\/b><\/h3>\n

    What does a GitHub repository owner primarily control?<\/b><\/p>\n

      \n
    1. Repository administration and settings<\/span><\/li>\n
    2. Individual commit timestamps<\/span><\/li>\n
    3. Markdown rendering rules<\/span><\/li>\n
    4. Git object compression<\/span><\/li>\n<\/ol>\n

      Correct Answer: 1<\/b><\/p>\n

      Explanation:<\/b><\/p>\n

      A repository owner or administrator can manage important repository settings, permissions, collaboration controls, and other administrative features. Administrative access is broader than ordinary contribution rights because it allows configuration changes that affect the repository itself. Commit timestamps are associated with Git history rather than being controlled through repository administration. Markdown rendering is handled by GitHub\u2019s rendering system, while Git object compression belongs to Git\u2019s internal storage mechanisms. Understanding administrative responsibilities helps GH-900 learners distinguish between actions performed by contributors and actions requiring elevated repository permissions.<\/span><\/p>\n

      Question 183<\/b><\/h3>\n

      Which GitHub feature lets contributors propose changes from a separate copy of a repository?<\/b><\/p>\n

        \n
      1. Repository topics<\/span><\/li>\n
      2. Forks<\/span><\/li>\n
      3. Release notes<\/span><\/li>\n
      4. Project fields<\/span><\/li>\n<\/ol>\n

        Correct Answer: 2<\/b><\/p>\n

        Explanation:<\/b><\/p>\n

        A fork creates a separate copy of a repository under another user or organization account. Contributors can make changes within the fork without directly modifying the original repository. They can then propose those changes to the upstream project, commonly through a pull request. This workflow is widely used in open-source development because contributors may not have direct write access to the original repository. Repository topics organize repositories by subject, release notes document published versions, and project fields help manage work. Forking therefore provides an important collaboration mechanism within GitHub\u2019s distributed development model.<\/span><\/p>\n

        Question 184<\/b><\/h3>\n

        What is the main purpose of GitHub repository custom properties?<\/b><\/p>\n

          \n
        1. Store executable workflow commands<\/span><\/li>\n
        2. Add structured metadata to repositories<\/span><\/li>\n
        3. Replace repository branches<\/span><\/li>\n
        4. Manage local Git credentials<\/span><\/li>\n<\/ol>\n

          Correct Answer: 2<\/b><\/p>\n

          Explanation:<\/b><\/p>\n

          Custom properties allow organizations to attach structured metadata to repositories. Organizations can use them to categorize repositories according to internal needs, such as department, application type, compliance classification, or lifecycle stage. Because these values are structured, they can support organization-wide management and filtering activities more effectively than informal descriptions alone. Custom properties do not replace branches, execute workflow commands, or manage local Git credentials. Understanding repository metadata is useful for organizations managing many repositories because consistent classification can make administration, governance, and reporting more systematic.<\/span><\/p>\n

          Question 185<\/b><\/h3>\n

          Which Git command displays changes that have not yet been staged?<\/b><\/p>\n

            \n
          1. git branch<\/span><\/li>\n
          2. git remote<\/span><\/li>\n
          3. git diff<\/span><\/li>\n
          4. git tag<\/span><\/li>\n<\/ol>\n

            Correct Answer: 3<\/b><\/p>\n

            Explanation:<\/b><\/p>\n

            The git diff command can display differences between the working tree and other Git states, including changes that have not yet been staged. This makes it useful for reviewing modifications before adding them to the staging area. By examining the output, developers can identify unintended edits, verify expected changes, and prepare for a commit. git branch manages branches, git remote displays or manages remote repository references, and git tag works with named points in Git history. Reviewing differences before staging is a practical step in maintaining clean and intentional commits.<\/span><\/p>\n

            Question 186<\/b><\/h3>\n

            Which repository permission allows a user to manage repository settings?<\/b><\/p>\n

              \n
            1. Read<\/span><\/li>\n
            2. Triage<\/span><\/li>\n
            3. Write<\/span><\/li>\n
            4. Maintain<\/span><\/li>\n<\/ol>\n

              Correct Answer: 4<\/b><\/p>\n

              Explanation:<\/b><\/p>\n

              The Maintain role provides broader repository management capabilities than ordinary read or write access and is designed for users who need to manage aspects of a repository without necessarily receiving every administrative privilege. Repository permissions are divided into roles so organizations can provide access appropriate to different responsibilities. Read access is intended primarily for viewing, while Triage focuses on managing issues and pull requests without code modification. Write access supports contribution activities. Understanding permission levels helps teams follow least-privilege principles and assign repository access according to actual responsibilities.<\/span><\/p>\n

              Question 187<\/b><\/h3>\n

              What does a GitHub issue template primarily provide?<\/b><\/p>\n

                \n
              1. A consistent structure for new issues<\/span><\/li>\n
              2. Automatic repository deletion<\/span><\/li>\n
              3. A replacement for pull requests<\/span><\/li>\n
              4. A private Git database<\/span><\/li>\n<\/ol>\n

                Correct Answer: 1<\/b><\/p>\n

                Explanation:<\/b><\/p>\n

                An issue template gives contributors a predefined structure when creating issues. Templates can prompt users to provide important information such as reproduction steps, expected behavior, environment details, or feature requirements. Consistent issue formatting helps maintainers understand reports more efficiently and reduces incomplete submissions. An issue template does not delete repositories, replace pull requests, or create a private Git database. GitHub supports structured issue templates as part of repository collaboration and project-management workflows. Teams can use different templates for bug reports, feature requests, or other recurring issue categories.<\/span><\/p>\n

                Question 188<\/b><\/h3>\n

                Which GitHub capability can automatically assign metadata when an issue is created?<\/b><\/p>\n

                  \n
                1. Git tags<\/span><\/li>\n
                2. Issue forms<\/span><\/li>\n
                3. Repository archives<\/span><\/li>\n
                4. Commit signatures<\/span><\/li>\n<\/ol>\n

                  Correct Answer: 2<\/b><\/p>\n

                  Explanation:<\/b><\/p>\n

                  Issue forms allow repositories to collect structured information from users when they open issues. They can include fields that guide contributors toward providing specific details and can help maintainers process incoming reports more consistently. Issue forms are particularly useful when projects need predictable information for different issue types. Git tags identify specific points in repository history, archives preserve repository contents in a non-active state, and commit signatures provide information about commit verification. Issue forms therefore support structured issue intake rather than Git history management or repository preservation.<\/span><\/p>\n

                  Question 189<\/b><\/h3>\n

                  What does git revert create?<\/b><\/p>\n

                    \n
                  1. A new branch without history<\/span><\/li>\n
                  2. A deleted remote reference<\/span><\/li>\n
                  3. A new commit that reverses an earlier change<\/span><\/li>\n
                  4. A repository clone with modified metadata<\/span><\/li>\n<\/ol>\n

                    Correct Answer: 3<\/b><\/p>\n

                    Explanation:<\/b><\/p>\n

                    git revert creates a new commit that reverses the changes introduced by an earlier commit. Unlike rewriting history, reverting preserves the existing commit history while adding a new change that counteracts the selected commit. This makes it particularly useful when changes have already been shared with others and rewriting published history would cause collaboration problems. A revert should therefore be distinguished from commands that remove or rewrite commits. Understanding this distinction is important when managing collaborative repositories because preserving shared history can reduce synchronization problems among contributors.<\/span><\/p>\n

                    Question 190<\/b><\/h3>\n

                    Which GitHub feature helps organizations review security risks across repositories?<\/b><\/p>\n

                      \n
                    1. Security overview<\/span><\/li>\n
                    2. Repository topics<\/span><\/li>\n
                    3. Contribution graph<\/span><\/li>\n
                    4. Project board layout<\/span><\/li>\n<\/ol>\n

                      Correct Answer: 1<\/b><\/p>\n

                      Explanation:<\/b><\/p>\n

                      GitHub\u2019s security overview provides organizations with visibility into security-related information across repositories. Depending on the enabled security capabilities, it can help administrators understand areas requiring attention, such as dependency or code-security findings. This centralized perspective is valuable when an organization manages many repositories and needs to monitor security posture consistently. Repository topics classify projects by subject, contribution graphs visualize activity, and project board layouts organize work. Security-focused views are therefore intended for identifying and managing repository security information rather than organizing development tasks or categorizing project themes.<\/span><\/p>\n

                      Question 191<\/b><\/h3>\n

                      What does a Git lightweight tag identify?<\/b><\/p>\n

                        \n
                      1. A repository collaborator<\/span><\/li>\n
                      2. A specific Git reference<\/span><\/li>\n
                      3. A workflow permission<\/span><\/li>\n
                      4. A project milestone<\/span><\/li>\n<\/ol>\n

                        Correct Answer: 2<\/b><\/p>\n

                        Explanation:<\/b><\/p>\n

                        A lightweight Git tag is a simple reference to a specific point in Git history. It can be used to give a memorable name to a commit, such as marking a particular state of development. Lightweight tags contain less annotation information than annotated tags, which can include metadata and messages. Tags are useful when developers need stable references to important points in a repository\u2019s history. They are separate from GitHub collaborators, workflow permissions, and project milestones. Understanding tags helps users distinguish source-control references from GitHub project-management and access-control features.<\/span><\/p>\n

                        Question 192<\/b><\/h3>\n

                        Which GitHub feature can display project work in a table-style view?<\/b><\/p>\n

                          \n
                        1. Git branches<\/span><\/li>\n
                        2. Repository topics<\/span><\/li>\n
                        3. GitHub Projects<\/span><\/li>\n
                        4. Commit history<\/span><\/li>\n<\/ol>\n

                          Correct Answer: 3<\/b><\/p>\n

                          Explanation:<\/b><\/p>\n

                          GitHub Projects can organize work using different views, including table-style presentations. A table view allows teams to inspect project items using rows and fields, making it useful for tracking structured information across multiple work items. Projects can connect issues and pull requests with planning information while providing flexible ways to organize work. Git branches manage lines of source-code development, repository topics categorize repositories, and commit history records changes made to code. Project views are therefore designed for planning and tracking work rather than directly managing Git history or repository classification.<\/span><\/p>\n

                          Question 193<\/b><\/h3>\n

                          What is the purpose of GitHub repository transfer?<\/b><\/p>\n

                            \n
                          1. Move a repository to another owner<\/span><\/li>\n
                          2. Convert issues into commits<\/span><\/li>\n
                          3. Replace all repository branches<\/span><\/li>\n
                          4. Remove repository history<\/span><\/li>\n<\/ol>\n

                            Correct Answer: 1<\/b><\/p>\n

                            Explanation:<\/b><\/p>\n

                            Repository transfer allows a repository to move from one user or organization to another owner while preserving important repository content and history. This can be useful when ownership responsibilities change, when a project moves into an organization, or when repositories are reorganized. Transfer procedures can involve permission and ownership considerations, so administrators should review the requirements before performing the operation. Transferring a repository is fundamentally different from deleting history, replacing branches, or converting issues into commits. It is an administrative capability for changing ownership while maintaining the repository as a development resource.<\/span><\/p>\n

                            Question 194<\/b><\/h3>\n

                            Which GitHub feature helps identify the person who introduced a specific line of code?<\/b><\/p>\n

                              \n
                            1. Repository topics<\/span><\/li>\n
                            2. Git blame<\/span><\/li>\n
                            3. Project milestones<\/span><\/li>\n
                            4. Issue labels<\/span><\/li>\n<\/ol>\n

                              Correct Answer: 2<\/b><\/p>\n

                              Explanation:<\/b><\/p>\n

                              Git blame identifies the commit and author associated with each line of a file. Developers can use it to investigate when a particular line was introduced and which commit modified it. This can be useful when understanding historical changes, tracing the origin of a behavior, or locating relevant commits for further investigation. Git blame is not intended for categorizing repositories, managing milestones, or labeling issues. It works with Git history to provide line-level attribution. Because attribution reflects repository history, it should be interpreted alongside the surrounding commits and development context.<\/span><\/p>\n

                              Question 195<\/b><\/h3>\n

                              What does a GitHub repository environment commonly represent?<\/b><\/p>\n

                                \n
                              1. A local operating-system account<\/span><\/li>\n
                              2. A Git commit category<\/span><\/li>\n
                              3. A deployment target with configuration controls<\/span><\/li>\n
                              4. A Markdown document type<\/span><\/li>\n<\/ol>\n

                                Correct Answer: 3<\/b><\/p>\n

                                Explanation:<\/b><\/p>\n

                                A GitHub environment commonly represents a deployment target or stage where workflows can run with specific configuration and protection settings. Environments can have associated secrets, variables, and approval requirements. This allows teams to distinguish deployment destinations such as testing or production while applying different controls to each. Environments are part of GitHub\u2019s automation and deployment capabilities rather than Git commit classification or Markdown formatting. Understanding environments helps users recognize how GitHub Actions can connect automated workflows with controlled deployment processes.<\/span><\/p>\n

                                Question 196<\/b><\/h3>\n

                                Which Git command creates a new branch without switching to it?<\/b><\/p>\n

                                  \n
                                1. git branch<\/span><\/li>\n
                                2. git checkout<\/span><\/li>\n
                                3. git merge<\/span><\/li>\n
                                4. git reset<\/span><\/li>\n<\/ol>\n

                                  Correct Answer: 1<\/b><\/p>\n

                                  Explanation:<\/b><\/p>\n

                                  The git branch command can create a new branch without automatically switching the working directory to that branch. For example, creating a branch with this command establishes the new reference while leaving the currently checked-out branch active. Commands such as git switch -c can both create and switch to a new branch, which is a different behavior. git merge combines changes from branches, while git reset moves references or modifies the staging and working states depending on its mode. Understanding these distinctions helps prevent accidental branch changes during development.<\/span><\/p>\n

                                  Question 197<\/b><\/h3>\n

                                  What is the primary role of GitHub repository webhooks?<\/b><\/p>\n

                                    \n
                                  1. Store encrypted repository backups<\/span><\/li>\n
                                  2. Send event notifications to external systems<\/span><\/li>\n
                                  3. Replace Git authentication<\/span><\/li>\n
                                  4. Generate local branches<\/span><\/li>\n<\/ol>\n

                                    Correct Answer: 2<\/b><\/p>\n

                                    Explanation:<\/b><\/p>\n

                                    GitHub webhooks notify external systems when selected repository events occur. For example, an external service can receive information when code is pushed, an issue changes, or a pull request is created. This allows GitHub activity to trigger integrations, automation, monitoring, or other external processing. Webhooks do not serve as repository backups, replace Git authentication, or create local branches. Their primary function is event-driven communication between GitHub and external services. Understanding webhooks is useful for recognizing how repositories can integrate with systems outside the GitHub platform.<\/span><\/p>\n

                                    Question 198<\/b><\/h3>\n

                                    Which GitHub feature records a repository\u2019s published versions?<\/b><\/p>\n

                                      \n
                                    1. Issue forms<\/span><\/li>\n
                                    2. Repository labels<\/span><\/li>\n
                                    3. Releases<\/span><\/li>\n
                                    4. Team discussions<\/span><\/li>\n<\/ol>\n

                                      Correct Answer: 3<\/b><\/p>\n

                                      Explanation:<\/b><\/p>\n

                                      GitHub Releases provide a way to publish and organize specific versions of software based on Git tags. A release can include release notes and downloadable assets, giving users a clear representation of a published version. Releases are commonly used to communicate changes between software versions and distribute associated files. Issue forms are designed for structured issue submission, labels classify issues or other items, and team discussions support communication. Releases therefore connect source-control milestones with a user-facing mechanism for documenting and distributing published software versions.<\/span><\/p>\n

                                      Question 199<\/b><\/h3>\n

                                      Which Git command temporarily saves uncommitted working changes?<\/b><\/p>\n

                                        \n
                                      1. git stash<\/span><\/li>\n
                                      2. git status<\/span><\/li>\n
                                      3. git show<\/span><\/li>\n
                                      4. git describe<\/span><\/li>\n<\/ol>\n

                                        Correct Answer: 1<\/b><\/p>\n

                                        Explanation:<\/b><\/p>\n

                                        git stash temporarily stores changes that have not been committed so the working directory can be cleaned for another task. This is useful when a developer needs to switch contexts without creating an incomplete commit. The stashed changes can later be reapplied when the original work is resumed. git status reports the current state of the working tree, git show displays information about Git objects such as commits, and git describe generates human-readable names based on repository references. Stashing is therefore a temporary workflow mechanism rather than a permanent history operation.<\/span><\/p>\n

                                        Question 200<\/b><\/h3>\n

                                        What does GitHub\u2019s contribution graph primarily visualize?<\/b><\/p>\n

                                          \n
                                        1. Repository ownership transfers<\/span><\/li>\n
                                        2. Development activity over time<\/span><\/li>\n
                                        3. Repository storage capacity<\/span><\/li>\n
                                        4. Organization billing history<\/span><\/li>\n<\/ol>\n

                                          Correct Answer: 2<\/b><\/p>\n

                                          Explanation:<\/b><\/p>\n

                                          The GitHub contribution graph visualizes a user\u2019s contribution activity over time. It can provide a calendar-style representation of activity associated with qualifying contributions, helping users see patterns in their participation. The graph is not intended to show repository storage capacity, ownership transfers, or billing information. Contribution visualization can be useful for understanding activity history, although the graph does not represent every aspect of a developer\u2019s work. GH-900 learners should distinguish contribution tracking from repository administration, organizational billing, and storage-management features.<\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

                                          View Full Microsoft GH-900 Exam Dumps and Practice Test Dumps   Question 181 Which GitHub setting controls whether a repository permits forking? Discussion moderation Issue type configuration Forking policy Release retention Correct Answer: 3 Explanation: A repository\u2019s forking policy determines whether users can create forks and, depending on the configuration, where those forks may be […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"closed","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":[],"categories":[1648,1647],"tags":[],"_links":{"self":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19199"}],"collection":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/comments?post=19199"}],"version-history":[{"count":1,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19199\/revisions"}],"predecessor-version":[{"id":19200,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/posts\/19199\/revisions\/19200"}],"wp:attachment":[{"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/media?parent=19199"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/categories?post=19199"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.examlabs.com\/certification\/wp-json\/wp\/v2\/tags?post=19199"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}