DEV Community: Danstan-O

How to Create and update your Github Personal Token Issue

Danstan-O — Fri, 05 May 2023 16:22:04 +0000

1. Creating a personal acccess Token token

Disclaimer: a personal access token should be treated as a password to GitHub.

GitHub supports two types of personal access tokens;

Fine-frained personal access tokens.
Personal access tokens (classic).

Github recommends that you use fine-grained personal access tokens instead of personal access tokens(classic) whenever possible.

You can follow the instructions in the link provided in references on how to generate an access token.

2. Updating an expired token

If you have a token that you have been using and it expires you can run the command git remote -v. This command shows you your current origin which will look like;
https://[PERSONALACCESSTOKEN]@github.com/[USERNAME]/[REPO].git.
There are two steps to update a expired token;

First, you have to remove the expired token by running the command git remote remove origin.
After removing the expired token you can run the command git remote -v to confirm that your token has been removed.
You now need to generate a new token following the steps highlighted in the creating a new token.
After creating a new token you need a to add a remote with your updated Github personal access token.
You can add it using the command git remote add origin + your new generated token as follows; git remote add origin https://[PERSONALACCESSTOKEN]@github.com/[USERNAME]/[REPO].git and you are done.

References

Creating a personal access token

Introduction to static libraries in C programming language.

Danstan-O — Sun, 09 Apr 2023 21:36:00 +0000

WHAT IS A STATIC LIBRARY

A library is a collection of already build functions, variables, classes and anything that should make your code run. You can use the code in your program without knowing how it's declared.
Static libraries are a collection of object files that are linked into the program during the linking phase.

HOW TO CREATE A STATIC LIBRARY

We first need to create a normal c file. After creating the c file define all the functions needed in that file.
After our functions have been defined we create a header file that will be used to store all the prototypes that will be needed in our program.
The header file should have a .h file extension.
The following code should be included in our main.h file.

#ifndef MAIN_H
#define MAIN_H


#endif

A WALK THROUGH EXAMPLE

I will create 2 c files and use them to demonstate the concepts described above. The file names will be monalisa.c and sum.c. We also have to create the main.c file which will act as our main entry point to the program.
The monalisa.c file will have the following code.

#include <stdio.h>
#include "main.h"

/**
 * monalisa - file returns a print statement
 * Return: returns 0
 */

void monalisa(void)
{
printf("Welcome home, Kid\n");
}

The sum.c file can have the following snippet

#include <stdio.h>
#include "main.h"

/**
 * sum - adds up two integers
 * @z: our first input value
 * @y: our second input value
 * Return: returns the sum of two integers
 */

int sum(int y, int z)
{
int sum;
sum = y + z;
printf("The sum of the two integers is: %d\n", sum);
return (sum);
}

our main.c file can have the following piece of code

#include "main.h"

/**
 * main - the major entry point
 * Return: it returns a 0
 */

int main(void)
{
monalisa();
sum(1, 2);
return (0);
}

and finally our main.h file will have the following piece of code that will contain our prototypes and will be used to call the monalisa and sum functions.

#ifndef MAIN_H
#define MAIN_H

void monalisa(void);
int sum(int y, int z);


#endif

Running the command 'gcc -c *.c' generates all the .o files from the .c files that will be in the current directory.

We can then create a library named lib.a with the command
'ar rcs lib.a'

After creating the library we run the command 'ar rcs lib.a *.o' which helps move copies of every .o files into our library.
Note: The s flag tells the ar command to add an index to the archive or update it if the index already exists.
This can also be achieved by running the command 'ranlib lib.a' after generating the .o files.

After indexing our library we can run the commandn 'ar -t lib.a' to see if our file is indexed properly.
Finally we run the ' nm lib.a' command to list all the symbols of the files that we have and from this we can see the files that we were unable to link into our object file.

TOP TIP

We can create an executable file script that can be used to automate the process of generating .o library files.
Create a file named static_lib.sh and put the following code in it.

#!/bin/bash
gcc -c *.c
ar rc bilan.a *.o
ranlib bilan.a

After writing the code you can make the file executable by running the following command.

chmod u+x static_lib.sh

The above script creates a static library called bilan.a from all the .c files that are in our current directory.

After creating an executable file we run the following commmand on the terminal to test our executable and add all the .o files that will have been generated from the .c files into our library named bilan.a
./create_static_lib.sh

All the libaries have a .a exentionj to them.

By Oduor.

Contributing to an open source tech project on github.

Danstan-O — Sun, 05 Feb 2023 16:30:24 +0000

In this article I am going to talk about some of the advantages of contributing to open source projects and how you can start doing it.

Advantages of contributing to an open source project

It helps you build the muscle power needed in programming by giving you different projects to work on.
It helps you learn new skills, tools and different programming technologies.
It builds your reputation and you can showcase the contributions to prospecting employers.
It helps you meet new people.
In the process of meeting new people you get to improve on your communication skills as an individual.

Since you are now convinced of why you should start contributing to open source projects, how can you start doing that?

1. Identify a project that you are interested in.

The first thing that you need to do is identify a project that excites you among the many projects that the community maybe working on. You can do this by going to your community's homepage on github or gitlab.
i.e In this article I will be using the github as my primary reference.

2. Fork the repository

This will give you your own cpy of the repo that you can manipulate when working on the project.

Clone the repository

Since git collaboration is an advanced feature when working with git I will assume that you are familiar with this step and I will jump right into you going to get an issue you will be working on.

Getting an issue.

An issue is a feature that you will try to implement and see that it's functionalities work as it was intended in the initial design. An issue will come with an explanation of where you need to place the components needed in achieving the desired feature, how the feature should look like and sometimes a link to the project design.

Issues are taken from the parent repository where you forked the project and they are continuously updated by the project lead.
When you have picked an issue that you want to work on you can leave a comment to tell everyone that you will be working on that issue and they can choose something else to work on.

Creating a pull request

After working on an issue and being confident that your code works as intended you have to commit the changes and push the code to github.
After pushing the code you go to github and create a new pull request so that your work can be reviewed and get merged to the main project.

After creating a pull request you can notify someone to review your changes on github.

What happens when changes have been merged.

After a contributors changes have been reviewed and merged to the main project you have to sync your forked repository with the main repository.
You can do this by going to the github repository that you forked and syncing the fork.

After this you have to do a git pull on the terminal to get the changes locally on your machine then you can continue working on the project.

Extra tip

When making commits to github you can add some descriptive emoji just to spice things up and also make the person reviewing the code have an idea of what you were doing even before looking at the code or the comment sent.
Here is a link to gitmoji that can help you achieve sending emojis when doing your commits.
gitmoji link

For example, after updating your readme file you can commit something like: " 📝 updated my readme file"

Thanks for reading!
Have a lovely time!