Chapter 1 Introduction to GitHub Copilot

In this article, I will share insights on a productivity tool I began using recently—GitHub Copilot. This innovative tool has seamlessly integrated into my daily work routine.

Whether you are an experienced coder, a casual programmer, or just starting out with a new programming language, GitHub Copilot can be an invaluable resource.

Developed through a collaboration between GitHub and OpenAI, Copilot leverages large language models (LLMs) to offer smart code suggestions, autocompletion, and the ability to generate entire functions from natural language descriptions.

💡 GitHub describes it best: "Copilot draws context from the code you're working on, suggesting whole lines or blocks of code to complete your work. It’s more than just autocompletion; it’s an AI-powered pair programmer that aids you in writing better code more swiftly."

In this guide, I will showcase some remarkable features I have explored and illustrate how they can enhance your coding journey, making it more efficient and enjoyable. 🚀 Getting Started

To begin, you’ll need an integrated development environment (IDE) set up. I recommend using VS Code for an optimal experience with Copilot, though it also supports JetBrains, Visual Studio, and Vim.

Here’s how to get started with GitHub Copilot:

1. Sign up for the GitHub Copilot beta at copilot.github.com.
2. Install the Copilot Extension. Open VS Code, navigate to Extensions (Ctrl+Shift+X on Windows, Cmd+Shift+X on Mac), search for "GitHub Copilot," and click Install.
3. Link your GitHub account within VS Code to access Copilot’s features.

You’re all set to start coding!

Chapter 2 Building a Calculator Application

In this section, we will create a basic Python application that performs simple calculations—addition, subtraction, multiplication, and division.

💭 "Programming isn't about hitting the right keys. It's about knowing what you want to do." — Steve Jobs

One of Copilot's standout capabilities is its proficiency in interpreting natural language comments. You can articulate the functionality you want in plain English, and Copilot will translate that into code, sparing you the effort of converting your thoughts into syntax.

Open the Copilot chat on the sidebar, describe your application, and prompt Copilot to generate it. I used this prompt:

"Create a Python class called Calculator. Include the necessary calculator operations as class methods."

After a brief moment, Copilot produced the following class:

class Calculator:

def add(self, a, b):

return a + b

def subtract(self, a, b):

return a - b

def multiply(self, a, b):

return a * b

def divide(self, a, b):

if b == 0:

raise ValueError("Cannot divide by zero")

return a / b

Remarkably, it recognized the fundamental functions of a calculator and created a method for each, including logic to handle division by zero.

Furthermore, Copilot suggested the following code snippet to test the class:

calc = Calculator()

print(calc.add(5, 3)) # Outputs: 8

print(calc.subtract(5, 3)) # Outputs: 2

print(calc.multiply(5, 3)) # Outputs: 15

print(calc.divide(5, 3)) # Outputs: 1.6666666666666667

Now, you can insert the generated code into a new file. Click the … in the top right corner of the generated code box and select "Insert Into New File." This will create a new file containing the generated class code that you can save.

Chapter 3 Enhancing Your Code

💡 "Good company in a journey makes the way seem shorter." — Izaak Walton

Copilot quickly grasps the context of your project and begins to suggest relevant code extensions. For example, I wanted to add trigonometric functions to my Calculator, and as I started to define a sine function, Copilot anticipated my needs and suggested the necessary code.

🤯 Bug Fixes

💡 "Debugging is twice as hard as writing the code in the first place." — Brian Kernighan

However, despite its intelligence, Copilot suggested using math.sin without the requisite import statement. VS Code flagged this error.

Let’s assume we need help with this issue. Highlight the line, press Ctrl+. (or Cmd+. on Mac) for the code actions menu, and select 'Fix using Copilot.' Voilà! Copilot identified the missing import and proposed a solution. By pressing Ctrl+Enter, you can accept and insert the import math statement at the top of your file.

Now our code is working correctly. Thanks, Copilot!

We can now implement additional trigonometric functions without manual coding. Just prepare to be amazed as Copilot will offer suggestions for calculating cosine and tangent values.

👨🏽‍🏫 Understanding Complex Code

💡 "Code is like humor. When you have to explain it, it's bad." — Cory House

Everyone has encountered undocumented code left behind by a colleague. If you find yourself puzzled, don't worry—Copilot is here to assist.

You: Can you clarify this code for me?

Copilot: Of course! Just highlight your code, go to the chat, and type:

@workspace /explain

Alternatively, click the Copilot orange icon in the code and type /explain in the command line.

In the chat panel, Copilot will elucidate the class and its methods. Here’s the explanation I received:

"The provided code is a Python class named Calculator that includes several methods for performing mathematical operations. The sin(self, a) method calculates the sine of a given angle a, which is expected to be in radians, using Python's built-in math.sin() function."

This response highlights Copilot's capability to understand context and assumptions in your code.

🖋️ Streamlining Documentation

💡 "Documentation is a love letter that you write to your future self." — Damian Conway

Generating thorough documentation can be tedious, and many developers often overlook it—until they regret it months later when they struggle to recall their thought process.

This is where GitHub Copilot's auto-comment generation proves useful. Try this: highlight the class and in the command prompt enter /doc. This will yield the fastest and most comprehensive documentation you've ever produced.

import math

class Calculator:

"""

A simple calculator class that performs basic arithmetic operations and trigonometric functions.

"""

def add(self, a, b):

"""

Adds two numbers.

Args:

a (float): The first number.

b (float): The second number.

Returns:

float: The sum of the two numbers.

"""

return a + b

...

🔁 Creating Unit Tests

💡 "Testing software is like tasting wine. One sip reveals more than a whole bottle of descriptions." — Generated by AI

Now, let’s elevate this project with comprehensive unit tests. At the end of your file, click the Code Actions icon and type /tests. This generates a full set of test cases for all the class functions and prompts you to create a new file for the code.

Here’s how the test_calc.py file looks:

import unittest

from calc import Calculator

class TestCalculator(unittest.TestCase):

def setUp(self):

self.calculator = Calculator()

def test_add(self):

result = self.calculator.add(2, 3)

self.assertEqual(result, 5)

...

def test_divide(self):

result = self.calculator.divide(10, 2)

self.assertEqual(result, 5)

def test_divide_by_zero(self):

with self.assertRaises(ValueError):

self.calculator.divide(10, 0)

...

if __name__ == '__main__':

unittest.main()

🔄 Converting Code to Another Language

💡 "One language sets you in a corridor for life. Two languages open every door along the way." — Frank Smith

Lastly, if you need to convert your Python code into C++ for production purposes, you guessed it—just ask Copilot. Here’s my Calculator class in C++:

#include <iostream>

#include <cmath>

class Calculator {

public:

double add(double a, double b) {

return a + b;

}

double subtract(double a, double b) {

return a - b;

}

double multiply(double a, double b) {

return a * b;

}

double divide(double a, double b) {

if (b == 0) {

throw std::invalid_argument("Cannot divide by zero");

}

return a / b;

}

double sin(double a) {

return std::sin(a);

}

double cos(double a) {

return std::cos(a);

}

double tan(double a) {

return std::tan(a);

}

};

GitHub Copilot exemplifies how artificial intelligence can revolutionize coding, making programming more efficient and accessible.

In conclusion, GitHub Copilot offers a groundbreaking approach to coding, providing tools for generating code snippets, explaining code, creating documentation, and even translating code from one programming language to another. While it excels in many areas, it’s crucial to acknowledge Copilot’s limitations. Developers may need to scrutinize the generated code, especially in larger projects, and make iterative adjustments.

GitHub is continually enhancing Copilot, focusing on improving its contextual suggestions and expanding its understanding of extensive codebases. They’re addressing concerns regarding the tool's limitations and updating its capabilities based on user feedback. Furthermore, they aim to enhance Copilot’s ability to generate code across various programming languages and frameworks.

Despite these factors, the advantages of utilizing Copilot are substantial. It alleviates repetitive tasks, minimizes the time spent on trial and error, and liberates your creativity and productivity.

Chapter 4 Exploring More Resources

Discover how to leverage GitHub Copilot for increased efficiency and innovation in coding.