Forem: Stephen Gachoki

Introduction to GitHub

Stephen Gachoki — Tue, 04 Apr 2023 12:44:40 +0000

Understanding the basics of version control and collaboration with GitHub

Introduction to GitHub
- Table of contents
- Introduction
- What is GitHub
- Why GitHub
- Git vs. GitHub
- GitHub Desktop vs. GitHub CLI
- Cloning a Git Repository
- How to create an empty repository
  - Prerequisites
  - Creating the repository on GitHub
- How to Clone a git repository
  - Prerequisites
  - Cloning the repository
- Committing to a repository
- Pull requests
- Opening a pull request
- Conclusion

Introduction

GitHub and version control are two of the most salient topics to learn as a developer or software engineer. The scope to which this knowledge is applied is vast and is not constrained to software development only. GitHub can be used for tasks such as collaboration with teams, developing complex algorithms, and hosting websites, among others. GitHub is a tool that can be powerful if its capabilities are leveraged by the user to produce marvelous results.

What is GitHub

GitHub is a cloud-based platform that hosts git projects on a remote server. GitHub is used by individuals and teams for version control and collaboration using Git. GitHub's Graphical User Interface (GUI) is very user-friendly, and it allows even novice programmers to leverage the power of Git, which could otherwise be very problematic.

GitHub is free for all, and anyone can sign up and begin hosting their projects without limits. This feature makes GitHub especially popular for open-source projects.

Why GitHub

GitHub has a myriad of benefits when used by a developer or any GitHub user at any level. You will have a backup of your project because it hosts git projects on a remote server. You can still easily access and retrieve your project files in a matter of minutes, if not seconds, even if there is damage to the local storage.

Additionally, it is simple to keep track of both individual and group projects. The process of tracking the progress is made simpler by making changes to your project and pushing them to GitHub. Additionally, this is valid for multi-person collaborative projects. By creating new branches, everyone can work on the project remotely and contribute up until the deployment stage without running into any problems.

GitHub provides some of the best documentation that makes it simple for new users to understand its technical aspects. The documentations make it easy to solve any problem encountered on the way without requiring a third party to take you through. In addition, GitHub offers a markdown that is used in the writing of instructions and explanations about a project (README.md). Markdown is also used by book authors to write their books, and technical writers to write their technical articles.

Git vs. GitHub

Git is an open-source version control tool that can be downloaded and installed on a computer. It is used to keep track of a development's source code history.

GitHub is a cloud-based code hosting platform that allows users to save their Git repositories on a remote server. It essentially stores code that is pushed to it from computers running the Git tool.
You can learn more about Git and GitHub here

GitHub Desktop vs. GitHub CLI

GitHub Desktop is an application that enables you to communicate with GitHub using a Graphical User Interface (GUI), instead of utilizing the command line or a web browser. GitHub Desktop allows you to perform the majority of Git operations from your desktop with visual confirmation. You can read more about how to install and use GitHub desktop here

GitHub CLI on the other side is an open-source tool that allows you to interact with the GitHub from the computer's Command Line Interface(CLI). The CLI makes use of the git commands to perform certain tasks. You can find out more about the GitHub CLI and how to install it here.
Some of the commands that are used in the GitHub CLI can be found at the GitHub documentation.

Cloning a Git Repository

How to create an empty repository

Prerequisites

In this section, it is assumed that you have already created a GitHub account and your first task will be to create a repository otherwise known as a repo. If you have not created an account, you can create one from github.com.
You will use the web-version of GitHub for this activity.

Creating the repository on GitHub

Click the + on the top right corner of your GitHub home page and it will show a dropdown with options.
You will use the New repository option that is shown on the dropdown. Click on that option which will take you to a new page.
In the next step, you are required to give your repository a name. You can write your own repository name or use the one suggested for you.
Write a short description of your repository. This step is optional but preferable.

You are required to choose whether your repository will be public or private. For this tutorial we will set the repository to be public and everyone in the internet can see it.

You can add a README file which is used to talk briefly about your project. The README file also gives instructions to the people interacting with the project on how to use the project. At this stage you will not be required to add a README file since you will be creating an empty repository. Other files you can add to your repository include:

Git ignore file. You can find out more about a git ignore file here
License.

You will not require the above files for now and we will leave them out.

Click on the Create repository button at the bottom to finish creating your repository.

After creating you repository, you will be redirected to another page with the link to your repository. You will need this link when you will be cloning your repository to your local machine for changes.

On that page, you will see other alternative ways of creating a repository from the command line, pushing an existing repository from the command line and importing code from another repository.

Copy the link to the repository by clicking on the clipboard symbols on the right side of the link.

Now you are ready for the next step, cloning.

How to Clone a git repository

Cloning is the act of copying a repository from GitHub.com to your local machine. Your clone will contain all the project files (if any), history and branches.

You can also contribute to repositories belonging to other people or already in existence. All you will need is the link to the repository.

Select the repository you want to clone and click on the green button labelled code and it will show a dropdown.
Choose the HTTPS option and copy the link to the repository by clicking on the clipboard symbol on the far-right of the link.

Prerequisites

You are supposed to have installed git into your computer for this section. If you have not installed it yet, you can learn how to install git which will be compatible with your machine from Git Guides.

Cloning the repository

In this article I will be using the windows Git Bash, but Git can be downloaded to any Operating system including macOS and Linux/Unix distros See here.

Search for git bash in the search bar found on the bottom left corner of your windows machine and click on open.

Write the commands below to clone the repository.

# download a repository on GitHub to our machine
# Replace `owner/repo` with the owner and name of the repository to clone
  git clone https://github.com/owner/repo.git

# It will look like this for the repository that we created
  git clone https://github.com/<your username>/github-
  introduction.git

Committing to a repository

According to Wikipedia, a commit is an operation which sends the latest changes of the source code to the repository, making these changes part of the head revision of the repository, in version control systems.

We use git commands to stage the changes made to the repository and finally push them to GitHub. The commands that are used in committing the repository include:

git add - stages a change.
git commit - completes the change-tracking procedure by adding the snapshot to the project history. In essence, committing works like taking a picture. With git commit, anything that has been staged with git add will be added to the snapshot.
git push - Updates a branch's remote repository with any commits made locally.

To learn more about the git commands, refer to GitHub documentation


# Change into the `github-introduction` directory
  cd github-introduction

# Make changes, for example, create a `README.md` and `file1.md` using the text editor
  touch README.md
  touch file1.md

# Check to confirm the files you have created using the `ls` command
  ls

# stage the changed files
  git add .

# take a snapshot of the staging area (anything that's been added)
  git commit -m "My first commit"

# push changes to GitHub
  git push --set-upstream origin main

Pull requests

A Pull Request is a "message" that lets you inform other contributors of the changes that you have pushed to a branch in a repository on GitHub.

You contribute to other people's projects by creating a new branch, which essentially gives you a copy of what is there in the main branch. You can make your changes in the new branch and commit the changes to GitHub before opening a pull request.

A pull request proposes your changes to someone, asking the person to review, pull in your contributions and merge them into their branch. It shows the differences of the contents from both branches.

Opening a pull request

# Pull the repository that you pushed to GitHub so that you can be update your local repository
 git pull

# Create a new branch and switch to the new branch
 git checkout -b new-branch

# Make some changes to the files that you created.
# Write something inside the file.
# Press `CTRL` + D to terminate the command
  cat > README.md

# stage the changes made to the files
git add .

# take a snapshot of the staging area (anything that's been added)
git commit -m "Modified README.md file"

# push changes to GitHub
git push --set-upstream origin new-branch

You will now have changes in a branch off the main branch. You can now open a pull request.

Click on the Pull requests tab of your github- introduction repository.

Click New pull request button.

In the Comparisons box, select the branch you made changes to, new-branch, to compare with main branch (the original).

Confirm the changes in the diffs on the comparing changes page and make sure they are the changes that you want to submit.
Click Create pull request.

Give your pull request a title and a brief description of changes made.
Click Create pull request.

Congratulations!🎉 You have created a new pull request ready for review and merging of your branch. You can learn more about Git and GitHub from the GitHub docs.

Conclusion

By using Git and GitHub, your production is boosted and you can focus the time you spent thinking about your project history to other projects. GitHub, and specifically, pull requests are the heart of collaboration. You can contribute to projects from anywhere around the globe and be sure of no data loss.

Javascript: Building a Dice Game

Stephen Gachoki — Mon, 13 Feb 2023 13:52:28 +0000

Introduction.

The dice game is a duo-player game that is very interesting to play and brings the feel of the physical dice game to the players.
The players roll the dice and their cumulative scores are updated consistently until the active player hits a 1. Hitting a 1 means that the active player loses their current scores and the game switches to the next player. You should use the hold button to update your overall score and to make sure that you do not lose your high scores before switching to the next player. The first player to hit a 100 and above cumulative points wins the game. From this game, you will learn more about the JavaScript DOM manipulation.

Overview

This tutorial puts the DOM(Document Object Model) skills into practice. You should already have knowledge on how to manipulate the DOM. This knowledge will come in handy in our small project.

Prerequisites.

This tutorial blog assumes that you already have HTML and CSS knowledge and you are just going to work with JavaScript to make the game functional.
This project however, will be helpful to both code newbies and intermediate programmers who want to brush their JavaScript skills.

HTML and CSS starter files.

The starter files for the HTML and CSS of this project can be found on my GitHub page plus the images required therein: Github.

Clone the project to your local machine and let's enjoy the ride.

By now, your website should be looking like this:

With all that set, you are now ready to begin our adventure.

Functionality with JavaScript.

Looking at your HTML code, you can see that you have linked all the important scripts (script.js and style.css) meaning that you can work directly on separate sheets and expect all the changes to occur within the markup.

As seen in the image, the dice image shown is hard coded as well as the scores. These should be generated automatically according to the dice rolled.

1. Selecting the elements.

The first step is to select all the elements that you are going to manipulate (Work with). You use the querySelector and the getElementById methods to select your elements using both the IDs and the classes.

//Selecting Elements
const player0 = document.querySelector('.player--0');
const player1 = document.querySelector('.player--1');
//Final cumulative scores
const score0Element = document.querySelector('#score--0');
const score1Element = document.querySelector('#score--1');
//Current Scores and the Dice element.
const currentScore0 = document.getElementById('current--0');
const currentScore1 = document.getElementById('current--1');
const diceElement = document.querySelector('.dice');
//Buttons
const btnRoll = document.querySelector('.btn--roll');
const btnNew = document.querySelector('.btn--new');
const btnHold = document.querySelector('.btn--hold');

2. Initializing the game.

You need to make all the elements flexible by removing the hard coded values and manipulating them using the DOM whenever the dice is rolled.
You should set the final score to begin at 0 and be updated continuously as the game progresses. The dice image too should be hidden since it is only supposed to show after the dice is rolled.

The scores accumulated by the active player are supposed to be stored in an array so that at the end of the game, they are added and displayed on their final score element.

 let scores, currentScore, activePlayer, playing;

// Defining a function to initialize the whole game when called.

 const init = () => {
   scores = [0, 0];
   currentScore = 0;
   activePlayer = 0;

  //Final scores elements set to zero
   score0Element.textContent = 0;
   score1Element.textContent = 0;

 //Set surrent score elements to zero
   currentScore0.textContent = 0;
   currentScore1.textContent = 0;
   playing = true;

   diceElement.classList.add('hidden');
   player0.classList.remove('player--winner');
   player1.classList.remove('player--winner');
   player0.classList.add('player--active');
   player1.classList.remove('player--active');
 };

init();

3. Roll Button Functionality.

The first button that you need to work with is the "Roll Dice" button. When clicked, it rolls the dice and gives us the final number rolled, displays the rolled dice to the website and checks if the dice is equal to one. If the dice rolled is equal to 1, the game switches to the next player.

//Button Roll Functionality
btnRoll.addEventListener('click', function () {
  if (playing) {
    //1. Generate a random dice number between 1 and 6.
    const dice = Math.floor(Math.random() * 6) + 1;

    //2. Display dice
      // Set the image source to the rolled dice
    diceElement.src = `dice-${dice}.png`; 
     // Remove the 'hidden' class to display the dice that has been rolled.
    diceElement.classList.remove('hidden');

    //3. Check if the number is equal to 1; If true, move to the next player.
    if (dice !== 1) {
   //Update the current score of the current player. 
      currentScore += dice;
   // Display the current score to the page.
      document.getElementById(`current--${activePlayer}`).textContent =
        currentScore;
    } else {
      //switch to Next Player
      switchPlayer();
    }
  }
});

4. Switching the players.

In the code above, if the current player rolls a 1, the game is supposed to switch to the next player. The code to switch the player is repeated twice, thus you need to create a function to reuse at both instances to keep your code DRY (Do not Repeat Yourself).
You set the active player to be from zero since we store their scores in an array and you need to access the scores using bracket notation.


function switchPlayer() = {
//Display the current score of the active player.
  document.getElementById(`current--${activePlayer}`).textContent = 0;
  // Set the current scores to zero.
  currentScore = 0;
 //If active player is player 0, switches to player 1 else sets the player to 0.
  activePlayer = activePlayer === 0 ? 1 : 0;
 /*Toggles between player--active class.
 Adds the 'player--active' class to an element if it is not there and removes it if it is already there.
Already defined in the CSS file*/
  player0.classList.toggle('player--active');
  player1.classList.toggle('player--active');
};

5. Hold Button Functionality.

The hold button is supposed to update the cumulative scores of the current player and display it, reset the current score of the active player to zero, and then switch immediately to the next player.
If the cumulative scores of the active player is equal to or greater than 100, the player is considered the winner and the winner class is added to the element which changes the background color.

btnHold.addEventListener('click', function () {
  if (playing) {
    // 1. Add the current score to the player's score
    scores[activePlayer] += currentScore;
    // Display the score to the current player's scores
    document.getElementById(`score--${activePlayer}`).textContent =
      scores[activePlayer];
    // Check if the score[activeplayer] >= 100, if true exit the game
    if (scores[activePlayer] >= 100) {
      //Finish the game
      diceElement.classList.add('hidden');
      // Set playing to false so that none of the buttons works.
      playing = false;
     // Add the winner class to the active player if the score is greater or equal to 100.
      document
        .querySelector(`.player--${activePlayer}`)
        .classList.add('player--winner');
    // Remove the player active class from the winner to make sure the game ends.
      document
        .querySelector(`.player--${activePlayer}`)
        .classList.remove('player--active');
    } else {
      switchPlayer();
    }
  }
});

6. New Game button functionality.

Now that you have all buttons working well, it's time to make your "New Game" button functional. This will be easy since in the event where you click the new game button, it is supposed to initialize everything we have manipulated back to the initial content.

btnNew.addEventListener('click', function () {
//We call the init function which has all the code to revert everything to original.
  init();
});

Conclusion

We have looked at how we can use JavaScript to manipulate CSS styles and HTML elements in response to the clicking of buttons.
I hope you enjoyed the article and learnt something from it.

Javascript: What You Need to Know (Part one)

Stephen Gachoki — Thu, 02 Feb 2023 21:19:24 +0000

Basic Syntax
- Numbers
- Strings
- Booleans
- Undefined and Null
Operators
- Arithmetic Operators
- Assignment Operators
- Comparison Operators
- Logical Operators
- Conditional Operator
- Console.log function

The Nitty Gritty of The Javascript Language
As a newbie programmer or a beginner to the Javascript language, you often find yourself stranded on what to learn.
First of all, what exactly is this Javascript that I am talking about? Well, Javascript is the most popular language used in the websites' client-side development. More about Javascript can be found in MDN's website, the developer's best friend. Here I am a bit biased on the web development side, but hey, do not go away just yet; you will encounter these Javascript basics irregardless of your motivation to taking any Javascript roadmap.

Learn these Basics of Javascript Language and then move on:

Basic syntax
DOM Manipulation (Web Development).
Fetch API / Ajax.
Async Await.
Event Listeners. (Web)
ES6+ Javascript.
Promises.
Classes.
Array Methods.
Scoping.
Hoisting.
Closures.

Basic Syntax

The ice peak of any language is learning the basic syntax of the language and advance to the challenging parts with time. Javascript has data types that are the building blocks of any code written in Javascript. These data types include: numbers, strings, Booleans, Undefined and Null.

Numbers

_Numbers _are the integer values, both negative and positive and are used to quantify something and can also be used in arithmetic calculations.

let y = 10;
let x = 9;
let z = y + x;
//->19

Strings

Strings are used to represent text. This data type makes use of quotation marks; Single quotes('), double quotes("), and backticks(`). Backticks have a special purpose when used in strings and are called Template literals-More about this to be discussed a bit later.
It is mandatory to use the quotation marks since not using them would introduce bugs to your code.

let day = 'Wednesday';
let lesson = "Javascript Fundamentals";
let newStr = "123";

Booleans

Booleans are true and false values. These values are assigned to variables, object properties, arrays and comparisons. These data types are used just as they are:

let married = false;
let hasDriversLicense = true;

console.log( 3 > 2);
//-> true

`
The last code evaluates to true. This is because, the program asks the question, "Is 3 greater than 2?" and prints the answer to the console. Those are the booleans.

Undefined and Null

Null is the deliberate absence of a value in the code. It is encountered whereby you assign it to a variable to mean that the variable might not have a value now, but it will have one later.

Undefined on the otherhand means that the value that is being referred to does not exist in the compiler. An example is when you define an empty variable.

let newNum;
console.log(newNum);
// -> undefined

let boxLabel = null;

Operators

Now that we have looked at data types, let's look at Operators. There are different types of operators in Javascript. The most common and the most used operators include:

Assignment Operators.
Arithmetic operators.
Comparison operators.
Logical operators.
Conditional operators.

Arithmetic Operators

The Arithmetic operators takes two numerical values as their operands, one on the left and one on the right side and returns one numerical value. The most common ones are addition(+), subtraction(-), division(/) and multiplication(*).

In addition to these standard operators, there are other arithmetic operators that are offered by Javascript that include:

Remainder operator -denoted by (%).This one returns the value that remains after dividing two values.
Increment operator - denoted by (++). It adds 1 to its operand. It is a unary operator meaning that it performs operations on only one operand.
Decrement operator - denoted by (--). It subtracts 1 from its operand. It is a unary operator too.

let x =  5 + 2 - 3 * 2 / 2;
// Ans = 4

let y = 5;
y++;
//y will be equal to 6

let z = 10;
z--;
//z will be equal to 9

let remainder = 10 % 3;
// Ans = 1

Operators have precedence whereby one operation is performed first before it moves on to the other incase they appear in the same code. *, / and modulo (%) have the same precedence and are handled first in an operation. - and + have the same precedence and are handled last after *, % and /.

Assignment Operators

Assignment operators as the name suggests, are used to assign values on their right to operands on their left side. The most common assignment operator is the = and we have seen it before in the code blocks.
`

let x = 10;
//Assigns the value 10 to x. Thus whenever we invoke x, we get 10.

There are other types of assignment operators called the Compound Assignment Operators which are shorthand for some operations.

x += 1; means x = x + 1;
//Addition Assignment 

x -= 2; means x = x - 2;
//Subtraction Assignment 

x *= 5; means x = x * 5;
//Multiplication Assignment

x /= 4; means x = x / 4;
//Division Assignment 

x %= 2; means x = x % 2;
//Remainder Assignment

Comparison Operators

The comparison operators are used to compare two operands (Binary operators). They compare whether one operand is greater than denoted by (>), less than denoted by (<), less or equal to denoted by (<=), greater or equal to denoted by (>=), equal to the other (==) or strictly (exactly) equal to denoted by (===).

console.log(3 > 2);
//->true (This is true because 3 is greater than 2)

console.log(5 < 7);
//->true (This is true because 5 is less than 7)

console.log(2 >= 3);
//->false (This is false because 3 is greater than 2)

console.log(2 <= 3);
//->true (This is true because 2 is less than 3)

The most crucial part of using the loosely equal (==) operator and the strict equal operator (===) is to know the difference between the two. The loosely equal(==) applies type conversion before comparison while the strict equal (===) compares the two operands without conversion. In Javascript, there is type conversion that is triggered by some operators before comparison. For example, a string can be converted to a number before the comparison is done. This is done internally by Javascript.

console.log("2" == 2);
//-> true (This comparison translates to true since the string "2" is first converted to number then compared to 2.)

console.log("2" === 2);
//-> false (This translates to false since there is no type conversion done here. The operands are compared as they are.)

The Not equal (!=) operator - Returns true if the operands are not equal.
The Strict not equal (!==) - Returns true if the operands are of the same type but not equal, or are of different type.

Logical Operators

Logical operators are used with Boolean (logical) values. They return a Boolean value after the conditions set by the operands are met. There are three logical operators:

The logical and denoted by &&. This operator returns true if both the operands are true.

const example = true && true; //true
//-> return true since both the operands are true.

const example2 = false && true; //false
//->returns false since one of the operands is false meaning they are different.

const example3 = false && false; //false
//->returns false since all the operands are false.

const example4 = "Cats" && "Dogs" //Dogs;
//->returns Dogs.

The logical or denoted by ||.It returns expression1 if it can be converted to true; otherwise, returns expression2. Thus, when used with Boolean values, || returns true if either operand is true; if both are false, returns false.

console.log(true || false) // true.
// -> returns true since one of the operands is true.

console.log(false || false) //false
// -> returns false since all the operands are false and none can be converted to true.

The logical not denoted by !. This operator gives the opposite of the operand given. For example, !true == false and !false == true.

Conditional Operator

The conditional operator (Also called the Ternary operator) is the only Javascript operator that takes three operands. It's general syntax is: condition ? expression to execute if the condition is met(truthy) : expression to execute if the condition is not met (falsy).
This operator is used instead of if...else condition.

console.log(true ? 1 : 2) // 1
//-> returns 1 because the condition is true.

const age = 13;
age >= 18 ? console.log("Adult") : console.log("Minor") // Minor
// -> returns Minor because the condition has not been met / it is false since age is 13.

Console.log function

You might be wondering what console.log in my code means. Well,
console.log is a function that is used to print values to the console in Javascript.

PART 2 IS ON THE WAY...HAPPY CODING.

A DEEP DIVE INTO C PROGRAMMING. (Part 1)

Stephen Gachoki — Sun, 11 Sep 2022 15:43:13 +0000

A little History of the C language

A little dive into the history of C would be a good place to start I presume. Dennis Ritchie is the name behind this magnificent language. The C programming language had it predecessor from B created by Ken Thompson. 'C' is more of an upgrade of B. It was founded in 1978 by both Brian Kerninghan and Dennis Ritchie. C is the programming language that was used to write UNIX developed by both Dennis Ritchie and Ken Thompson. Dennis Ritchie died in October 2011 having received many awards based on his inventions and creations. Dennis Ritchie.

A journey of a thousand miles is started by taking the first step- Chinese Proverb.

Before we dive in into C programming we have to know what C as a language is and why it is important to learn C programming. C is considered a high-level programming language but compared to other programming languages such as Python, Javascript and Java, it is the lowest level programming language. "What high level and low level language is he talking about?" You probably must be asking yourself what the meaning of high and low level language by now. The highest level is the human language that we use to communicate especially English. The lowest level is the machine language or should I call it the computer language (binaries). This means that a high level programming language syntax is close to human language and can comfortably be read by human, the vice versa is true. This means that the C syntax can easily be understood by humans.

Too much of that already, but we can't begin before we know what type of language C is. C is a compiled language. This means that it's not possible to write a C program and run it straight away after saving it. You have to pass it through a compiler so that it can be executed by the machine. As you already know, C being a high-level programming language it is written in a language near human language that the machine, in this case, your computer can not understand. Thus, the written program must be converted to a language that the computer understands. That is where the compiler comes in. The source code passes through four main stages before it can be executed. That's a lot of stages I know. Am I the one who is going to do all that? Relax, the compiler does all the work for you. The stages are preprocesser, compiling, assembling and the linking.

The preprocesser stage: This is the stage where the required libraries defined in the header are assembled and made available to the source code. The extension of the source code at this level is .c .Then the source code goes to the compiler stage.
The Compiling stage: The compiler compiles the source code plus all the libraries that have been assembled into another file called assembly file.
The assembly stage: At this stage we have an assembly file. The compiler assembles the required function code and makes it available for the linker to link and make an executable file out of it. The assembled data is stored in an object file with the extension .obj for windows and .o for unix users.
The linker:After all the required function code is made available, it is now time for the linker to connect all of them plus the object file to make an executable file that will now run on the computer to perform the task intended. The linker will yield an executable file with the extension .exe for windows users and a.out for unix users. This is now the binary code.

That's a lot to do isn't it? Well, that's less than blink of an eye to the computer. At this stage you know that you need a compiler if you are using a windows system but for Unix users, the gcc compiler or the gnu compiler comes already installed in the machine. All you need to do is run the gcc command.(We'll look at it later.)

gcc file_name.c -o new_filename

Now that you know what happens to your program after you write it, it is time to get our hands dirty. Look out for my next article where we will be writing our first code and learning more about the C syntax.

Forem: Stephen Gachoki

Introduction to GitHub

Understanding the basics of version control and collaboration with GitHub

Table of contents

Introduction

What is GitHub

Why GitHub

Git vs. GitHub

GitHub Desktop vs. GitHub CLI

Cloning a Git Repository

How to create an empty repository

Prerequisites

Creating the repository on GitHub

How to Clone a git repository

Prerequisites

Cloning the repository

Committing to a repository

Pull requests

Opening a pull request

Conclusion

Javascript: Building a Dice Game

Introduction.

Overview

Prerequisites.

HTML and CSS starter files.

Functionality with JavaScript.

1. Selecting the elements.

2. Initializing the game.

3. Roll Button Functionality.

4. Switching the players.

5. Hold Button Functionality.

6. New Game button functionality.

Conclusion

Javascript: What You Need to Know (Part one)

Table of contents

Basic Syntax

Numbers

Strings

Booleans

Undefined and Null

Operators

Arithmetic Operators

Assignment Operators

Comparison Operators

Logical Operators

Conditional Operator

Console.log function

A DEEP DIVE INTO C PROGRAMMING. (Part 1)

A little History of the C language