Welcome back to season two of GitHub for Beginners, a series designed to help you navigate GitHub more confidently! So far, we’ve explored how to use GitHub Copilot and some of its essential features. Today, we will be learning all about large language models (LLMs) and the basics of prompt engineering.

LLMs are powerful, and the way we interact with them via prompts matters. For example, have you ever tried asking an LLM a question, but it can’t really figure out what you’re trying to ask? Understanding the power of prompts (and the limitations that come with them) can help you become even more productive.

In this post, we’ll explore:

• How LLMs work and how prompts are processed.
• How to engineer the most effective prompts.
• How to troubleshoot prompts when we don’t get the outcomes we want.

Let’s get started!

What’s an LLM?

Large language models are a type of AI that are trained on a large (hence the name) amount of text data to understand and generate human-like language.

By predicting the next word in a sentence based on the context of the words that came before it, LLMs respond to humans in a way that is relevant and coherent. Sort of like an ultra-smart autocomplete!

When it comes to using LLMs, there are three important things to understand:

• Context: This is the surrounding information that helps an LLM understand what you’re talking about. Just like when you have a conversation with a friend, the more context you offer, the more likely the conversation will make sense.

• Tokens: For LLMs, text is broken down into units of tokens. This could be a word, part of a word, or even just one single letter. AI models process tokens to generate responses, so the number of tokens you use with an LLM can impact its response. Too few tokens can lead to a lack of context, but too many could overwhelm the AI model or run into its built-in token limits.

• Limitations: LLMs are powerful, but not all-powerful. Instead of understanding language like humans, LLMs rely on patterns and probabilities from training data. Taking a deeper dive into training data is beyond the scope of this post, but as a general rule, the ideal data set is diverse and broad. Models are never perfect—sometimes they can hallucinate, provide incorrect answers, or give nonsensical responses.

What is a prompt?

A prompt is a natural language request that asks an LLM to perform a specific task or action. A prompt gives the model context via tokens, and works around the model’s potential limitations, so that the model can give you a response. For example, if you prompt an LLM with “Write a JavaScript function to calculate the factorial of a number,” it will use its training data to give you a function that accomplishes that task.

Depending on how a specific model was trained, it might process your prompt differently, and present different code. Even the same model can produce different outputs. These models are nondeterministic, which means you can prompt it the same way three times and get three different results. This is why you may receive different outputs from various models out in the world, like OpenAI’s GPT, Anthropic’s Claude, and Google’s Gemini.

Now that we know what a prompt is, how do we use prompts to get the outputs we want?

What is prompt engineering?

Imagine that a friend is helping you complete a task. It’s important to give them clear and concise instructions if there’s a specific way the task needs to be done. The same is true for LLMs: a well-crafted prompt can help the model understand and deliver exactly what you’re looking for. The act of crafting these prompts is prompt engineering.

That’s why crafting the right prompt is so important: when this is done well, prompt engineering can drastically improve the quality and relevance of the outputs you get from an LLM.

Here are a few key components of effective prompting:

• An effective prompt is clear and precise, because ambiguity can confuse the model.
• It’s also important to provide enough context, but not too much detail, since this can overwhelm the LLM.
• If you don’t get the answer you’re expecting, don’t forget to iterate and refine your prompts!

Let’s try it out!

Example: How to refine prompts to be more effective
Imagine you’re using GitHub Copilot and say: Write a function that will square numbers in a list in a new file with no prior code to offer Copilot context. At first, this seems like a straightforward and effective prompt. But there are a lot of factors that aren’t clear:

• What language should the function be written in?
• Do you want to include negative numbers?
• Will the input ever have non-numbers?
• Should it affect the given list or return a new list?

How could we refine this prompt to be more effective? Let’s change it to: Write a Python function that takes a list of integers and returns a new list where each number is squared, excluding any negative numbers.

This new prompt is clear and specific about what language we want to use, what the function should do, what constraints there are, and the expected input type. When we give GitHub Copilot more context, the output will be better aligned with what we want from it!

Just like coding, prompt engineering is about effective communication. By crafting your prompts thoughtfully, you can more effectively use tools like GitHub Copilot to make your workflows smoother and more efficient. That being said, working with LLMs means there will still be some instances that call for a bit of troubleshooting.

How to improve results when prompting LLMs

As you continue working with GitHub Copilot and other LLM tools, you may occasionally not get the output you want. Oftentimes, it’s because your initial prompt wasn’t specific enough. Here are a few scenarios you might run into when prompting LLMs.

Prompt confusion

It’s easy to mix multiple requests or be unclear when writing prompts, which can confuse the model you’re using. Say you highlight something in Visual Studio Code and tell Copilot fix the errors in this code and optimize it. Is the AI supposed to fix the errors or optimize it first? For that matter, what is it supposed to optimize for? Speed, memory, or readability?

To solve this, you need to break your prompt down into concrete steps with context. We can adjust this prompt by separating our asks: First, fix the errors in the code snippet. Then, optimize the fixed code for better performance. Building a prompt iteratively makes it more likely that you’ll get the result you want because the specific steps the model needs to take are more clear.

Token limitations

Remember, tokens are units of words or partial words that a model can handle. But there’s a limit to how many tokens a given model can handle at once (this varies by model, too—and there are different models available with GitHub Copilot). If your prompt is too long or the expected output is very extensive, the LLM may hallucinate, give a partial response, or just fail entirely.

That means you want to keep your prompts concise. Again, it’s important to iterate on smaller sections of your prompt, but it’s also crucial to only provide necessary context. Does the LLM actually need an entire code file to return your desired output, or would just a few lines of code in a certain function do the trick? Instead of asking it to generate an entire application, can you ask it to make each component step-by-step?

Assumption errors

It’s easy to assume that the LLM knows more than it actually does. If you say add authentication to my app, does the model know what your app does? Does it know which technologies you may want to use for authentication?

When crafting a prompt like this, you’ll need to explicitly state your requirements. This can be done by outlining specific needs, mentioning best practices if you have any, and once again, iterating with edge cases and restraints. By stating your requirements, you’ll help ensure the LLM doesn’t overlook critical aspects of your request when it generates the output.

Prompt engineering best practices

Prompt engineering can be tricky to get the hang of, but you’ll get better the more you do it. Here are some best practices to remember when working with GitHub Copilot or any other LLM:

• Give the model enough context while considering any limitations it might have.
• Prompts should be clear, concise, and precise for the best results.
• If you need multiple tasks completed, break down your prompts into smaller chunks and iterate from there.
• Be specific about your requirements and needs, so that the model accurately understands the constraints surrounding your prompt.

Your next steps

We covered quite a bit when it comes to prompt engineering. We went over what LLMs are and why context is important, defined prompt engineering and crafting effective prompts, and learned how to avoid common pitfalls when working with large language models.

• If you want to watch this demo in action, we’ve created a YouTube tutorial that accompanies this blog.
• If you have any questions, pop them in the GitHub Community thread and we’ll be sure to respond.
• Remember to sign up for GitHub Copilot (if you haven’t already) to get started for free.
• Join us for the next part of the series where we’ll walk through security best practices.

Happy coding!

The post GitHub for Beginners: How to get LLMs to do what you want appeared first on The GitHub Blog.

Welcome to season two of GitHub for Beginners! Last season, we introduced you to GitHub and helped you go from beginner to confidently using the platform. This season, we’re continuing your journey by leading you into the world of AI with GitHub Copilot.

Imagine having a pair programmer who never takes a break and knows plenty of programming languages. That’s Copilot, which is powered by a number of large language models (LLMs) that you can choose from and is the industry’s most widely adopted AI coding tool. Today, we’ll be exploring everything you need to know to get started using it.

In this post, we will:

• Get you up and running with GitHub Copilot
• Give you an overview of the different usage tiers from free to enterprise
• Help you use GitHub Copilot for the very first time!

Let’s get started!

What is GitHub Copilot?

Powered by generative AI and LLM models, GitHub Copilot is an AI pair programmer that helps you write code faster. It’s designed to help with programming tasks and acts as your assistant while working in your editor and on github.com.

In addition to code completion, GitHub Copilot can help you:

• Write code using natural language prompts
• Understand shell commands
• Describe changes in your pull requests
• Debug and refactor code
• … and much, much more!

You can use GitHub Copilot with a variety of programming languages, and it’s available in VS Code, Visual Studio, JetBrains IDEs, Neovim, XCode, on GitHub Mobile, in your terminals, and on github.com!

This leads us to our next question: how do you access GitHub Copilot?

What are the different tiers of GitHub Copilot?

Before using GitHub Copilot, you need to have a GitHub account and—if you want more than the free version—a Copilot license.

There are four options available:

• For individuals:
  • GitHub Copilot Free
  • Copilot Pro
• For professionals and organizations:
  • Copilot Business
  • Copilot Enterprise
• For students and educators:
  • Free access to Copilot Pro through GitHub Education
• For popular open source project maintainers:
  • GitHub Copilot Pro (which is also free in our open source program)

If you’ve never used GitHub Copilot before, sign up for the free tier to give it a try! Once you do that, you can install and use GitHub Copilot in your IDE and on github.com.

How to install GitHub Copilot in VS Code and JetBrains

How you install GitHub Copilot depends on what IDE you’re using. GitHub Copilot currently works with several IDEs on the market—but for the purpose of this article, we’ll focus on two popular IDEs: VS Code and JetBrains.

If you’re using VS Code:

1. Navigate to the Extensions Marketplace and search for “GitHub Copilot.” Click on the “GitHub Copilot” extension, authored by GitHub and then click Install. This will install two extensions: GitHub Copilot and GitHub Copilot Chat.
2. Once installed, sign into VS Code with your GitHub account that has access to GitHub Copilot. (If you didn’t previously authorize VS Code in your GitHub account, you’ll need to sign in to GitHub in VS Code.)
3. And you’re all set!

A few helpful notes in case you run into any issues:

• You can sign in to GitHub in VS Code by selecting the “Accounts” menu in the Activity Bar, and then “Sign in to Sync Settings” to use GitHub Copilot.
• In your browser, you can grant GitHub the necessary permissions needed for GitHub Copilot. Click “Continue” to authorize VS Code to approve.

When you return to your editor, you’ll notice a Copilot icon at the top next to the Command Center, and a Copilot icon in the bar at the bottom of the editor window. If you click the icon at the bottom, it might ask you to select the account you want to use, then show menu options and display a ready status.

If you see Copilot icons next to the Command Center and at the bottom of the VS Code window, you’ve successfully installed GitHub Copilot and are ready to use it.

If you’re using a JetBrains IDE:

We’ll be using PyCharm to install GitHub Copilot in JetBrains IDE. Here’s how:

1. Open your editor of choice and navigate to the plugins marketplace. Search for “GitHub Copilot” and click Install, then restart your IDE.
2. When you open a project, you’ll see a Copilot icon on both the right side of your editor and the bottom, with a “ready” status. Once you see two icons on the left: GitHub Copilot with a question mark and another with a chat icon, you’ll know you successfully installed GitHub Copilot.
   1. Select the first icon, GitHub Copilot with a question mark, to get an overview of what GitHub Copilot is, along with a welcome message.
   2. Select the second icon, GitHub Copilot with a chat icon, to find help for programming-related inquiries.

A few notes that may be helpful:

• If you didn’t previously authorize JetBrains in your GitHub account, you’ll need to sign in to GitHub in your editor.
• Alternatively, you can click on the Copilot icon at the bottom and select “Login to GitHub.”
• In your browser, you can grant GitHub the necessary permissions needed for GitHub Copilot. Click “copy and open” to approve the permissions needed.
• Press CMD+V or CTRL+V to paste the code, click continue and finally select “Authorize GitHub Copilot plugin.”

Return to your editor and you will see a message that GitHub Copilot has been successfully installed.

Now, it’s time to authorize GitHub Copilot Chat.

1. Click on the chat icon and click the “Authorize” button.
2. Select “Copy and Open” and paste the code in your browser.
3. Click “Authorize GitHub Copilot for JetBrains IDEs.”
4. Return to your editor and you should see a greeting from GitHub Copilot Chat.

Once you’ve completed these steps, you’re ready to use GitHub Copilot in JetBrains.

How to use code completions in GitHub Copilot

We now have Copilot installed in our editors, so let’s explore how to use features like code complete. In our example, we’ll be using Python in VS Code.

Here’s a short walkthrough on using code complete in GitHub Copilot:

1. Create a new file called validate_email.py.
2. Type import re and press Enter. Copilot will suggest code based on what it believes you want to do. For example, since the file is named validate_email.py Copilot will provide code for validating an email.
3. Click the tab key and accept the suggestion.
4. Hit the Return key to have Copilot provide the main function to run the code.
5. Hover over the suggested code, then click the arrows to see multiple suggestions.
6. Click on the three dots (…) at the end of the suggestion and select “Open Completions Panel” to see even more suggestions.

One thing to keep in mind: because we’re using Copilot for inline code completion, the gray text represents ghost text with Copilot’s suggestions. If you try this later and get a different response, no worries! When working with GitHub Copilot or any LLM, responses are nondeterministic—which means a different result may be generated every time (so you may get a different result than what’s shown in the examples).

How to use Copilot Chat

GitHub Copilot Chat can provide more context into the code and what it means. Maybe you’re seeing the code for the first time and need to be brought up to speed quickly.

Open Copilot Chat, type /explain, and hit Enter. Copilot will give you a detailed explanation of what’s happening in the code. You’ll see that Copilot Chat has a view of the currently opened file as indicated by the eye icon next to the file name at the bottom of the chat window.

Let’s take a look at another example. Imagine you want to improve the regex and allow users to enter multiple email addresses.

Open Copilot Chat and type, “allows users to enter email multiple addresses for validation and also improve the regex to be more robust.” Once you send the request, Copilot will give you a plan, an updated code block, and a list of suggested changes. Hover over the code block, click the “Apply in Editor” button to accept the changes, and GitHub Copilot will make the updates for you.

What’s the difference between GitHub Copilot and other copilots?

Time to address the elephant in the room: what’s the difference between GitHub Copilot and all the other copilots out there?

Well, GitHub Copilot is specifically designed for programming. And because it works where you work—both in your editor and on github.com—there’s no need to go back and forth between your browser or another app and your code. You’re able to stay focused without having to context switch between your editor and your AI assistant. And remember, when you hear “GitHub Copilot,” it’s referring to your personal AI pair programmer.

Your next steps

Thanks for joining our deep dive into GitHub Copilot.

• If you want to watch this demo in action, we’ve created a YouTube tutorial that accompanies this blog.
• If you have any questions, pop them in the GitHub Community thread and we’ll be sure to respond.
• Remember to sign up for GitHub Copilot (if you haven’t already) to get started for free.
• Join us for the next part of the series where we’ll walk through essential features of GitHub Copilot.

Happy coding!

The post GitHub for Beginners: How to get started with GitHub Copilot appeared first on The GitHub Blog.

We believe that software is at the center of human progress and that all software builds on the work of others, especially open source, through an interconnected community of developers. We need to level the playing field to spark innovation on a global level, and that includes helping early developers get the best start possible. We believe that all developers can solve problems, innovate, and create collaboratively through code. This is why we aspire to empower 1 billion individuals to become developers, and work to help break down barriers to entry for those who wish to join the field and participate in the community.

To achieve this goal, it’s important to provide a safe, inclusive environment for first time developers of all ages. GitHub Education supports the next generation of developers by providing free access to tools like the GitHub Student Developer Pack and GitHub Copilot to ensure they have everything they need to start building, including the most up-to-date industry standard tooling. More than 453,000 GitHub Education users were first-time contributors to open projects on the platform over the past year. They’re following in the footsteps of 7 million students and teachers who also used GitHub at the beginning of their coding journey.

Joining forces with Hack Club

GitHub Education is proud to work with Hack Club, one of the largest global networks of highly technical youth, to introduce the next generation of developers to open source. Hack Club enables 39,400 teen hackers from around the world to code together. Through open source contributions, students learn valuable skills and join a vibrant community that fosters innovation, creativity, and collaboration. As part of our partnership, GitHub provided swag prizes, dedicated promotion, and operational funding to support Hack Club’s Summer Arcade, which reached 19,000 high school students, who shipped 2,000 projects and logged over 135,000 hours of coding! If you’re a parent or teacher looking to encourage your teen to explore the world of coding and open source, Hack Club’s High Seas is the next place where students can ship projects with friends.

What makes Hack Club’s programs even more special is that they’re organized by teens who understand what makes a program exciting and engaging to their peers. By joining, teens can make friends, work on cool projects, and earn rewards along the way. With 400+ Hack Clubs globally, access barriers are being shattered: 40% of attendees at in-person events are girls, 30% of the Hack Club community are girls, and 50% of the HCB (fiscal sponsorship) organizations are female-led.

Hack Club at GitHub Universe

As you may have seen at this year’s GitHub Universe, our Chief Operating Officer Kyle Daigle’s Universe Day 2 Keynote was all about how collaborators in our community, from the enterprise to open source developer, student to professional, play a critical role in the developer ecosystem. Highlighted in this talk were projects created by Hack Club teens including Acon Lin, an 18-year-old Hack Clubber who built Summer Arcade joined Kyle on stage to launch High Seas, the next project to engage young tech leaders and spark them to ship projects and win prizes.

What’s next and how to get involved

Open source software is both foundational to tech today and is what will continue to fuel the future. With nearly all developers using or experimenting with AI coding tools, we expect open source developers and students to drive the next wave of AI innovation. Partnerships with organizations like Hack Club help increasing numbers of teen developers get excited about building for the future.

Similar to the Summer Arcade, High Seas is an online campaign running from October through January. Teens simply sign up, ship projects, and trade them for prizes. It’s a great place for a first-time coder to begin logging hours and meet new friends!

Why is this approach so impactful?

1. Self-directed projects: Teens can start their own coding, electrical, or mechanical projects. If they’re not sure where to begin, Hack Club offers “You Ship, We Ship” challenges to get them started.
2. A global community: With Hack Club chapters in 22 countries, students can connect with peers, participate in live AMAs with builders, and gain inspiration from a global network of young developers.

The journey of teens in open source

Open source projects offer a unique opportunity for new developers to learn new skills and contribute to software projects—almost immediately! These projects allow teens to work on real-world problems, contribute to meaningful solutions, and see their work impact a global community. The skills gained—ranging from coding and problem-solving to teamwork and project management—are invaluable.

• Take the story of Sam Poder. At just 15, Sam created Hack Club’s Summer of Making. “Finding an online community full of people who share my interests changed my life,” he says. Today, Sam is studying Computer Science at Berkeley, a testament to the long-term benefits of early engagement in open source.

• Zaahir (@zaaahir), 18, from England, created a full-fledged operating system in C++, equipped with networking from the kernel level. It was created to replace outdated educational operating systems currently being used in universities. His project was the Hack Club Arcade Showcase 2024 winner, selected from over 2,000 projects.

• Lopa (@lopa-ok), 17, from Egypt, built a new version of meta tic-tac-toe on GitHub Pages where you play 9 games in a 3×3 grid of tic-tac-toe games. It’s a mind-bending game that’s really fun!

• Charlie (@crn), 14, from Massachusetts, made a low-cost, lightweight Unmanned Aerial Vehicle from the ground up—the autopilot code, pcb traces, and model files are all there for other high schoolers to replicate and fork.

Signing up is easy. Just visit Hack Club to get started. You can also donate to help support teens.

The post Supporting the next generation of developers appeared first on The GitHub Blog.

We’re thrilled to celebrate the third year of Git Commit, our annual program dedicated to bridging the tech skills gap and empowering students across the country. This year, we’re also proud to launch Git Commit 101, our first free online AI course in Spanish, available to students and educators year-round.

Why Uruguay

With one of the highest rates of internet connectivity in Latin America (over 70%), Uruguay leads the region in digital transformation and education. Its commitment to fostering innovation is reflected in its top-five ranking in the Global Innovation Index among Latin American economies, excelling in knowledge outputs and human capital development.

Programs like Git Commit thrive in this environment, aligning perfectly with the nation’s mission to build a knowledge-based economy and create opportunities for underserved communities.

Introducing Git Commit 101

This year, in partnership with Microsoft AI for Good, we launched Git Commit 101, a free online AI course streamed live from Microsoft’s AI Co-Innovation Lab in Montevideo—the only lab of its kind in the Southern Hemisphere. The course introduces students to AI fundamentals, GitHub tools, and GitHub Copilot, equipping them with skills they can apply immediately. The online course has already attracted more than 20,000 viewers in its first few weeks.

Our in-person Git Commit event was held at Centros Educativos Impulso and ORT University. Together we hosted 125 students, many from vulnerable backgrounds, from 13 participating institutions. Students heard from inspiring speakers including Dr. Juan M. Lavista Ferres, Corporate Vice President and Chief Data Scientist of the AI for Good Lab at Microsoft, Alejandro Pazos, Microsoft’s Country Manager in Uruguay, Eliane Elbaum, Manager of the Microsoft AI Co-Innovation Lab, and Mario Rodriguez, GitHub’s Chief Product Officer.

“It’s very important that each of you receive the best education possible, because it’s through education and technology that we’re going to open doors. It’s how we’ll ultimately reach for the sky,” Rodriguez shared during the closing ceremony at the LATU Technology Laboratory in Montevideo.

The power of education and innovation

Together, we’re not only teaching students how to use technology, but also empowering them to build a future where innovation is inclusive, accessible, and sustainable. We’re excited to see what this year’s participants go on to do, and look forward to Git Commit 2025.

Let’s continue to reach for the sky—together. 🚀

The post Building LATAM’s future tech workforce with AI appeared first on The GitHub Blog.

Welcome back to GitHub for Beginners, a series designed to help you navigate GitHub with ease.

So far in this series, we’ve covered the top Git commands every developer should know, how to create repositories, how to upload files and folders to your repository, how to add code to your repository, and how to create your first pull request. However, sometimes it can be a little bit more complicated when changes conflict with each other. As you will see, GitHub has tools to help you navigate this potentially confusing situation.

Let’s get started!

Pull request recap

First, let’s review what a pull request is (often referred to as a PR) and how it works. A pull request is a proposal to move a set of changes from one branch into another. After submitting a pull request, other team members can review your proposed changes before accepting them. They can review your code, test your changes locally, and provide feedback.

Once you have completed the review process, you can merge the changes into the target branch on GitHub by clicking the green button that says “Confirm merge.” This pulls the changes into the target branch, making your proposed updates.

What are merge conflicts?

Sometimes, GitHub can’t automatically merge the changes into the target branch. This usually happens because of a merge conflict.

Since the same section of the file changed, GitHub doesn’t know which version of the changes you want to keep, so in order to merge a pull request on GitHub, you must first resolve all merge conflicts.

Creating a merge conflict

To show you how to resolve a merge conflict, it’s helpful to create one and walk through the steps necessary to fix it. For this example, we are working in this repository. We already have a pull request in this repository under the update-name branch to update the index.html file with a change to the header text. What we’re going to do is create a new branch for this repository and introduce a different change to the same section of the index.html file.

Open your terminal and navigate to the project directory for this repository. If you need help with these steps, refer to the earlier entries in the GitHub for Beginners guide. Once you’re in your project directory, run git checkout -b add-new-name to create a new branch named add-new-name. In the new branch, open the index.html file and change the header text to be a different title from the existing pull request. Save the file and exit your editor.

Now that the changes have been made, you need to push them by running git push origin add-new-name in the terminal.

Navigate to the repository on GitHub and create a pull request for the add-new-name branch, pulling the changes into the main branch. Don’t forget to finish the merge by clicking the green “Confirm merge” button on the pull request page. Now, these changes have been integrated into the **main **branch of the repository.

Make your way back to the original pull request from the update-name branch. If you scroll to the bottom of the page, you will see that you no longer have the option to merge the changes into the main branch. Instead, you’ll see a message that there’s a merge conflict that needs to be resolved.

Resolving the merge conflict

There are a couple of ways that you can resolve merge conflicts. One option is to click the “Resolve conflicts” button on the pull request page. You can also address the merge conflicts locally by pulling down the latest changes in the target branch. We’re going to walk through the second option.

In your terminal, run git switch main to navigate to the main branch. In that branch, pull down the latest changes by running the git pull origin main command. Now, navigate back to your update-name branch by running git switch update-name in the terminal.

Run git merge main to attempt to merge the changes from update-name into main. You’ll receive a message in the terminal that the automatic merge failed and that you need to resolve the conflicts before you can continue merging. To fix the changes, open up index.html in your code editor of choice.

Depending on your code editor, the problematic section might be highlighted. If you’re using a code editor with integrated GitHub support, such as VS Code, you’ll see some options at the top of the highlighted section.

If so, click the option that says “Accept Current Change.” This will edit the file so that only the incoming change remains in the file.

If your code editor doesn’t have integrated GitHub support, you will need to manually edit the file to remove the conflicting sections. They can be easily identified by the presence of several angle brackets (that is, <<<<<<< at the start of the conflict and >>>>>>> at the end of the conflict).

Once you’ve finished editing the file, save your changes and quit the code editor. Back in the terminal, run the following commands to commit your changes and verify that all of the changes have been committed:

git add .
git commit -m "resolve merge conflict"
git status

Finally, it’s time to push these changes up to GitHub. You do this by running the git push origin update-name command. This uploads the changes that have resolved the merge conflicts into your pull request. If you navigate back to the pull request on GitHub, you’ll see that the conflicts no longer exist and that you can merge the changes into the main branch by clicking the green “Merge pull request” button. Last but not least, don’t forget to click the “Confirm merge” button.

Congratulations! You’ve resolved the conflict and updated the main branch with the requested changes!

Your next steps

If you want to practice creating pull requests and resolving merge conflicts, you can use this repository and follow the instructions in the README.md file.

Merging pull requests is an essential skill in order to be proficient with using GitHub as a collaborative development tool. However, with some practice, resolving conflicts will feel as natural as pushing changes to GitHub.

If you have any questions, pop them in the GitHub Community thread and we’ll be sure to respond.

Here are some more resources to help you on your GitHub journey:

• GitHub Foundations Certificate
• Hello world – a full pull request workflow
• Merging a pull request
• About merge conflicts
• Requesting a pull request review
• About pull requests

The post Beginner’s guide to GitHub: Merging a pull request appeared first on The GitHub Blog.

The GitHub CLI is a free and open source tool that brings the features of GitHub to your terminal. The GitHub Classroom extension adds powerful and easy to use commands that enhance the functionality of the GitHub CLI, specifically tailored for educators using GitHub Classroom. This post will walk you through the steps to create a new command customized to you and contribute back to the open source community!

1. Set up your development environment

The GitHub Classroom extension for the GitHub CLI is a Go based project. Your contributions will be made through a pull request from your personal fork of the repository. The instructions to set up your development environment and fork are described step by step in our contribution guidelines!

2. Plan your feature

We acknowledge that every classroom is unique and we want to support broader personalization of the GitHub Classroom CLI. At the time of writing this tutorial, the following commands are available:

• accepted-assignments: List your student’s accepted assignments
• assignment: Show the details of an assignment
• assignment-grades: Download a CSV of grades for an assignment in a classroom
• assignments: Display a list of assignments for a classroom
• clone: Clone starter code or a student’s submissions
• list: List classrooms
• view: Show the details of a classroom

Have a feature in mind? Be sure to open an issue before you begin your work.

Looking for a way to contribute but don’t know where to start? Check out the open feature requests and bug issues in the gh-classroom repository. If you decide to work on one of these issues, assign yourself and link the issue to your pull request!

3. Determine the availability of the data required for your command

The GitHub Classroom API documentation has the most up-to-date information about the available REST endpoints. You will need to ensure that you can request the data needed for your feature from one or more of these endpoints. To make it even simpler, there is already a helper library in the project to query these endpoints.

As an example in this tutorial, let’s look at the assignment-grades command. In order to build this feature, we had to make use of the /assignment/:id/grades endpoint.

func GetAssignmentGrades(client api.RESTClient, assignmentID int) ([]AssignmentGrade, error) {
    var response []AssignmentGrade
    err := client.Get(fmt.Sprintf("assignments/%v/grades", assignmentID), &response)
    if err != nil {
        return nil, err
    }
    return response, nil
}

What if the data you need isn’t available through any of the public API endpoints? If you run into this roadblock, don’t worry, we’re here to help. Simply open an issue describing the information you need for your feature. We will triage this issue as soon as possible in order to unblock you.

4. Build your command package

Each command is contained within a Go package. Following the same example as above, the assignment-grades package is titled grades.

To start building your new command, create a new package directory and files from the root of your fork using the commands below:

mkdir ./cmd/gh-classroom/$my-feature-name && cd ./cmd/gh-classroom/$my-feature-name
touch $my-feature-name.go $my-feature-name-test.go

Within each of your newly created files on the first line, write package $my-feature-name to include it in your package.

5. Write and test your code

It’s your time to write your shiny new feature and shine as a software developer! If you’re feeling stuck, check out the code and tests for the existing commands in the cmd/gh-classroom directory.

When you’re done coding up a storm, run the tests using the following commands from the root of your fork:

go test -v ./…
golangci-lint run

Be sure that all of your code is tested and that all tests pass before moving on to the next steps. Reviewers will require this before your changes can be merged.

6. Register your package as a command

In order for your feature to work in the CLI, your package needs to be included in the root package using the AddCommand helper function.

cmd.AddCommand(assignmentgrades.NewCmdAssignmentGrades(f))

7. Commit, push, and open a pull request

Once you’re done writing your feature, you will need to commit the code and push it up to your fork. Before opening a pull request ensure that you have read the contribution guidelines to increase the likelihood of your changes being accepted. Finally, you can open a pull request against the official gh-classroom repository.

8. Wait for a review from a maintainer

You’re almost at the finish line! At this point you can sit back and wait for our comments, request for changes, or approval. The GitHub Classroom CLI is maintained by GitHub staff and the community. We will do our best to respond in a timely manner.

Please kindly note that there may be instances where a feature is not one that we would like to support. We cannot guarantee that your feature will be approved.

9. Use your new feature

If your pull request is accepted you can merge it into the main branch of gh-classroom. Next, one of our administrators will create a new release that will trigger a GitHub Action. Once the action is successfully completed, you can update the CLI in your terminal using gh extension upgrade classroom. The next time you run gh classroom -h you will see your new command.

Voila, you are now an open source contributor to the GitHub Classroom CLI!

Conclusion

This post walked you through the power of open source, and showed how to build custom features in the Classroom extension for the GitHub CLI. We’re thrilled that you’ve taken the time to consider contributing to this project. Your help is essential for ensuring that this tool is, and continues to be great.

We’d love to hear from you! If you have any questions or have feedback, please feel free to open an issue in the gh-classroom repository.

The post Calling all teachers! Learn how to build new commands on the GitHub Classroom CLI appeared first on The GitHub Blog.

GitHub Education recently took a close look at GitHub Global Campus, the portal that showcases all of GitHub Education’s tools, programs, and resources in one place. We enlisted the help of GitHub’s Accessibility team to audit the pages and features of GitHub Global Campus against accessibility standards, such as the Web Content Accessibility Guidelines (WCAG), and point out areas of the application that could be made more inclusive.

Gathering and implementing feedback

The GitHub Accessibility team includes testers with lived experience in using assistive technologies. GitHub Education has spent the past several months taking in their feedback, working with designers, and improving the code to remove barriers that may block access. We’ve updated features, tested, and iterated until we’ve landed on the best and most inclusive solutions.

Shipping fixes

Many of the changes you’ll find on GitHub Global Campus include improving the way we write HTML:

• Reviewing headings so that the content hierarchy makes sense and so that any user can skim or skip to the information they want.
• Making sure the linkable things are links and the clickable things are buttons.
• Including more semantic tags to make the pages easier to navigate and interact with.

The code also now uses more components from Primer, GitHub’s open source design system. This gives GitHub Global Campus the accessibility features that are built into the rest of GitHub, in addition to better matching the GitHub experience that you’re used to. Check out modal windows on GitHub Global Campus, for example, if you’re using a keyboard, they now hold focus, land on the close button, and return you to where you left off on the page when you exit out of them. If you’re exploring GitHub Global Campus visually you may not notice all of the changes, but we hope these are big improvements for many other users.

What’s next

The GitHub Education team is joining the effort to build a more accessible GitHub, and we’re only just getting started. Going forward, linters will automate accessibility checks and prevent regressions, but our engineering team will also continue working with the GitHub Accessibility team to find the improvements that we can only find manually. Our learnings from the current process will be applied throughout all GitHub Education products to provide a more inclusive platform in the future.

Get involved

Learn more about our efforts to build a more inclusive GitHub at accessibility.github.com, and share your feedback in the Accessibility Feedback category on GitHub Discussions.

Want to contribute to one of the open source projects that has a direct impact on our product? Check out our documentation and the Primer Design System.

The post Building a more inclusive GitHub Global Campus appeared first on The GitHub Blog.

How can you make the best use of the tools included in the Aspiring Creatives Experience?

Design

The design of a project is the backbone to which all other pieces are dependent. Become inspired by tapping into your creativity, from sets by thousands of artists around the world to snappy interface tools, such as Iconscout, Icons8, Octicons, and Figma.

Brainstorm & Organize

Sometimes, getting another pair of eyes on a project can spark creativity. Ideate with others by bringing projects together while synchronizing collaboration efforts through shared tasks and checklists in FigJam.

Showcase

Get exposure for your project and discover other student repositories in need of collaborators and maintainers through GitHub Global Campus by visiting the GitHub Community Exchange.

Featured collaboration: Figma education template and live stream

GitHub Education welcomed Figma Education’s, Lauren McCann, to CampusTV to discuss all things Figma and Aspiring Creatives, including the brand new GitHub Education‐designed hackathon templates created by Campus Expert, Vaishnavi Dwivedi .

The mini designs systems for hackathons template was developed to inspire student developers who struggle while designing hackathon projects. Be it colors, typefaces, or simple wireframes to decide their project flow, this template can help them save time while building their hack. Aspiring Creatives can use the template for storyboarding, prototyping, and presenting their work and designer-dev handoffs.

Re-watch the stream on CampusTV.

Sign-up for Figma Education.

Download, like, and share the mini design systems for hackathons design template.

Redeeming the Aspiring Creatives Experience!

The Aspiring Creatives Experience is part of the Student Developer Pack. Not a member yet? It’s available for all verified students ages 13+ and anywhere in the world where GitHub is available. Join today using your school-issued email, student ID, or other proof of academic enrollment. Becoming a member grants access to Global Campus and allows you to learn how to use real-world development tools. Visit the GitHub Education Figma page to like, share, and comment on the mini design systems for hackathons template.

The post Working on a creative project? Unleash your originality and start to tinker with the Aspiring Creatives Experience appeared first on The GitHub Blog.

The MLH Fellowship is a twelve-week program where students get assigned to open source projects and mentors who are ready and willing (and excited!) to help them make open source contributions. It helps to learn the process behind popular open source projects and the work that maintainers go through. At the end of the program, students contribute to major projects on GitHub, which are used by developers around the world. Check out the feedback from one of our maintainers and GitHub staff member about her experience working with a MLH Fellow during our last cohort.

This cohort is special as its our first to be entirely made of Campus Experts. GitHub Campus Experts were carefully selected from the student community to join MLH’s Fellowship cohort. Campus Experts are student leaders that strive to build diverse and inclusive spaces to learn skills, share their experiences, and build projects together. They can be found across the globe leading in-person and online conferences, meetups, and hackathons, and maintaining open source projects.

We were fortunate enough to sit down with the Campus Experts and ask them about their experience and goals with the program.

Meet the Fellows

Samson Amaugo

GitHub Handle: @sammychinedu2ky

How has your Campus Expert experience prepared you for the Fellowship?

“Being a Campus Expert comes with some tech advocacy responsibilities which also translates to some of the acknowledged skills needed to succeed in the Fellowship. Some of the skills include being able to communicate and collaborate with peers and also the ability to learn new technologies. I look forward to also improving on these areas during my stay in the Fellowship.”

What are you hoping to learn from the Fellowship experience?

The opportunity and privilege of meeting and working with people from different cultures, spheres of life and mixed-tech backgrounds creates an environment where I am fortunate to learn not only from the project managers, but also from my pod mates. I aspire to develop my soft skills and also improve on my project management and contribution dynamics.

Tushar Gupta

GitHub Handle: @tushar5526

How has your Campus Expert experience prepared you for the Fellowship?

Campus Experts helped me get unique insights into the community culture. The experience and exposure from Campus Experts helped shape an impactful essay, which eventually led to my applications for the MLH Fellowship always being able to clear the initial screening processes.

Both of these programs have the same core values—that is working for the growth and betterment of the community. So, my experience at Campus Experts automatically modeled my thought process, mind and values to resonate with the values of the program. Thus, the interviews and the whole process felt very natural and an easy fit for me.

What are you hoping to learn from the Fellowship experience?

I am really looking forward to interacting with super-talented Fellows all around the globe and learning from their experiences and innovative ways of problem-solving. Also, getting hands-on experience on real-world projects and picking up skills like teamwork, effective communication, and working on different tech stacks excites me to the core. I am hoping that the time at the Fellowship will help me get a better understanding of how software is ideated, developed and managed for real-world use cases.

Nathaly Toledo

GitHub Handle: @ahn-nath

How has your Campus Expert experience prepared you for the Fellowship?

Prior to my role as a Campus Expert, I was rejected four times for the Fellowship. Part of it, I believe, is how I focused entirely on my technical skills. The Campus Experts program has helped me look at other aspects of my career and role in communities. It helped me build soft skills that not only make my profile much more robust, but also make me communicate my value with more confidence and eloquence. It also added more meaning to the use of my skills and the purpose of my leadership in tech, which should go beyond being good at coding.

What are you hoping to learn from the Fellowship experience?

I am looking forward to discussing and learning from top talent on how to troubleshoot and go about finding a solution to technical issues and taunting challenges while collaborating with other Fellows. I am also looking forward to working with professional mentors who will help me be aware of my weakness and of the level I need to reach to build top-level software as an engineer. Finally, I almost can’t wait for it to start, as I think that it is highly likely to go beyond my expectations.

We’re looking forward to tracking the progress of the Campus Experts throughout their journey.

Happy hacking!

The post Meet the GitHub Campus Experts selected for the fall 2022 MLH Fellowship Cohort, powered by GitHub appeared first on The GitHub Blog.

Stepping into Global Campus

While applying to join Global Campus doesn’t require essay writing, it does require each student and teacher to pass through our proprietary fraud detection system. This verification is really important to be able to create and maintain a safe and inclusive learning community. No bad actors, no marketers, no scammers allowed!

If you’re not yet a part of the Global Campus community, no worries! You can apply to join if you are a student or a teacher.

Start the new education journey with new tools for students

Growing projects with Global Campus Community Exchange

Over the last few months students have been learning and contributing to each other’s projects and building engaging communities all within the safe space of the Community Exchange within GitHub Global Campus. The Community Exchange offers the ability for students to connect with peers to either further the path of becoming an open source contributor or upskill further within the software development realm. From discovering new projects and repositories to submitting their own, students are surrounded by others also eager to collaborate.

In addition, students are growing their network and building their portfolio which can yield many professional opportunities. Being featured within the Community Exchange also brings exposure and visibility for student projects, allowing more community members to see interesting and varied projects and gives focus on how to be an open source maintainer.

Hosting hackathons in the cloud

Hosting and organizing a hackathon or codefest is no small feat, but with the right software and guides any student can empower student hacker communities. GitHub Global Campus has a new experience focusing on tools that help organize, promote, and communicate any upcoming hackathon, no matter the skill level.

The Hackathon in the Cloud Experience contains guides from Major League Hacking and HackMIT to help guide and organize efficiently. Offers from Typeform and Mailgun elevate the event promotion to a higher grade. And Git extensions from GitLens allow for information to be communicated and track commits all throughout the event.

Managing your secrets in the Student Developer Pack with Doppler

A highly requested tool finally arrives within the Global Campus Student Developer Pack! Doppler is a universal secret manager that aims to reduce the stress and issues associated with managing secrets with GitHub Actions. Students can now inject secrets from Doppler into GitHub Actions and avoid risking exposure with .env files or hard-coded values. With rollback support, secret referencing, and automatic redeploys, Doppler can supercharge a student’s GitHub Secrets management experience in local development, CI/CD, and production.

Best tools to make CS learning accessible in your classroom

Codespaces x GitHub Classroom for Teachers

The launch of Global Campus for Teachers came with an exciting feature for the educator community: the power of Codespaces. Codespaces allows teachers to integrate a Visual Student Code-backed editor, terminal, and debugger alongside GitHub version control into GitHub Classroom, which provides a scalable solution for quickly getting CS students starting using any virtual device that has a browser.

Mixing Codespaces with GitHub Classroom allows teachers to standardize environments, hardware specifications, and other editor settings so that all students have the same setup no matter where they work with significantly less troubleshooting.

While GitHub Team and GitHub Enterprise users are billed for Codespaces in a pay-as-you-go model, your Global Campus teacher status gives you a no-cost monthly allowance of Codespaces hours to use in your classroom. The free allowance is estimated to be enough for a class of 50 with five assignments per month, on a 2 core machine with one Codespace stored per student, which is ample to have students creating projects and completing assignments.The Codespaces Education benefit is currently in public beta. During the beta release, you will not be charged if you exceed the free allowance, so begin integrating Codespaces in your classroom and start enabling curriculum and classes around GitHub’s industry-standard toolset and help prepare students for a career in tech.

Reuse assignment in your classroom

Teachers, we have heard your feedback! GitHub Classroom now gives the ability to easily reuse an Assignment across Classrooms and/or from semester to semester. You don’t have to now manually and repeatedly create new assignments using the same template repository.

Using ‘Reuse assignment’ you can copy single / multiple assignments and the associated template repository across Classrooms and organizations. The copied assignment will include the assignment details, such as name, source repository, autograding and preferred editor. Learn more.

Copilot now free for teachers

GitHub Copilot, an AI pair programmer, is now free for all teachers verified on GitHub Global Campus.

GiHub Copilot is an AI pair programmer that uses OpenAI Codex to suggest code and entire functions in real time, right from your editor. Earlier this summer, following a successful year long technical preview with more than 1.2 million developers, we launched GitHub Copilot for individuals. The feedback received from the community has made it abundantly clear: AI is one of the best tools to empower the next generation of developers. With GitHub Copilot, developers have more time and space to focus on solving bigger problems and building even better software.

We recognize the challenge of integrating Copilot into the classroom and have been working with partners to identify early opportunities for assessing Copilot’s impact. Dive into a few case studies around professors adapting existing teaching methods and join the conversation with other teachers on GitHub Global Campus.

Time to get started

New features on the GitHub Global Campus await you. If you are a student or a teacher and you haven’t joined Global Campus yet, apply for the Global Campus Student or Global Campus Teacher benefits. Also join the GitHub Education Discussions and connect with other students and teachers!

The post Gear-up and unlock the newest GitHub Global Campus features appeared first on The GitHub Blog.