DEV Community: sourav-ojha

Git Commands Cheat Sheet

sourav-ojha — Mon, 06 Nov 2023 07:22:37 +0000

Git Vocabulary

Bare Repository
- A repository that doesn’t have a working directory.
Branch
- An active area of development in Git. The newest commit displays the end of the branch.
Blame
- Refers to the most recent alteration to every line in the file. Displays Author, Revision, and Time.
Commit
- Record of a moment in Git history containing specifications of a changeset.
Checkout
- Process whereby a particular commit is chosen from the repository, and the condition of the file associated with it and the directory tree are reproduced in the working directory.
Diff
- The difference in changes between saved changes or two Commits.
Detached Head
- State in which a specific commit is checked out rather than a branch.
Fetch
- Retrieves the most recent changes in the branch and the local or remote repositories.
Hash
- Unique SHA1 code for each Commit.
Head
- Name of the Commit at the end of a Branch.
Fork
- When you Fork the repository, you can add Commits and add Pull Requests.
Index
- A group of files that hold state information.
Merge
- Includes changes from named commits (from when their histories split from the current branch) into the current branch.
Master
- Git’s default development Branch.
Pull Request
- Suggests changes to the Master Branch.
Repository
- A group of Commits, Branches, and Tags to identify Commits.
Push
- Pushes new changes once they’ve been committed.
Working Tree
- The directory of files that you are currently working on.
Origin
- Default Upstream Repository.

Git Setup

Initialize an empty Git repository:
```
git init
```
Clone a repository (local or remote via HTTP/SSH):
```
git clone [repo / URL]
```
Clone the repository from GitHub to the project folder:
```
git clone [repo / URL] [folder]
```

Git Configuration

Configure the username to be used for all actions:
```
git config --global user.name "[your_name]"
```

Configure the email to be used for all actions:

git config --global user.email "[email_address]"

Create an alias for a Git command:

git config --global alias.[alias_name] [git_command]

Set a default text editor:

git config --system core.editor [text_editor]

Open Git’s global configuration file:
```
git config --global --edit
```
Enable the helpful colorization of command line outputs:
```
git config --global color.ui auto
```

Managing Files

List which files are staged, unstaged, and untracked:
```
git status
```
Show history of changes:
```
git log
```
List all commits from all branches:
```
git log --all
```
Compare two branches by showing which commits from the first branch are missing from the second branch:
```
git log [branch1]..[branch2]
```
To see the difference between the last commit and the working directory:
```
git diff HEAD
```
Display the content and metadata of an object (blob, tree, tag, or commit):
```
git show [object]
```
To see the difference between the working directory and the index:
```
git diff
```
To see the difference between the last commit and the index:
```
git diff --cached
```

Git Branches

List all branches in the repository:
```
git branch
```
Create a new branch:
```
git branch [branch]
```
List all branches - local and remote:
```
git branch -a
```
List all remote branches:
```
git branch -aa
```
Switch to a branch under a specified name:
```
git checkout [branch]
```
Rename a branch:
```
git branch -m [new_branch_name]
```
Delete a local branch:
```
git branch -d [branch]
```
Merge a branch:
```
git merge [branch]
```

Making Changes

Add the current changes of a file to staging:
```
git add [file/directory]
```
Add the entire directory changes to staging:
```
git add .
```
Commit the changes with a message:
```
git commit -m "[descriptive_message]"
```

Rewriting History

Replace the last commit with a combination of the staged changes and the last commit combined:
```
git init
```
Rebase the current branch with the specified base (It can be a branch name, reference to a head, tag, or a commit ID):
```
git rebase [base]
```
Lists changes made to the HEAD of the local repository:
```
git reflog
```

Undoing Changes

Undo all changes in the specified file/directory by creating a new commit and applying it to the current branch:
```
git revert [file/directory]
```
Unstage the specified file without overwriting changes:
```
git reset [file]
```
Undo all changes that happened after a specified commit:
```
git reset [commit]
```
See which files should be removed from the current directory:
```
git clean -n
```
Remove the unnecessary files in the directory:
```
git clean -f
```

Remote Repositories

Remove the unnecessary files in the directory:
```
git remote add [name] [URL]
```
Fetch a branch from a remote repository:
```
git fetch [remote_repo] [branch]
```
Fetch the specified repository and merge it with the local copy:
```
git pull [remote_repo]
```
Push a branch to a remote repository with all its commits and objects:
```
git push [remote_repo] [branch]
```

In the fast-paced world of software development, mastering Git is an invaluable skill. With this Git Commands Cheat Sheet, you have a powerful resource at your fingertips to streamline your version control workflow, whether you're a beginner or an experienced developer. Git empowers collaboration, helps you manage your project history, and ensures code integrity.

Remember, Git is not just a tool; it's a journey. As you continue to explore its capabilities and best practices, you'll unlock new ways to work more efficiently and collaboratively with your team. So, keep this cheat sheet handy, and may your coding adventures be filled with success and innovation.

Happy coding! 🚀👨‍💻👩‍💻

Need for Speed: Turbocharge Your Web App Performance!

sourav-ojha — Thu, 19 Oct 2023 11:07:18 +0000

Have you ever visited a website that loaded at a pace slower than a sloth on a Sunday afternoon, and you felt like you had all the time in the world to make a cup of coffee before it loaded? We've all been there, and it's not a delightful experience, whether you're a developer or an everyday internet surfer.

The good news is that there are ways to prevent this digital snail race. As a Full-Stack Developer, I've had my fair share of encounters with sluggish web apps, and let me tell you, the need for speed is real! But fret not, fellow developers and web enthusiasts, because in this article, I'm going to share some practical tips and tools to turbocharge your web app performance. And guess what? It's going to be a fun ride!

The Need for Speed

Remember that scene in 'The Fast and the Furious' when Vin Diesel revs up his car to warp speed? Well, we can't promise you Vin Diesel, but we can promise you warp speed for your web app.

Tip 1: Optimize Your Images

Think of images as the baggage of your web app. The more baggage you have, the slower you'll move. Compress and optimize your images, and watch your app shed those extra pounds.

Explanation: Large images can be the primary culprits behind a sluggish web app. When you compress and optimize your images, you reduce their file size without significantly compromising quality. Use image editing tools or online services to ensure your images are in the right format and resolution.

Tip 2: Minify Your Code

Ever read a novel that had way too many words and not enough story? Your web app's code can be the same. Minify it, strip away the extra spaces and comments, and let it tell a faster, more exciting story.

Explanation: Minifying your code involves removing unnecessary characters such as white spaces, line breaks, and comments, which can bloat your files. There are tools and plugins available for various programming languages that can automatically minify your code.

Tip 3: Optimize Server Responses

Your server response time can be the Achilles' heel of your web app's speed. Optimize server responses, database queries, and API calls to minimize waiting times for users.

Explanation: Slow server responses can be a significant bottleneck. Consider optimizing database queries, using server-side caching, and optimizing API calls. Reducing the time it takes for your server to respond can drastically improve your web app's performance.

The Need for the Right Tools

Now, imagine you're a wizard, and you have a magic wand (or in our case, development tools) to cast spells that speed things up.

Tool 1: Google PageSpeed Insights

Google to the rescue! PageSpeed Insights is like having a personal coach for your web app. It gives you suggestions to make your site faster, and who can say no to Google's advice?

Explanation: Google PageSpeed Insights analyzes your web page and provides optimization suggestions. It evaluates performance for both mobile and desktop devices, offering insights into what needs improvement. Use these recommendations to enhance your site's speed.

Tool 2: GTmetrix

Think of GTmetrix as the app doctor. It diagnoses issues slowing down your web app and prescribes the right treatment.

Explanation: GTmetrix evaluates your web page's performance and provides a comprehensive report. It offers actionable recommendations for improvements, such as image optimization, browser caching, and reducing server response times. Follow these recommendations to boost your web app's speed.

More Tips for Lightning-Fast Web Apps

Tip 4: Browser Caching

Imagine if you had to carry your entire closet with you every time you went out. Sounds tiring, right? Web browsers cache (store) certain elements of a website so that users don't need to download them every time they visit. Utilize browser caching to reduce loading times for returning visitors.

Explanation: By instructing web browsers to store certain files locally, like images and CSS, you reduce the amount of data that needs to be fetched from the server on subsequent visits. This speeds up the user experience significantly.

Tip 5: Content Delivery Networks (CDNs)

Have you ever ordered a pizza and it arrived cold? That's like your web content travelling a long distance before reaching the user. CDNs are like teleportation devices for web assets. They distribute content across a network of servers worldwide, ensuring that your web app's files are delivered from the server closest to the user.

Explanation: CDNs, like Cloudflare and Akamai, reduce the physical distance between users and the server by distributing your content to multiple locations. This reduces latency and accelerates content delivery. By using a CDN, you can significantly improve the speed and availability of your web app.

The Need for Humor

Every good adventure needs humour. After all, it's all about keeping the spirits high while making those improvements.

Time for a Giggle: Have you ever seen a turtle doing a sprint? That's how your web app might be feeling right now!

So, whether you're a seasoned developer or someone who just Googled "how to make my website faster," remember that the need for speed is universal. With a sprinkle of humour and a dash of practical tips and tools, your web app will be zooming like Vin Diesel in no time. And you'll make your users happier than a kid in a candy store.

So, there you have it, folks! Get ready to rev up your web app and take it to the fast lane. Speed isn't just for Vin Diesel; it's for your web app too. May your digital journey be smooth, speedy, and full of delightful user experiences. Happy coding!