BARR

MILENA67

BLACKFRIDAY2024

DISCOUNT25

BF24

ANDRA20

JON20

WORKSHOP60

TRAINERFREE

FRIENDS50

SAVE10JD

Save 10%

Free TLL Monthly

50% Off TLL

$400 off

Plerion Prepaid

Plerion Pre-paid

debuggingleadership.com beta - monthly

debuggingleadership.com Beta Access

Free Course

This course is targeting one main concept important for real life usage of Copilot - project development.

go through most stages of software project development

Main app would be covering up an area of equity management with 4 core methods to write:

for this course to not overcomplicate the implementation as the main goal of this course is to teach how to use Copilot for software development, NOT build a fully-pledged equity management app.

NOTE: I am not an expert in equity management, just curious self-learner.

There are some optional lessons targeting basic ChatGPT usage for project idea generation and enhancement the features set of an existing project.

Welcome to the "GitHub Copilot and ChatGPT for Software and Project Development" Course!

Hi, I'm VAD and I want to welcome you to my new course about GitHub Copilot and ChatGPT for software and project development.

I'm a software engineer and engineering manager with over 10 years of experience working at startups and international companies.

In this course, I want to showcase how you can use modern generative AI tools like ChatGPT and GitHub Copilot for all stages of the software project cycle—from ideation to development to testing and code reviews.

We look forward to helping you leverage these powerful AI tools to streamline and enhance your software development process. Let's get started!

TLBGCP - 01 Intro

Hi, I'm VAD and I want to welcome you in my new course about Github
copilot and chat GP T for software and project Development.
I'm a software engineer and engineering manager with over than 10
years of experience working at start ups and international companies.
In this course,
I want to showcase you how you can actually see modern generative A i tools like J,
GP, T and github
copilot for all stages of the software project cycle
from ideation to development to testing and code reviews.
In the introduction section, I will show you how to set up and use Chad GP T and
github
co
plot
in the ideation. I will show you how you can use Chad GP T
to generate ideas for your next project. If you don't have an idea yet
and also we'll explain which idea we will pick up in this course.
Then we will take the 80% of the course into the development section,
uh which would be setting up the back end project, creating the services,
setting up a dependencies, dockize
our application
and then we will move to create the front end part of it very small and restricted one.
But just to showcase how to use it also for the front end development.
Then we will move to the testing section where we explain how to use Github
copilot in unit and integration test creation.
And then it would be the short five minutes Next step section.

Hey there! My name is Vad and as a software developer with quite some experience in different technologies and 10+ years experience in software development, I would like to share my experience with curious audience.

I want to mostly focus on Engineering Management and Leadership but nobody will stop me from sharing some insights on the latest trends!

Vadym Kukhtin

Passion for Software Engineering and Leadership

Welcome to the "Tech Lead Brief GitHub Copilot" Course!

Hi, I'm Vad and I want to welcome you to my new course about GitHub Copilot and ChatGPT for software and project development.

Introduction

TLBGCP - 02 Optional Setup ChatGPT

Understanding OpenAI Tools for Business and Project Idea Generation

Welcome students! In this lesson, we're diving into how to leverage OpenAI's GP T tools for generating business and project ideas.

. Here, you will find the interface for interacting with GPT models.

GPT models are effective tools for brainstorming and generating ideas. Here's how you might use it:

By understanding these tools, you can unlock a wealth of information and innovation for your business or projects. Happy brainstorming!

Optional: Setup ChatGPT

TLBGCP - 03 Setup Github Co-Pilot

In this lesson, we'll focus on setting up another generative AI tool, which will be a central part of our course. Follow the quickstart guide available from GitHub docs. The link to the guide will be included in the course description.

By following these steps, you can successfully set up and start using GitHub Copilot in your development environment. Happy coding!

Setup Github Copilot

TLBGCP - 04 Optional Ideation with ChatGPT

In this lesson, we delve into the ideation phase using ChatGPT. You'll learn how to generate project ideas, get suggestions for functionalities, and identify popular programming languages for your projects.

To start with, you can use ChatGPT to brainstorm and come up with ideas for a pet project. If you're uncertain about where to begin, you can ask for strengths based on industries or countries.

Thank you for following along with the lesson. We hope you find these tools useful in enhancing your projects. See you in the next section!

Optional: Ideation with ChatGPT

TLBGCP - 05 Sample app features explained

Let's dive into the details by explaining how these features work, step by step.

At the initial state of equity management:

Note: In real-life scenarios, the 10% would likely convert to stocks.

, another one-time event. Here’s the process:

 event can occur for various reasons, such as decreasing share price or increasing liquidity. It works as follows:

 event, which involves buying or selling stocks. For instance:

Thank you for following along. See you in the development section!

Sample app features explained

TLBGCP - 06 Setting up Backend project

Welcome to the first lesson in the development section of our equity project course! Throughout these sessions, we'll set up two crucial parts of our equity project: the backend and the frontend. We'll adhere to a standard development cycle process and leverage GitHub Copilot to assist us whenever possible.

We'll start by setting up the backend using Node.js and its ecosystem. We'll use NPM as our package manager, Express.js to define REST APIs and routers, and MongoDB (via Mongoose) to manage our data storage within Docker.

The frontend of the project will primarily use React.js, enabling a dynamic and responsive user interface.

Starting with Visual Studio Code (VS Code)

In this section, we'll open our project in VS Code and go step-by-step through the project creation process, utilizing GitHub Copilot to assist us.

With our initial setup in place and dependencies installed, we're ready to delve deeper into building out the backend and frontend components of our equity project. Stay tuned for the subsequent lessons where we'll continue to explore and leverage GitHub Copilot's capabilities to streamline our development process.

Setting up Backend project

TLBGCP - 07 Install dependencies and entry file

Setting Up Your TypeScript Project with Express

I skipped a few steps initially to avoid boring you with the npm installation part. Here are the steps I took:

 section was updated. I will explain it later as we haven't discussed these files yet.

New Project Structure and Configuration Files

After setting up, you will see a few changes:

This configuration is fairly standard and is what you get with the default 

Creating the Source Folder and Index File

We will now create the source folder and a new file called 

As previously discussed, we will create an Express app for our REST application and add an Express router to manage different routes. I will cover the router in detail in the next lesson.

For now, we can use GitHub Copilot to generate a basic application:

If everything is set up correctly, you should see the message:

Install dependencies & entry file

TLBGCP - 08 Architecture of the app and Dockerising the app

Backend Development Architecture and Setup

Before diving into the backend development, let's overview the simple architecture for our backend app. Here's a breakdown of how the components will interact and function:

To proceed with development, we need to add MongoDB as a dependency to our service. We have two ways to run MongoDB:

We will use Docker to run MongoDB. Here's a step-by-step guide to setting it up:

By following these steps, we now have a Docker setup for a MongoDB instance ready to support the backend services. This setup ensures our backend app can handle business logic efficiently while maintaining data integrity and persistence.

Architecture of the app & Dockerising the app

TLBGCP - 09 Mongoose models Part 1

Next, we will define the schema for the shareholders.

Step 4: Using GitHub Copilot for Assistance

GitHub Copilot can help automate some of our tasks. It can suggest types for our schema properties and even create schemas and models.

Once you've defined your schemas, you need to export them so that they can be used in other parts of your application.

Mongoose models Part 1

TLBGCP - 10 Connect MongoDB

In this section, we will go through the process of connecting our Node.js application to a MongoDB instance. Follow the steps below to set up the connection.

Now, you can start your application using the 

You should see a log message confirming that MongoDB is connected and the server is running.

This setup ensures that your application will not continue to run if the MongoDB connection fails, which is crucial for maintaining integrity and stability in your applications.

Connect MongoDB

TLBGCP - 11 Mongoose models Part 2

First, we need to create a TypeScript interface for the shareholder. This interface will include the shareholder's information such as name, email, and the companies they own.

Step 2: Create an Additional Type for Company Information

We need to define a separate type for the company's information. This additional interface will capture the company ID, which is crucial for our implementation.

Once the interfaces are created, we can proceed to build the model. This model will represent the default structure of a shareholder within our system.

Step 4: Updating Imports and Fixing Issues

To ensure our project is cohesive, we need to import the necessary components and resolve any issues related to the shareholder data integration.

With our models and interfaces in place, the next step is to create routes that our service will use. These routes will facilitate operations like creating, reading, updating, and deleting shareholder information.

Mongoose models Part 2

TLBGCP - 12 Add express routers

Building RESTful Express Routers for an Application

Copilot helps generate a default schema which we can adjust according to our needs. Here’s a basic setup.

Ensure our base URL and routes align with our application's needs. Typically, we use Express with mongoose models.

For example, in our companies route, we deal with the GET, POST, PUT, and DELETE requests.

While Copilot is helpful, sometimes it may not understand the complete context. Make sure to verify and adjust the generated code.

Finally, always review the code to align it with best practices and ensure it adheres to your application's needs.

For any remaining issues, Copilot can suggest fixes. We'll dive deeper into these fixes in a later section.

Add express routers

TLBGCP - 13 Continue with routers

This video covers the process of setting up routes and middleware for handling company data in a Node.js application. It involves integrating different routes, testing them, and ensuring they interact correctly with a MongoDB database.

Continue with routers

TLBGCP - 13.5 Creating main service business logic

In this video, we focus on creating and implementing the business logic for an equity management service. This involves setting up event types and handling specific business events like capitalizations, share releases, share splits, and share purchases.

. This service will handle the core business events and logic for managing equity.

, we will define four main events that will be used in our equity management system.

For better clarity and understanding, we define several types that will be used throughout our service.

This is a generic type that includes an ID and data field for all events.

These are the specific event types we will handle in our service.

Specific payloads sent from any event provider or even internally within our express routes.

A generic type that consists of all our payloads.

To handle the capitalization event, we need to ensure that we have the necessary information like the company ID and the capitalization payload.

Creating main service business logic

TLBGCP - 14 More business logic

If the current company capitalization exceeds the original capitalization, the app will update and save the new value. If not, an error will be thrown, as the capitalization should not decrease within the application’s context.

More business logic

TLBGCP - 15 Even more business logic

In this lesson, we explored updating shareholders and managing share purchases within a company structure using the copilot and repositories. Below is a step-by-step breakdown of the concepts covered.

Even more business logic

TLBGCP - 16 Update routers with business logic actions

Implementing Event Handling in Our Router

To enable the execution of events within our system, we need to integrate them into our router. Here we will update the company's router to handle the first three types of events: shares release, capitalization, and shares split.

We begin by verifying the existence of the company before processing any events.

We need to ensure that all events are correctly closed, especially when auto-generated code might omit necessary closures.

By following these steps, we can effectively manage shares release, capitalization, and shares split events within our router. Each event is thoroughly verified for correctness in structure and required properties.

: Always test to ensure these configurations are functioning as expected before deploying them to a production environment.

Update routers with business logic actions

TLBGCP - 17 Finish updating routers

Fixing a Typo in the REST API and Testing Events

In this lesson, we will address a typo in our code and move on to test our events.

Let's carry out some tests to ensure that our events are working correctly.

At each stage, we check for errors and verify that the events have been triggered successfully.

Finish updating routers

TLBGCP - 18 Extra Explain it and Fix it functions

If you need an explanation for a segment of your code:

This feature can be particularly useful when dealing with more complex functions or segments, such as those found in equity management.

In simpler functions, like those checking the split factor, manual understanding might suffice. However, knowing this functionality is available can be very useful in more intricate coding scenarios.

This feature expedites the initial documentation process, making it easier to align and refine later.

This functionality ensures prompt and accurate troubleshooting, enhancing debugging efficiency.

By utilizing these GitHub Copilot features, you can streamline your coding workflow, make informed code decisions, and maintain clear, concise documentation with minimal effort.

Extra: Explain it and Fix it functions

TLBGCP - 19 Setting up Frontend project and Simple CSS suggestions

Creating a Default App and Integrating React Query

Welcome to the tutorial on setting up a default app and adding React Query to it. Below is a step-by-step guide based on our video transcription to help you easily build and enhance your app.

Step 1: Creating and Running the Default App

Use the following command in the terminal to create the default app

Start the application on a different port (e.g., 3002) to avoid conflicts:

React Query is a powerful tool for fetching and caching server-state in your React application. To integrate React Query, follow these steps:

Step 3: Creating a Functional Component for Fetching Data

With these steps, your application should now be set up to fetch and display a list of companies, and you have some basic CSS for styling.

Feel free to explore more advanced CSS or JS functionalities to enhance your application further. Happy coding!

Setting up Frontend project & Simple CSS suggestions

TLBGCP - 20 Unit tests generations and fixes

Unit Testing with GitHub Copilot: A Step-by-Step Guide

In this video, we dive into the process of setting up unit tests for a company's router using GitHub Copilot. Here's a detailed breakdown of the steps covered.

Testing is an iterative process. As you write more tests, your familiarity with the framework will improve. GitHub Copilot is a powerful tool that can streamline the initial setup, but hands-on experience and troubleshooting are essential. This walkthrough provides a solid foundation for using Copilot to generate and modify unit tests in a real-world scenario.

Unit tests generations and fixes

TLBGCP - 21 Integration tests generation and fixes

In this session, we will walk through creating integration tests for our business logic within the Equity Management Service using GitHub Copilot. Let's get started!

Creating robust integration tests using tools like GitHub Copilot can streamline the development process. By following the above steps, we ensure comprehensive coverage and correctness in our Equity Management Service. Happy Testing!

Integration tests generation and fixes

We will use a sample app and go through most stages of software project development with main focus on GitHub Copilot.

Tech Lead Brief: GitHub CoPilot

Hi. Welcome to lesson number four
Equity management features.
So in this lesson,
I want to explain which features we want to focus during this course,
especially in the development phase,
how they work and why they are important.
So let's go to the
drawing board to explain how these features work.
So we have.
We have our the initial state
in the equity management when you don't have any shareholders,
so they don't own anything in your company.
You have a owner who owns 100%
and you have a company with a zero evaluation and zero amount of stocks available.
So the first event is the capitalization.
So the capitalization in this specific, simplified case is a one time event.
Somebody will offer some money or propose a funding for your company
to become valuable. So let's say you have a shareholder who proposed
10-K euro for 10% of your company, and the owner will own 90% left of the company,
and that would impact
overall evaluation
to becoming 100 K instead of zero.
Why? Because if 10% cost
10-K, that would mean that the 100% of company would be 100 K.
The stocks are still stand at zero because currently we just talking about the eval
evaluation in general,
in relative percentages,
I just want to note that in real life scenario,
most probably 10% will convert to some kind of stocks.
But we will discuss it in our next event,
so the next event would be initial shares release.
It's also a one time event, at least in our specific app development.
So how does it work? You have a company
which have, uh uh which wants to be available on the market.
In order for that to be available,
you need to have some kind of initial shares release.
In
this case, let's say we release, uh,
10-K of shares into the market, which would represent 100% of the company.
So what that would mean is that our owner, who owns 90%
will now own nine K of shares,
and the shareholder who
bought initial 10% of the company would be worth of one K shares.
The owner will have nine K
shareholders will have one K overall amount of shares is
10-K for now,
so the next is the share split event.
So the share split event is an event when the company, for various reasons,
um like, uh,
decrease the share price or make the shares more
liquid decides to increase the amount of shares,
and they do it by applying a certain, uh, split factor to your shares.
So let's say our company now stands at evaluation of 100 K.
The stocks of the company are
10-K.
So if we run the share split with the split factor of two,
that would essentially mean that we have
10-K stocks multiplied by split factor of two, which would mean now we stand at 20 K.
The amount of shares available for the owner and shareholder
are now different instead of nine K For owner,
it would be 18 K,
and for the shareholder, it would be two K instead of one K.
So last but not least, is the
shares purchase.
So let's say you can buy or sell stocks in the market in real life scenarios,
so we want to do the same here.
Let's say our shareholder want to buy one K of shares from the market.
That would essentially mean that his stake at the company increase from 10 to 15%
and the amount of stocks will increase from two K to three K.
So that's all what we have right now.
So if you want to repeat all of them, we have capitalization, which is one time event.
We have initial shares release, which is one time event.
We have a share split, which is increased amount of the shares,
and also we will have a shares purchase,
which would mean buying or selling a stake of
the company and increasing or decreasing amount of stakes.
Thank you and see you in the development section.

Sample app features explained

Lesson 4: Equity Management Features

Initial State

Event 1: Capitalization

Event 2: Initial Shares Release

Event 3: Share Split

Event 4: Shares Purchase

Summary