To improve their way of working, Ahmed and Naima realise they need the following:

• a way to both know what the most recent version is
• a way to know what the old versions were, and in what order (i.e. how they got to the current version, and what content they may have deleted that they may want to get back)

To manage the different versions of the blog project, they decide to use Git.

In Git, we create different versions of a project over time by creating commits.

A commit is a snapshot of our project at a particular point in time. You can also think of a commit as a particular version of a project.

Commits store the following information:

• what changed in this commit
• who created the change
• what time the change happened
• what the previous commit was

A typical timeline of commits might look like this:

We can check the commits on the remote repository as before:

On the left page of the page, we see additional information:

So what is main?

main is a branch.

Commits form a sequence that look like this:

A branch represents a particular history of development in a project - the different versions there have been.

There can be different branches with different names, which may have different versions.

For example, if we were testing out some different visual styles, maybe we would have one branch with some extra changes which make the website more blue, and a different branch with some extra changes which make the website more purple. These branches may share some commits in history, but have some extra different commits separately.

The main branch is often treated as a special branch - it’s where we put commits which people working on the project have agreed on. Other branches (e.g. the experimental purple branch) may have extra changes, and if people working on the project agree the changes are good, we’ll add those changes to the main branch.

When we’re working on something new, we haven’t agreed with other people that our new thing is good yet, so we often don’t add our changes to the main branch straight away. Instead we make our own branch to experiment on.

We can start to create independent branches like this:

In the diagram above, we can continue to commit on the “week-1-coursework” branch without altering the history of the main branch.

Often we want to take an existing project and start working on it independently. In other words: we start making our own versions of the project separate from the original project.

We may have a repo with the following url:

We might want to start creating our version of this project in isolation from the original project.

So we can create a fork 🧶 🧶 fork A fork is a copy of a repository that exists on Github .

When we create a fork on Github, the new forked repository gets a new url:

We can also use Git on our local machine to perform similar tasks as we do on GitHub. So we need to address the following question:

In other words, we need to get a local copy of the repository which is on GitHub.

Git

You will use Git continually as a developer. We will cover Git in more depth later in the course. Right now, we will just check that you have it installed.

Open up a terminal and run the command git --version to double check you have Git installed. If it is installed successfully, you should get a version number (which may not be exactly the same as this example, but should look similar):

git version 2.40.0

Otherwise, you will need to install it or ask for support on your Slack channel.

GitHub

In Fundamentals, you should have set up your Coursework planner.

Ensure you’ve completed the following issue 👉 https://github.com/CodeYourFuture/Coursework-Planner/blob/main/readme.md

This playlist introduces Git & Github: tools we’ll be using from now on.

These videos cover concepts that you’ll learn slowly over this course. Bookmark these videos and come back in the future when you need them.

For now, watch only the first video:

https://www.youtube.com/watch?v=BCQHnlnPusY

Once you’ve got a local copy of a codebase on your local machine you can start to view the files and folders in that codebase. You can use a code editor like VSCode.

VSCode is an application that enables developers to view and edit files on their local machine.

Here is a diagram representing how the repositories interact after forking and cloning:

Imagine that two people are writing a blog. Ahmed and Naima are writing a blog together about their struggles learning coding.

The published blog is live here 👉 Educational blog

We can view the different commits of a project on Github. This means we can see what the website looked like before, in previous versions.

Recall that a commit is a snapshot of our project at some point in time.

Therefore, we should be able to check out a previous version of our project and look at the files and folders there. We can use the Github interface to check out the files and folders at a previous commit.

Planner on GitHub

In Fundamentals, you should have set up your Coursework planner.

Ensure you’ve completed the following issue 👉 https://github.com/CodeYourFuture/Coursework-Planner/blob/main/readme.md

At The Docs, we learn as a community.

In this session, we’re going to describe how we harness our community to learn together.

Resources

The facilitator will use this presentation 👉 Learning as a community presentation

Preparation

• Facilitator: Review this presentation before class.
• Facilitator: Ensure everyone can access the Miro board presentation.
• Facilitator: Split the class into groups of no more than 5.
• Facilitator: Make sure every group has access to a laptop.
• Facilitator: Make sure every group has access to a piece of paper and pen

Introduction

The facilitator will use the Miro board presentation to guide trainees and volunteers on a discussion about how we learn together as a community.

For trainees

In this section, we’re going to go through a set of questions/tasks to clarify what we’re going to do in the next part of the course.

Get into pairs with somebody you’ve not paired up with today and try figuring out the answers/solutions to the following questions/tasks:

1. Using the curriculum, locate the page setup page for the upcoming module.
2. Using the curriculum website, locate the page with the prep material for the first week of the next module
3. List the things you need to install ( if anything ) for the upcoming module.
4. Check you can find the backlog page for the Induction sprint. Double check you’ve copied all the issues from the backlog over to your Course Planner.
5. Identify all the issues with 🔑 icon that are marked as Priority. What does the Priority icon 🔑 mean?
6. Go to your group Slack channel and start a thread 🧵 outlining times you’re free to meet up to discuss the prep work during the week
7. Which day ⏰ should you start the prep work for the upcoming HTML module?
8. Experiment with your project planner: can you filter by Size, Week 1, Tech ed, PD etc.?

For volunteers

1. Locate the classroom planning board for your region ( if one exists )
2. Locate the day-plan for the next week/module
3. Check the instructions and links on the Priority 🔑 issues for the upcoming week ( both Tech Ed and PD )
4. In the day-plan for the upcoming week identify the instructions for any workshops and visit the repository containing that readme. Check the instructions make sense.

Download and install the following software or register for the apps.

Click on the links to go to the registration pages. Keep your login details for all sites/apps consistent and always use your real name.

Gmail, Google Account

Make a new Google account if you do not have a professional one already. Use your real name. Don’t use any numbers or words that are not your name. Never put the year of your birth in your professional email address. Your email address should look something like this:

JDoe@gmail.com > JohnDoe@gmail.com > JaneDoe@gmail.com

This is your public professional email address. Use it to sign up for all your professional accounts unless you can use your GitHub.

• I have made a professional Google account and Gmail address.
• I have explored the Google Suite, such as calendar, docs and spreadsheets.

Google Chrome

Google Chrome is the first browser we will all use together.

• I have downloaded and installed Google Chrome.
• I have logged into my professional profile on Chrome.

Use your professional Chrome profile for all your CYF work. You will often have to share your screen during sessions, so keep your personal internet use private and away from your professional profile.

LinkedIn

Sign up for LinkedIn. LinkedIn is the largest professional social network. You will use it to help you get a job and to advance your career.

Make a LinkedIn account. Use your real name. Sign in with Google. Connect with your cohort.

Your cohort is your first network, and this is one of the most valuable things you can develop at Code Your Future. A strong, tightly linked, professional network is a powerful asset, so begin building it today.

• I have made a LinkedIn account using my professional email address.
• I have used my real name.
• I have connected with my cohort.
• I am following CodeYourFuture.

Slack

Slack is our community space and how we communicate with each other. Download and install it now.

• I have downloaded the Slack app on my computer and phone.
• I have logged in to the Code Your Future Intro to Coding Workspace.
• I have found and joined my class channels.
• I have updated my profile with my picture, my professional email address, my GitHub username, my Linkedin profile and my class.
• I have posted something on my cohort channel.

Zoom

Usually we use Meet, but sometimes we use Zoom for remote sessions. Install it now.

• I have downloaded and installed Zoom onto my computer.

Earlier on, Ahmed and Naima realised they also need the following:

a way to share the history of the project between different users and different computers

To share a project and its history, we can use an online platform called GitHub

GitHub is a platform where teams can store projects along with a history of their different versions.

By storing projects on GitHub, multiple users can gain access to the history of a project.

We can use the Github interface to explore the different commits (versions) of a project too.

You’ll need to create a The Docs folder to store your projects on the course.

1. Open a terminal on your computer.

For each of the steps below, you’ll need to use the command line in your terminal.

Use this cli documentation to remember terminal commands.

2. In your terminal, print your current working directory.

3. List the files and folders in your current working directory.

You’ll need a place to store your work for the course.

4. Make a new directory called The Docs in your home directory.

5. Change directory into the The Docs directory.

6. Double check you’re in the right place by printing your current working directory.

Ahmed and Naima are using the following development process for writing their blog:

• writing the blog in a single file on a single computer
• saving multiple versions of the file on the same computer
• taking turns to use the computer during the day

At the moment, the computer has a folder with the blog that looks like this:

We use VS Code to write all of our code in the course. It is known as an Integrated Development Environment (IDE) and really helps you write great code!

🔗 Download and install VSCode now

Watch this video if you’d like a quick introduction to VSCode:

A handshake is a check for continuity between two different parts of the course. In this handshake, we’re going to check any important work done in the Fundamentals module is carried over to the Software Development Course.

A handshake isn’t the responsibility of a single individual: it is your collective responsibility as a cohort to check that you transition smoothly between two different sections of the course.

📝 Checks

Here are some checks:

1. Double-check that the “XX X Rota” spreadsheet you created in Fundamentals is bookmarked in your new cohort Slack channel