DEV Community: Farzaneh

The Best Git Commands Every Junior Developer Should Know

Farzaneh — Sun, 27 Jul 2025 05:40:39 +0000

Introduction

Git is not just a tool — it’s the lifeline of modern software development. Yet, many junior developers underestimate its power. If you don’t master Git early, you’ll soon find yourself drowning in broken branches, lost commits, and unsolvable merge conflicts. This guide covers the absolute must-know Git commands that every junior developer should engrain into their muscle memory.

1. git init

What it does: Initializes a new Git repository.

If you’re starting a new project, run:

git init

Without this, Git won’t track your project. Forget this step, and you’re just coding in the void.

2. git clone

What it does: Clones a repository from a remote source.

git clone <repository-url>

When you join a team or contribute to an open-source project, this is how you grab the code.

3. git status

What it does: Shows the current state of your working directory.

git status

Before making any changes, always check git status. It prevents you from pushing unfinished code or committing the wrong files.

4. git add

What it does: Stages changes for the next commit.

git add <filename>

Or add all changes:

git add .

Skipping this step means your changes won’t be included in your next commit. Rookie mistake.

5. git commit -m “your message”

What it does: Saves changes with a descriptive message.

git commit -m “Added user authentication module”

Always write clear and concise commit messages — future you will thank you.

Here is my article about how to write commits and document git projects:

Practices for Maintainable and Future-Proof Projects

6. git push

What it does: Sends your committed changes to the remote repository.

git push origin <branch-name>

If you don’t push, your teammates won’t see your work. Forgetting this could lead to merge hell.

7. git pull

What it does: Fetches and integrates changes from the remote repository.

git pull origin <branch-name>

Skipping this before pushing can cause conflicts that will ruin your day.

8. git branch

What it does: Lists or creates branches.

git branch

Create a new branch:

git branch <new-branch-name>

Always work in branches! Never push directly to main unless you enjoy total chaos.

9. git checkout

What it does: Switches between branches.

git checkout <branch-name>

Switching branches without committing changes? Say goodbye to your work.

10. git merge

What it does: Merges one branch into another.

git merge <branch-name>

ALWAYS resolve conflicts properly — otherwise, your team will hate you.

11. git reset

What it does: Undoes changes.

git reset — hard HEAD~1

This command is powerful — and dangerous. Use it wisely, or you might lose hours of work in an instant.

12. git log

What it does: Shows commit history.

git log — oneline

Need to find out who broke the code? Start here.

13. git stash

What it does: Temporarily saves changes without committing them.

git stash

For when you need to switch branches but don’t want to commit half-baked code.

14. git rebase

What it does: Moves or combines commits.

git rebase main

Rebasing keeps your commit history clean — but misuse it, and you’ll corrupt your repository.

15. git revert

What it does: Undoes a commit safely.

git revert <commit-hash>

Unlike git reset, this keeps history intact, making it a safer option for rolling back changes.

Conclusion

Ignoring Git is not an option if you want to survive as a developer. Master these commands, and you’ll avoid embarrassing mistakes, save time, and gain the respect of your peers. Git is unforgiving — either you control it, or it controls you.

Which of these commands has saved you from disaster? Let me know in the comments!

Effective Code Documentation: Strategies for Future-Proof Projects

Farzaneh — Wed, 03 Jan 2024 08:02:45 +0000

In the ever-evolving landscape of software development, creating code that stands the test of time is crucial. One key aspect contributing to the longevity and maintainability of a project is effective code documentation. In this blog post, we'll explore strategies for crafting documentation that not only serves the immediate development team but also ensures future-proof projects.

Why Documentation Matters

Before diving into strategies, let's understand why documentation is essential. Well-documented code:

Facilitates Onboarding: New team members can quickly grasp the project's architecture, reducing the learning curve.
Aids Maintenance: As projects evolve, maintenance becomes inevitable. Clear documentation streamlines the process of identifying and fixing issues.
Encourages Collaboration: Collaborative projects require effective communication. Documentation serves as a shared resource that promotes collaboration among team members.
Enhances Code Reusability: Well-documented code becomes a valuable resource for future projects. It can be reused or adapted, saving time and effort.

Strategies for Effective Code Documentation

1. Inline Comments and Descriptive Variable Names

Use inline comments sparingly and focus on explaining complex or non-intuitive sections of code. Additionally, choose descriptive variable and function names to convey intent without the need for excessive comments.

// Bad example
const x = 10; // Set x to 10

// Good example
const initialSpeed = 10; // Initial speed of the vehicle

2. Function and API Documentation

Document every function's purpose, parameters, return values, and potential side effects. For APIs, provide usage examples and highlight any authentication or authorization requirements.

/**
 * Calculates the area of a rectangle.
 * @param {number} length - The length of the rectangle.
 * @param {number} width - The width of the rectangle.
 * @returns {number} - The calculated area.
 */
function calculateRectangleArea(length, width) {
  return length * width;
}

3. Project README and Architecture Overview

Maintain a comprehensive README file that serves as the project's main documentation hub. Include an overview of the project's architecture, directory structure, and any essential setup instructions.

## Project Overview

This project utilizes a microservices architecture, with the following main components:

- `frontend/`: Contains the React-based user interface.
- `backend/`: Manages server-side logic using Node.js and Express.
- ...

4. Change Log and Version History

Keep a detailed change log to track modifications, additions, and removals in each version of your project. This helps developers understand the evolution of the codebase and the rationale behind changes.

## Change Log

### [1.2.0] - 2024-01-15

- Added user authentication feature.
- Fixed performance issue in data retrieval.
- Updated third-party library dependencies.

5. External Documentation for Dependencies

When your project relies on external libraries or APIs, provide links to relevant documentation. This ensures that developers have easy access to additional resources when needed.

// External library documentation: https://example-library.com/docs
import exampleLibrary from 'example-library';

6. UML Diagrams and Flowcharts

For complex systems, use UML diagrams or flowcharts to illustrate relationships between components, data flow, and system behavior. Visual representations can significantly enhance understanding.

Conclusion

In conclusion, effective code documentation is not just a task to check off; it's an ongoing commitment to the success of a project. By implementing these strategies, you pave the way for future developers to seamlessly navigate, understand, and contribute to your codebase. Remember, documentation is not just for today – it's an investment in the future of your project and the developers who will carry it forward.