DEV Community: Istiak Islam

Git & GitHub for Beginners: A Hands-On Guide

Istiak Islam — Wed, 04 Jun 2025 02:41:16 +0000

🚀 Git & GitHub Made Simple

Version control is a superpower for developers. Git and GitHub is the most popular combo to make it happen. In this tutorial, you’ll learn the essential Git commands, how GitHub fits into the picture, and how to manage your code like a pro (even if you're just starting out!).

Let’s dive in! 🌊

🔄 What is Git?

Git is a version control system that helps you track changes in your code over time. It allows you to:

Save your progress (commits)
Go back to previous versions
Work with others on the same project (branches, merges)
Resolve code conflicts and maintain a clean history

🐙 What is GitHub?

GitHub is a cloud-based platform that hosts your Git repositories. With GitHub, you can:

Store your code remotely
Share it with collaborators
Review, comment, and merge changes
Manage projects using issues and pull requests

✅ Basic Git Commands

Here’s a quick overview of the most essential Git commands:

🔗 `git clone`

Copies a remote repository (e.g., from GitHub) to your local machine.

git clone <repository-url>

Example:

git clone https://github.com/username/project-name.git

📋 `git status`

Shows the current state of your working directory.

git status

You’ll see files that are:

untracked – new files not yet staged
modified – files that changed but are not staged
staged – ready to be committed
unmodified – clean and unchanged

➕ `git add`

Adds files to the staging area (preparing them for commit).

git add <file>

Add all files:

git add .

✅ `git commit`

Saves a snapshot of your staged changes.

git commit -m "Your commit message"

🚀 `git push`

Uploads your local commits to the remote repository.

git push

📁 `git init`

Initializes a new Git repository in your local directory.

git init

This sets up a .git folder to track your changes.

🌐 `git remote`

Links your local repository to a remote one (like GitHub).

git remote add origin <remote-url>

View your remote URLs:

git remote -v

🌿 `git branch`

Manages branches in your repository. You can create, list, delete, or rename branches.

🛠️ Create and Connect a Local Repository

Let’s set up a new Git project step-by-step:

Create a new folder and add your project files.
Initialize Git:

git init

Create a new repository on GitHub.
Link your local repo to GitHub:

git remote add origin https://github.com/your-username/your-repo.git

Rename the default branch to main:

git branch -M main

Push your first commit:

git add .
git commit -m "Initial commit"
git push -u origin main

From now on, just use:

git push

🌱 Branching and Merging

Branching allows you (or your team) to work on different features without affecting the main codebase.

📌 Create a new branch:

git checkout -b feature-branch

🔄 Switch between branches:

git checkout main

🧹 Delete a branch (from another branch):

git branch -d feature-branch

🔍 See Differences Between Branches

Compare your current branch with main:

git diff main

🔀 Merge a Branch

First, switch to the main branch:

git checkout main

Then merge the feature branch:

git merge feature-branch

🚩 Pull Requests (PR)

Instead of merging directly from your local machine:

Push your feature branch to GitHub.
Create a Pull Request (PR) on GitHub.
Have someone review and approve it.
Merge the branch into main on GitHub.

🔄 Sync with GitHub

After merging on GitHub, your local code may be outdated. To fetch and merge the latest changes:

git pull origin main

⚔️ Merge Conflicts

Conflicts happen when different branches change the same line of code. Git will show it like this:

<<<<<<< HEAD
your code
=======
someone else's code
>>>>>>> feature-branch

You’ll need to manually choose the correct version, fix the file, then commit the change.

🔙 Undoing Changes

Undo a staged file (before committing):

git reset <file>

Unstage all files:

git reset

Undo the last commit (keep changes):

git reset HEAD~1

Reset to a specific commit:

git log  # Find the commit hash
git reset <commit-hash>

Wipe everything and reset (dangerous!)

Including the code in the working tree. The project will look exactly like it did at that commit, as if later changes never happened This is destructive.
⚠️ Once you run it, you cannot recover the deleted commits or changes (unless you've backed them up or they exist in the reflog).

git reset --hard <commit-hash>

✅ Safer alternatives:
If you just want to move the branch without losing code:

git reset --soft <commit-has>

Keeps your changes in the staging area

OR,

git reset --mixed <commit-hash>

Keeps your changes in the working directory, but unstages them

🔁 Git Reset Modes — Comparison Table

Mode	Changes to Commit History	Staging Area Cleared	Working Directory Cleared	What Happens
`--soft`	✅ Yes	❌ No	❌ No	Moves HEAD to the given commit. Keeps all changes staged (ready to commit again).
`--mixed`	✅ Yes	✅ Yes	❌ No	Unstages your changes but keeps them in your working directory. This is the default mode.
`--hard`	✅ Yes	✅ Yes	✅ Yes	Completely deletes all changes after the given commit, including uncommitted work.

💡 Pro Tips

Use meaningful commit messages.
Commit frequently, but in logical chunks.
Always pull before pushing.
Use .gitignore to exclude unnecessary files.
Practice branching, it’s a powerful workflow tool.

🎓 My Final Thoughts to you

Learning Git and GitHub is like learning a new language. It might seem tricky at first, but with practice, you'll manage your projects confidently and collaborate smoothly.

Start small, explore branches, and don't be afraid to experiment. 💻✨

UNIX and Linux

Istiak Islam — Fri, 06 Sep 2024 21:05:42 +0000

Linux is not UNIX, although it is clearly UNIX-like.

Technically, Linux is only the kernel; everything else that makes up the full operating system is drawn from a number of sources. The full content depends on the particular Linux distribution being used.

UNIX and Linux have had very different evolutions. UNIX may have had humble beginnings, but from the very outset it was designed to be a serious enterprise operating system. It grew up largely outside of the Intel family of CPUs, although it was later ported to it. Linux, on the other hand, began as a toy operating system only on the x86 architecture. It is doubtful anyone had any idea of how robust it would become or how many architectures it would wind up supporting.

The first versions of UNIX were developed about 1969, by Ken Thompson, Rudd Canaday, and Dennis Ritchie. By the time Linux first appeared in 1991, UNIX had already become quite fractured. There were many varieties, grouped in two major families: System V arising from the original code at Bell Labs, and BSD arising from the University of California at Berkeley.

Sorting out the fractious history and differences among the different UNIXs would be a lengthy task (as well as an unnecessary one for our present purpose). But, by 1991, there were many variants, often tied to a specific hardware platform and vendor. For instance, SGI had IRIX, Sun had SunOS and Solaris, IBM had AIX, Hewlett Packard had HPUX, Cray had UNICOS, DEC had Ultrix. Each one of these manufactures often had several varieties running even on its own universe of hardware. SCO was one of the only variants not arising from a hardware company.

While there were various efforts to achieve some standardization, most vendors had strong self-interest in keeping things proprietary. At a minimum, there were always two major flavors to be considered, System V and BSD, and their behavior could be quite different even on quite basic matters such as signal handling. Thus, application developers interested in portability had to resort to the use of ugly #ifdef statements.

Even where the APIs were not that different, the actual implementation could be radically different from platform to platform. Basic kernel architectures also differed. Furthermore, each platform had its own set of basic file utilities, shells, etc.

The Free Software Foundation's (FSF's) GNU (GNU's not UNIX) project developed freely-distributable versions of many basic utilities, such as tar, ls, grep, etc., and even more important, the gcc compiler and the basic C-library, libc.

Linux could not have been born or grown without the availability of tools from the GNU project. There is no way to overemphasize this. We will stay out of the arguments about whether Linux should properly be called GNU/Linux or something similar, but just note that what is often loosely called Linux in fact contains many GNU components; properly speaking, Linux is only the kernel.

While UNIX and Linux are not the same thing, Linux has always borrowed heavily from UNIX. Most basic components of Linux, such as an inode-based filesystem, accessing hardware through device nodes, multi-process scheduling, process creation and destruction, are completely rooted in UNIX.

This is because the developers of Linux have always had a good footing in the UNIX world, and because of the availability of the UNIX tools from GNU and other non-GNU open-source projects.

Whenever possible, Linux has tried to accommodate both major variants of UNIX as far as the API is concerned; striving for POSIX type behavior is above that level. As such, it has never been very difficult to port UNIX applications to Linux, unless the application has relied very heavily on certain idiosyncrasies of a particular UNIX implementation.

The open nature of the Linux development model has thus far avoided the serious fracturing that took place in UNIX. It is perhaps ironic that the easily legal possibility of having Linux fork into competing versions at any time is perhaps what has prevented it.

Many hardware vendors now seriously support Linux on their hardware and the long range future of their own versions of UNIX is often in doubt. It could well be that the Linux plan for world domination is inevitable; at least as far as killing off other UNIX-like operating systems.

Kernel vs Operating System

Istiak Islam — Fri, 06 Sep 2024 20:03:34 +0000

The kernel is the central component that connects the hardware to the software, and manages the system's resources, such as memory, CPU, and time sharing among competing applications and services. It handles all the devices that are connected to the computer by including so-called device drivers and makes them available for the operating system to use.
A system running only a kernel has limited functionality, and the only place you will see that is in a dedicated device (often termed as an embedded device) such as inside an appliance.

An Operating System includes the kernel and some additional components like User interface, File system, Utilities Tools and Security. It is a software that manages computer hardware and software resources and provides common services.

To distinguish, the Kernel is the part of the Operating System and the Operating System itself include many more components. In addition, users interact with the Operating System, but Kernel operates in the backstage.

OSS Licensing and Legal Issues

Istiak Islam — Sun, 07 Jul 2024 02:29:53 +0000

There are many ways to work with Open Source Software. In particular, what kind of license is adopted will have strong effects on:

How the project is developed
How the project is deployed

There are two broad classes of licenses:

Restrictive, such as the GPL in all of its forms
Permissive, such as the BSD and Apache Foundation Licenses

There is a lot of misinformation spread about Open Source Software and licenses, which can make organizations reluctant to use and develop for it. We will discuss the main kinds of this false information.

Restrictive vs Permissive Licensing

Restrictive Licenses

Demand the software remains open and place strong limitations on any attempt to make proprietary closed products. Changes to the code must be made available to future recipients. A prominent example is the GPL (General Public License), a copyleft license.

Permissive Licenses

Do not require modifications and enhancements to be generally available. Prominent examples include the BSD (Berkeley Software Distribution) and Apache licenses.

Fear, Uncertainty and Doubt

The term FUD is shorthand for F ear, U ncertainty and D oubt (or Elmer Fudd). Surprisingly, first usage goes back as far as the 1920s; use of the acronymic form seems to date from the 1970s.

Broadly speaking, it means disseminating misinformation to influence recipients to avoid certain strategies, products or classes of products by appealing to fear.

Microsoft was widely accused of spreading FUD about Linux in the 1990s. However, in present day, Microsoft has stopped doing so and is actually employing OSS widely.

As applied to OSS, FUD statements include:

OSS is a virus. If you include it in your product, all your source must be made available to everyone. This is simply not true. One does have to be careful about respecting licenses, but many prominent companies have learned how to combine open and closed software in their offerings. And, there are companies and organizations dedicated to helping ensure this is done properly.
OSS infringes on software patents, and the related claim that it forces you to grant patent rights to others. This is simply not true. Once again, proper legal analysis is required.
OSS products leave nowhere to turn when they break, or to get technical help. Many open source products are supported by serious, long-living companies (such as Red Hat Enterprise Linux), as well as smaller organizations. In addition, there is a lot of freely available help online, and there are many consultants that can be hired. In fact, there is more competition available for such help than there would be with vendor lock-in on a product.
OSS requires a lot of legal help to avoid the above pitfalls, and is thus very expensive. Even proprietary software requires significant legal analysis to properly avoid copyright and patent infringement, etc. OSS is no different and not more expensive. Also, having all the software being available in source form expedites the auditing process. Companies will indeed require interaction with lawyers, either on staff or external, to make sure they do not violate copyrights and licenses. There are many kinds of licenses and one has to be careful. But once an organization develops proper reasonable procedures, it is just a standard part of any project. Part of this is to train the developers to understand the dos and don'ts of working with OSS.

Software Patents

A software patent gives exclusionary rights to material such as a computer program, library, interfaces or even techniques and algorithms. The earliest software patents appear to have been granted in the early 1960s.

Like all patents, software patents must be filed in for each nation (or trading block such as the European Union) in which coverage is desired. This makes it an expensive and time-consuming project to do thoroughly.

Exactly what a patent can or cannot cover varies from jurisdiction to jurisdiction; e.g., in the United States this means exclusion of "abstract ideas", although what is or is not covered can always be fought about.

Many people feel there should be no software patents at all, that sufficient protections for intellectual property already exist under copyright and trademark laws. However, since it is highly unlikely software patents will be abolished, developers and organizations have to learn to deal with them properly.

More often than not, software patents have been used defensively, with corporations cross-licensing each other’s work to avoid litigation. However, there are many well-known cases of expensive legal battles as well.

The Open Invention Network (OIN) was created as a global patent pool; companies and other entities which join the OIN enter in a mutual non-aggression agreement within the Linux-based ecosystem. OIN members agree in return for not suing each other over patent issues, they gain access to each other’s patent portfolio free of charge.

While the OIN has existed since 2005 it has been growing rapidly, to over 3000 members in 2019. Major members include: Google, IBM, NEC, Philips, RedHat, Sony, SUSE, Toyota, and Microsoft. For details about OIN’s mission, how it works and how to join, see its website.

Microsoft Sells Out

Microsoft’s joining of OIN in October 2018 was a major event, opening up over 60,000 patents for use by OIN members and, not surprisingly, leading to a spike in new memberships. For many this represented proof of Microsoft’s determination to be a good citizen in the OSS world (of course for others, it fed conspiracy theories...)

......

What is Open Source Software (OSS)?

Istiak Islam — Thu, 06 Jun 2024 20:00:31 +0000

What is open source software?

Open source software (OSS) refers to software that is distributed with its source code made available to the public. This allows anyone to view, modify, and distribute the software.
Sharing of software has gone on since the beginnings of the computer age. In fact, not sharing software was the exception, and not the rule. The concepts of open source software (OSS) long predate the use of the term.

This software are open for all. For instance it is Free. In English the word FREE has two meanings:

Free as in free speech, freedom to distribute
Free as in no cost, or as is often said, like "Free beer"

Use of OSS means source code is made available with a license which provides rights to examine, modify and redistribute, without restriction on the user's identity or purpose.

Why use open source software?

The purpose of OSS is Collaborative Development. enables software projects to build better software. When progress is shared, not everyone has to solve the same problems and make the same mistakes. Thus, progress can be made much faster and costs can be reduced.
Having more eyeballs viewing code and more groups testing it leads to stronger and more secure code, as well. It is often hard for competitors to get used to the idea of sharing, and grasping that the benefits can be greater than the costs. But experience has proved this to be true over and over again.
Competitors can compete on user-facing interfaces (e.g. internal plumbing that everyone needs) so that end users still see plenty of product differentiation and have varying experiences.

Successful OSS Projects:

Linux Kernel: It is the basis of almost all of the world’s computing infrastructure, from the most powerful supercomputers to the largest number of mobile devices, based on Android, built on a Linux kernel.
Git: Git is a distributed version control system that is used worldwide for an astounding number of collaborative products. It is also the basis of GitHub, which hosts more than one hundred million of open source projects repositories; GitLab, another easily available host, handles quite a few projects as well.
Apache: Work on the Apache HTTP Server began in 1995. Today it is the most widely used web server with roughly one third of the market share (another open source project, nginx, has almost as many users).
Programming Languages: Many computing languages are developed using open source methods. Examples of these languages include: Python, Perl, Ruby, Rust etc
GNU: The GNU Project has provided many essential ingredients for virtually all modern computer technologies, under various versions of the GPL (General Public License). Some of the most prominent products emanating from the GNU are GCC, GBD, GLIBC, BASH, COREUTILS.