Hands-On Git Workflow with Code Example

Go through the Git workflow step by step with hands-on practice (code example)

Following the previous An Intro to Git and Github for Beginners, today we’re gonna get our hands dirty. This story is going to walk you through the Git workflow with practical code examples. Since Github is the most popular website to host Git repositories, we’ll be using it as examples. We’ll be working with Git’s Command-line interface, therefore, Github CLI is not considered.

Prerequisite

1. You have to have Git installed on your local machine. You can follow the  official documentation to do so.
2. Have a  Github account (a free version would suffice).

#linux #git #command-line #github

What is GEEK

Buddha Community

Static Code Analysis: What It Is? How to Use It?

Static code analysis refers to the technique of approximating the runtime behavior of a program. In other words, it is the process of predicting the output of a program without actually executing it.

Lately, however, the term “Static Code Analysis” is more commonly used to refer to one of the applications of this technique rather than the technique itself — program comprehension — understanding the program and detecting issues in it (anything from syntax errors to type mismatches, performance hogs likely bugs, security loopholes, etc.). This is the usage we’d be referring to throughout this post.

“The refinement of techniques for the prompt discovery of error serves as well as any other as a hallmark of what we mean by science.”

• J. Robert Oppenheimer

Outline

We cover a lot of ground in this post. The aim is to build an understanding of static code analysis and to equip you with the basic theory, and the right tools so that you can write analyzers on your own.

We start our journey with laying down the essential parts of the pipeline which a compiler follows to understand what a piece of code does. We learn where to tap points in this pipeline to plug in our analyzers and extract meaningful information. In the latter half, we get our feet wet, and write four such static analyzers, completely from scratch, in Python.

Note that although the ideas here are discussed in light of Python, static code analyzers across all programming languages are carved out along similar lines. We chose Python because of the availability of an easy to use ast module, and wide adoption of the language itself.

How does it all work?

Before a computer can finally “understand” and execute a piece of code, it goes through a series of complicated transformations:

As you can see in the diagram (go ahead, zoom it!), the static analyzers feed on the output of these stages. To be able to better understand the static analysis techniques, let’s look at each of these steps in some more detail:

Scanning

The first thing that a compiler does when trying to understand a piece of code is to break it down into smaller chunks, also known as tokens. Tokens are akin to what words are in a language.

A token might consist of either a single character, like (, or literals (like integers, strings, e.g., 7, Bob, etc.), or reserved keywords of that language (e.g, def in Python). Characters which do not contribute towards the semantics of a program, like trailing whitespace, comments, etc. are often discarded by the scanner.

Python provides the tokenize module in its standard library to let you play around with tokens:

Python

1

import io

2

import tokenize

3

4

code = b"color = input('Enter your favourite color: ')"

5

6

for token in tokenize.tokenize(io.BytesIO(code).readline):

7

    print(token)

Python

1

TokenInfo(type=62 (ENCODING),  string='utf-8')

2

TokenInfo(type=1  (NAME),      string='color')

3

TokenInfo(type=54 (OP),        string='=')

4

TokenInfo(type=1  (NAME),      string='input')

5

TokenInfo(type=54 (OP),        string='(')

6

TokenInfo(type=3  (STRING),    string="'Enter your favourite color: '")

7

TokenInfo(type=54 (OP),        string=')')

8

TokenInfo(type=4  (NEWLINE),   string='')

9

TokenInfo(type=0  (ENDMARKER), string='')

(Note that for the sake of readability, I’ve omitted a few columns from the result above — metadata like starting index, ending index, a copy of the line on which a token occurs, etc.)

#code quality #code review #static analysis #static code analysis #code analysis #static analysis tools #code review tips #static code analyzer #static code analysis tool #static analyzer

7 Best Practices in GIT for Your Code Quality

There is no doubt that Git plays a significant role in software development. It allows developers to work on the same code base at the same time. Still, developers struggle for code quality. Why? They fail to follow git best practices. In this post, I will explain seven core best practices of Git and a Bonus Section.

1. Atomic Commit

Committing something to Git means that you have changed your code and want to save these changes as a new trusted version.

Version control systems will not limit you in how you commit your code.

• You can commit 1000 changes in one single commit.
• Commit all the dll and other dependencies
• Or you can check in broken code to your repository.

But is it good? Not quite.

Because you are compromising code quality, and it will take more time to review code. So overall, team productivity will be reduced. The best practice is to make an atomic commit.

When you do an atomic commit, you’re committing only one change. It might be across multiple files, but it’s one single change.

2. Clarity About What You Can (& Can’t) Commit

Many developers make some changes, then commit, then push. And I have seen many repositories with unwanted files like dll, pdf, etc.

You can ask two questions to yourself, before check-in your code into the repository

1. Are you suppose to check-in all these files?
2. Are they part of your source code?

You can simply use the .gitignore file to avoid unwanted files in the repository. If you are working on more then one repo, it’s easy to use a global .gitignore file (without adding or pushing). And .gitignore file adds clarity and helps you to keep your code clean. What you can commit, and it will automatically ignore the unwanted files like autogenerated files like .dll and .class, etc.

#git basics #git command #git ignore #git best practices #git tutorial for beginners #git tutorials

Best Practices for Using Git

Git has become ubiquitous as the preferred version control system (VCS) used by developers. Using Git adds immense value especially for engineering teams where several developers work together since it becomes critical to have a system of integrating everyone’s code reliably.

But with every powerful tool, especially one that involves collaboration with others, it is better to establish conventions to follow lest we shoot ourselves in the foot.

At DeepSource, we’ve put together some guiding principles for our own team that make working with a VCS like Git easier. Here are 5 simple rules you can follow:

1. Make Clean, Single-Purpose Commits

Oftentimes programmers working on something get sidetracked into doing too many things when working on one particular thing — like when you are trying to fix one particular bug and you spot another one, and you can’t resist the urge to fix that as well. And another one. Soon, it snowballs and you end up with so many changes all going together in one commit.

This is problematic, and it is better to keep commits as small and focused as possible for many reasons, including:

• It makes it easier for other people in the team to look at your change, making code reviews more efficient.
• If the commit has to be rolled back completely, it’s far easier to do so.
• It’s straightforward to track these changes with your ticketing system.

Additionally, it helps you mentally parse changes you’ve made using git log.

#open source #git #git basics #git tools #git best practices #git tutorials #git commit

Hand Sanitizer in bulk - Get your effective hand sanitizer here

With the spread of various harmful virus globally causing immense distress and fatalities to human mankind, it has become absolutely essential for people to ensure proper and acute hygiene and cleanliness is maintained. To further add to the perennial hardship to save lives of people the recent pandemic of Covid-19 affected globally created the worst nightmare for people of all walks of life. Looking at the present crisis, it has become imperative for human beings to be encouraged to tackle this challenge with an everlasting strength to help protect oneself and their loved ones against the devastating effects of the virus. One thing that stands up between keeping all safe and vulnerable is by making sure that everybody attentively Hand wash periodically to help physically remove germs from the skin and getting rid of the live microbes.

The essence of apposite handwashing is based around time invested in washing and the amount of soap and water used. Technically, washing hands without soap is much less effective anyway. But incase a proper handwashing support system doesn’t become possible around, the usage of Effective Hand Sanitizer will certainly help fight to reduce the number of microbes on the surface of hands efficiently, eliminating most variants of harmful bacteria to settle.

The need has come about for Hand Sanitizer in bulk to save your daily life aptly maintaining a minimum of 60% alcohol - as per the CDC recommendations and approved by USFDA for its greater effectiveness. With the growing demand of people on the move the demand for easy to carry, small, and travel size worthy pouches that are also refillable once the product runs out is the need of the hour. To further make sure that human lives are well protected from these external viruses, it is mandatory for producer of effective Hand Sanitizer to evolve products circumspectly with ingredients that produce not just saving lives but with multiple benefits for people of all ages.

#hand sanitizer #hand sanitizer in bulk #hand sanitizer ingredient #hand sanitizer to alcohol #hand sanitizer travel size #hand sanitizer wholesale

Git Merge: A Git Workflow explained 

What is Git Merge?

Merge is a command used in Git to move the changes in branch to another. Usually, the new features are developed in the dev branch and merged into the master branch after finishing the development. All the changes in the dev branch is added to the master branch on the merge. but the dev branch will be unaffected.

— merge pic —

How to do a Git Merge

Let’s do a Git Merge step by step to understand how it works. Except the merging part, many steps from cloning the repo to publishing the changes will be the same as in Git Rebase Tutorial because we are trying to do the same thing in a different way.

Step 1: Fork and clone the desired repo

Let’s reuse our rebase-demo repository for this. Go to https://github.com/kdanW/rebase-workflow-demo and click the button ‘Fork’ in the top right-hand corner. Now go to your forked repo, click ‘Clone or Download’ button and copy the link shown.

Now go to a directory of your preference and type the following command on the terminal to download the repo into your local PC.

git clone https://github.com/<YOUR_USERNAME>/rebase-workflow-demo

#git-merge #git-workflow #github #merge #git