Programación Para Tontos


If you've ever accidentally pushed an entire `node_modules` folder (with its 40,000 tiny files) to GitHub, this one's for you. If not, even better, this tutorial saves you that public embarrassment.

## Step 1: create the file

At the root of your project, create a file named exactly `.gitignore` (with the leading dot, no extension).

```bash
touch .gitignore
```

## Step 2: tell it what to ignore

```
# Dependencies
node_modules/

# Environment files with sensitive data
.env

# OS-generated files
.DS_Store

# Build folders
dist/
.next/
```

Each line is a pattern: `node_modules/` ignores that entire folder, `.env` ignores that specific file. Git will pretend those files don't exist for the purposes of `git add` and `git status`.

## Step 3: what if you already uploaded those files?

`.gitignore` only works on files Git isn't already tracking. If you accidentally uploaded them before, you need to untrack them (without deleting them from your computer):

```bash
git rm -r --cached node_modules
git commit -m "Stop tracking node_modules"
```

`--cached` is the key word here: it removes the file from Git's repository, but leaves it untouched on your hard drive. Nobody loses anything, except your repo's dead weight.

## Step 4: verify it's working

```bash
git status
```

If `node_modules` no longer shows up in the list of new or modified files, your `.gitignore` is doing its job correctly.

## What did you just learn?

- What the `.gitignore` file is for and how to create it.
- What kinds of files you should always ignore (dependencies, environment files, builds).
- How to untrack files you already pushed by mistake with `git rm --cached`.


Set up a .gitignore file to keep node_modules and sensitive files out of your repository.

Tutorial: create a .gitignore to stop uploading junk files


A merge conflict happens when Git doesn't know which of two changes to keep, because both touched the same line. It sounds terrifying the first time. It isn't. Let's cause one on purpose to lose the fear of it.

## Step 1: set up the conflict scenario

```bash
echo "Original version" > file.txt
git add file.txt
git commit -m "Original version"

git checkout -b branch-a
echo "Change from branch A" > file.txt
git commit -am "Change on branch A"

git checkout main
echo "Change from main" > file.txt
git commit -am "Change on main"
```

Now you have two different versions of the same line, on two different branches. Time to merge them.

## Step 2: attempt the merge

```bash
git merge branch-a
```

Git will show something like `CONFLICT (content): Merge conflict in file.txt`. It's not a fatal error, it's Git telling you "I need you to decide".

## Step 3: open the file and decide

```
<<<<<<< HEAD
Change from main
=======
Change from branch A
>>>>>>> branch-a
```

Everything between `<<<<<<< HEAD` and `=======` is your current version. Everything between `=======` and `>>>>>>> branch-a` is the version you were trying to merge in. Edit the file by hand, keep whichever content you want, and delete those marker lines (`<<<<<<<`, `=======`, `>>>>>>>`).

## Step 4: mark the conflict as resolved

```bash
git add file.txt
git commit -m "Resolve conflict between main and branch-a"
```

Running `git add` on the edited file tells Git "I've decided, this is the final content". The commit closes out the merge.

## What did you just learn?

- Why a merge conflict happens (two changes on the same line).
- How to read the `<<<<<<<`, `=======`, and `>>>>>>>` markers.
- That resolving a conflict is just editing the file and committing again, nothing magical or scary.


Learn to read and resolve a Git merge conflict without panicking.

Tutorial: resolve your first Git conflict


So far Git has only saved your history on your own computer. Today you'll back it up to the cloud (GitHub) so you don't lose it if your laptop decides to die at the worst possible moment.

## Step 1: create an account and a repository on GitHub

Go to [github.com](https://github.com/), create an account if you don't have one, and click "New repository". Give it a name (for example, `my-project`) and do NOT check the option to add a README (you already have one locally).

## Step 2: connect your local repository to GitHub

```bash
git remote add origin https://github.com/your-username/my-project.git
```

`origin` is just a nickname (the most common one) for your repository's remote address. You could call it something else, but nobody does, so neither should you.

## Step 3: push your commits

```bash
git branch -M main
git push -u origin main
```

`-u` (for "upstream") tells Git "remember this connection", so next time you just need to type `git push` on its own. The first time, GitHub will probably ask you to sign in.

## Step 4: verify it worked

Reload your repository's page on GitHub. If you see your files there, congratulations: your code no longer depends solely on your computer surviving.

## Step 5: the everyday workflow

```bash
git add .
git commit -m "Describe what you changed"
git push
```

This is the cycle you'll repeat constantly: save changes locally (`add` + `commit`) and then push them (`push`). As simple as it sounds, as important as it seems.

## What did you just learn?

- How to create a remote repository on GitHub.
- How to connect your local project with `git remote add`.
- The everyday workflow of `add`, `commit`, and `push`.


Create a GitHub repository and push your local project with git remote and git push.

Tutorial: push your first project to GitHub


A branch is a parallel copy of your project where you can experiment without fear of breaking the "real" version. It's like saving your game before trying something risky.

## Step 1: check which branch you're on

```bash
git branch
```

You'll see something like `* main`, where the asterisk marks the active branch. `main` (or sometimes `master`) is usually your project's primary branch.

## Step 2: create a new branch

```bash
git branch new-feature
```

This creates the branch, but doesn't move you to it yet (like creating a backup save without opening it).

## Step 3: switch to the new branch

```bash
git checkout new-feature
```

Or, in one step (create and switch at the same time):

```bash
git checkout -b another-feature
```

`-b` tells Git "create this branch and switch to it right away". Now any commit you make lives only on this branch, without affecting `main` at all.

## Step 4: make changes and go back to `main`

```bash
echo "testing something" >> notes.txt
git add notes.txt
git commit -m "Experiment on a new branch"

git checkout main
```

Back on `main`, you'll notice `notes.txt` doesn't have those changes (because they live on the other branch!). Nothing broke, nothing got mixed up, everything stays intact.

## Step 5: merge the changes when you're ready

```bash
git merge new-feature
```

`merge` brings the changes from the `new-feature` branch into the branch you're currently on. Only do it once you're sure the experiment worked.

## What did you just learn?

- What a branch is and why it lets you experiment without fear.
- How to create and switch branches with `git branch` and `git checkout`.
- How to merge changes back with `git merge`.


Learn to create and switch between Git branches to experiment without risking your main code.

Tutorial: create your first branch without fear


You already know what Git is in theory (check the "Git and GitHub for beginners" article if not). Today you're actually going to install it and make your first commit, no drama.

## Step 1: install Git

- **Windows**: download the installer from [git-scm.com](https://git-scm.com/) and follow the wizard (click "Next" on everything if you're unsure, the defaults are fine).
- **macOS**: open the terminal and run `git --version`. If it's not installed, macOS will offer to install it automatically.
- **Linux**: `sudo apt install git` (Ubuntu/Debian) or your distro's package manager.

## Step 2: introduce yourself to Git

```bash
git config --global user.name "Your Name"
git config --global user.email "you@email.com"
```

Git needs to know who you are to sign your commits. It's not a bureaucratic form, it's a setting you configure once per computer.

## Step 3: initialize a repository

```bash
mkdir my-project
cd my-project
git init
```

`git init` turns that folder into a repository: from now on, Git can track the history of everything that happens inside it.

## Step 4: make your first commit

```bash
echo "# My Project" > README.md
git add README.md
git commit -m "First commit: add README"
```

You just created your first official "checkpoint". If something goes wrong later, you can always come back to this exact moment. It's, literally, an undo button with superpowers and a perfect memory.

## Step 5: check the history

```bash
git log
```

You'll see your commit, with your name, your email, the date, and the message you wrote. Every future commit will stack up here, telling your project's complete story.

## What did you just learn?

- How to install Git and configure your identity.
- How to initialize a repository with `git init`.
- How to make your first commit with `git add` and `git commit`.


Install Git on your computer and save the first 'checkpoint' of your project.

Tutorial: install Git and make your first commit


**Git** is a tool that saves the history of changes to your code, like a giant "Ctrl+Z" with superpowers. **GitHub** is a website where you can store that history in the cloud and share it with others.

## The three commands you'll use most

```bash
git add .
git commit -m "Explain what you changed"
git push
```

1. `git add .` — marks the files you changed to be saved.
2. `git commit -m "..."` — saves a "snapshot" of those changes with a message.
3. `git push` — uploads that snapshot to GitHub so it's backed up.

## Why should I use Git from the start?

- You can undo mistakes without fear.
- You can see exactly what changed and when.
- It's the standard way programming teams work.

## Your first repository

1. Create a folder for your project.
2. Run `git init` inside it.
3. Create a GitHub account and a new repository.
4. Follow GitHub's instructions to connect your local folder to the remote repository.

You don't need to understand everything at once. With these three commands you can already start versioning your projects.


Learn what Git is, what GitHub is, and the three commands you'll use 90% of the time.

Git

Tutorial: create a .gitignore to stop uploading junk files

Tutorial: resolve your first Git conflict

Tutorial: push your first project to GitHub

Tutorial: create your first branch without fear

Tutorial: install Git and make your first commit

Git and GitHub for beginners: a drama-free guide