• Pixabay: Offers a wide range of free images that you can use without attribution.

• Pexels: Provides thousands of free stock photos that you can download and use, adding new images daily.

• Unsplash: A community of photographers sharing their work for free, known for the exceptional quality of images.

• Content Powered Blog: Lists multiple sources for free stock photos, including Negative Space and Gratisography.

Remember to check the licensing on each image, as some may require attribution or have restrictions on commercial use.

AI-generated images

You can create AI-generated images for free using various online platforms. Here are some options:

• Craiyon: Offers a free AI image generator that can create art from text prompts.

• Perchance: A realistic AI photo generator that’s free to use, with no sign-up or limits.

• ImgGen: Provides fast, high-quality visuals with a text-to-image generator that’s completely free.

• Canva: Features AI photo generator apps that produce images from text prompts.

• Lummi: A source for free AI-generated stock photos and royalty-free images⁵.

These services typically use advanced AI models to turn text descriptions into visual art, and they’re a great resource for bloggers and content creators looking for unique images. Remember to review the terms of use for each platform, as they may have specific rules regarding the commercial use of generated images.

Online image editors

The images you get from the previous links may not be the size you need for your site or blog. In those cases, you can access the following options:

• Online Image Editor (OIE): The easiest method to edit an image in a clean and fast manner

• Pixlr Express: A free modern AI-powered photo editor by Pixlr.

Configuration

Initial configuration

git config --global user.name "username"
git config --global user.email "user@domain.com"

Enlist all configurations

git config --list

Edit configuration in a text editor

git config --global --edit

Configuration list example

[core]
    editor = \\"C:\\\\Users\\\\eric\\\\AppData\\\\Local\\\\Programs\\\\Microsoft VS Code\\\\Code.exe\\" --wait
[user]
    email = eric@milaneze.com.br
    name = Eric Milaneze
[difftool "sourcetree"]
    cmd = '' \\"$LOCAL\\" \\"$REMOTE\\"
[mergetool "sourcetree"]
    cmd = "'' "
    trustExitCode = true

Store the remote repository password

git config --global credential.helper store

In this case, the password will be saved for future use when requested. For further information, please see this ShellHacks' post:

Basic commands

Init & status

# create a repository on the current directory
git init

# create a git repository to be used as remote 002 - Git Commands
git init --bare

# shows files added or modified in the stage and working directory
git status

Commit

# add all files to the staging area
git add .

git add a.txt

git add *.txt

# remove the file from the stage
git reset HEAD {{file-path}}

# goes back to a previous commit
# CAUTION, there is no going back
# actually, you can go back by getting your previous hash using reflog
git reset --hard {{commit-hash}}

git commit -m "initial commit"

# adds files in Stage to the last commit
git commit --amend -m "initial commit (editing)"

# create a new commit unlike {{commit-hash}} to reverse it
git revert {{commit-hash}}

Logs

# view the commit log
git log

# shows all commits in a row (also shows the single code of the commit in smaller size)
git log --oneline

# same as the previous one, but shows the other branchs and chart
git log --oneline --decorate --all --graph

# shows all commits in a row (also shows the hash of the commit)
git log --pretty=oneline

# works just like git log + git diff
git log -p

# shows the last two logs (last two commits)
git log -p -2 

# search for "function_name"
git log -S {{function-name}}

Branch

# shows the existing branches locally
git branch

# creates a new branch
git branch {{branch-name}}

# deletes a local branch
git branch -d nomeDaBranch

# checkout to a specific hash
git checkout {{hash}}

git checkout {{branch-name}}
git switch {{branch-name}}

# checkout to a tag
git checkout tagName

# create a branch and checkout to it
git checkout -b {{name-of-the-branch}}
git switch -c {{name-of-the-branch}}

# gives the option to analyze the differences between the two files
# and decide what to keep or not
git checkout -p source_branch -- <paths>

# open change report viewer (graphical interface)
gitk

# example:
# git remote origin https://github.com/ericmilaneze/karaoke
git remote nome url

# sends changes to the remote repository
git push origin master

# -force => ignores if any pull should be done before pushing
git push origin master --force

# takes changes in the remote without merging with local code
git fetch

# download changes to remote and apply to master branch
# (git fetch is more recommended)
git pull origin master

Tags

# creates a tag for the last commit
git tag -a v1.0 -m "Version 1.0"

# creates a tag for code commit
git tag -a v0.0 f15cf833e9a6040dfdffe1b488c9cfafe09248e2 -m "Version 0.0"

# shows details of the tag
git show v1.0

# deletes a tag
git tag -d v1.0

Files

# informs Stage of deleted files
git rm {{file-path}}

# to take from Stage
git rm --cached {{file-path}}

# check if file is tracked by git
git ls-files "{{file-path}}"

Stash

# creates a place to hide the files that are in Stage and take them from there.
git stash save "{{stash-name}}"

# lists the saved stashes
git stash list

# applies a saved stash
git stash apply stash@{0}

# erases a target stash
git stash drop stash@{0}

# apply + drop in the stack of saved stashes
git stash pop

# should be used after the save and is equal to the pop (apply + drop), but applied inside a new branch.
git stash branch {{branch-name}}

# restore file from stash
git restore -s stash@{0} -- {{filename}}

# gets a specific file from stash
git checkout stash@{0} -- {{filename}}

# check the differences in a specific file
git difftool stash@{0}..HEAD -- {{filename}}

# shows the content of an entire file (not just the changes)
git show stash@{0}:{{full-filename}}

# creates a new file base on the file from stash (could be from another branch as well)
git show stash@{0}:{{full-filename}} > {{newfile}}

Ways to delete changes

# Removes Unstaged Tracked files ONLY [Type 2]
git checkout . 

# Removes Unstaged UnTracked files ONLY [Type 3]
git clean -f -d
git clean -fd

# Removes Staged Tracked and UnStaged Tracked files ONLY [Type 1, Type 2]
git reset --hard 

# Removes all changes [Type 1, Type 2, Type 3]
git stash -u

Merge

git merge {{branchB}}

git merge -s ours {{branchB}}

git merge -X theirs {{branchB}}

# merge, but does not create any commit
# the files where the merge was done without conflicts are in Stage
# the others are waiting for the resolution of conflicts
git merge {{branchB}} --squash

# cancel merge when there are conflicts
git merge --abort

git mergetool

Rebase

# make the interactive rebase of the last two commits
git rebase -i HEAD~2

# take changes from another branch (interactive mode)
git rebase -i {{other-branch-name}}

# use this command after resolving conflicts
git rebase --continue

# ignores a commit
git rebase --skip

# aborts a rebase in progress
docker rebase --abort

Reset

# mixed - does not place changes from upcoming commits in Stage
git reset <hash>

# places changes to upcoming commits in Stage
git reset --soft <hash>

# has no return (except through "git reflog")
git reset --hard <hash>

Not-so-basic commands

Difference between commits/branches/files

# shows files that are different between the Working directory and the staging area
git diff

# shows what is on the staging area and will be comited
git diff --staged

git diff <COMMIT_HASH> -- {{file-path}}
git diff <BRANCH_NAME> -- {{file-path}}
git diff <COMMIT_HASH_1> <COMMIT_HASH_2> {{file-path}}
git diff stash@{0}^1 stash@{0} -- <filename>

# shows (with Meld/VS Code) the differences between what has current and the specified commit
git difftool -d 35c37fa607

# shows (with Meld/VS Code) the differences between what you have current and the specified branch
git difftool -d branch

# shows with Meld/VS Code the differences between what you currently have and what is in the staging area
git difftool -d --staged

git difftool <COMMIT_HASH> {{file-path}}
git difftool <BRANCH_NAME> {{file-path}}
git difftool <COMMIT_HASH_1> <COMMIT_HASH_2> {{file-path}}

Logs

# get all the changes/commits (even after a hard reset => reset --hard)
git reflog

Cherry-pick

# adds the commit to the top of the current branch
git cherry-pick {{commit-hash}}

# copy all the commits, including the first
git cherry-pick {{commit-hash}}^..{{other-commit-hash}}

# copy all the commits, ignoring the first
git cherry-pick {{commit-hash}}..{{other-commit-hash}}

The Plan

Firstly, I consulted ChatGPT to identify topics to study following the Pareto principle. You can click here to see ChatGPT's response, which provided me with direction for my next steps.

Udemy Courses

My initial approach involves warming up by tackling exercises in the course HTML e CSS: O Início (incluindo 5 Projetos) (HTML and CSS: The beginning (including 5 Projects)). This foundational course humbly sets the stage for progress. As I aim to share my journey, I'll post the results of these exercises on a GitHub repository.

Next, I'll delve into HTML5 e CSS3: Técnicas Avançadas (Com Flexbox e 5 Projetos) (HTML5 and CSS3: Advanced Techniques (with Flexbox and 5 Projects)), which acts as a continuation of the first course. Despite its advanced title, it provides fundamental insights worth exploring. You can follow my progress on this journey through the corresponding GitHub repository.

While another course, Curso Web Moderno Completo com JavaScript + Projetos (Complete Modern Web Course with JavaScript + Projects)), offers comprehensive learning, I'll primarily focus on the CSS section. Although it may seem redundant after the first two courses, it introduces additional challenges. I'll share the corresponding code on the GitHub repository.

Furthermore, there are additional topics to cover, such as Tailwind, Bootstrap, CSS variables, and more, as suggested by ChatGPT.

Continuous Learning

Practice is key to mastery. I intend to continue seeking challenges from ChatGPT to enhance my skills and work on projects listed in this YouTube playlist:

Similar to the approach with courses, I'll utilize a GitHub repository to store the code I develop to address the challenges presented in this playlist.

Wrap Up

To summarize, the plan entails:

• Engaging with Udemy courses while documenting progress on corresponding GitHub repositories.

• Seeking additional challenges from ChatGPT to broaden my learning.

• Continuing to learn and tackle CSS challenges from the YouTube playlist.

Wish me luck on this journey!

I've been programming since I was 15 (using JavaScript since 2001), but I only managed to get my first job as a software developer in 2009. I had to work in a different field to pay for college, but I often built websites as a freelancer. Since 2009, I've used several programming languages and frameworks, but my main ones are .NET (C#) and JavaScript (Vanilla, jQuery, Angular, and React). Of course, I learned some others during this period, but these are the main ones.

"Why start another blog when there's a sea of them out there?" you might wonder. Well, this isn't my first rodeo. I was blogging in 2012 – it feels like a lifetime ago – just sharing what I was learning. Still learning, still keen to share. Sometimes, my brain feels like a ticking time bomb, so I dump my thoughts here. It beats talking to myself, I suppose.

Here's what I plan to share on this blog:

• A peek into a programmer's daily struggles and how to overcome them

• A glimpse into the life of a leader and the daily challenges they face

• My journey with learning new programming languages, frameworks, etc.

• Deep dives into tech topics like data structures, algorithms, cloud computing, Linux, and more

So, join me on this journey. If my musings can quiet the imposter syndrome and help someone out there, then it's a win-win, that's a bonus.

Here's the "original" cover of this post created by IMGGEN.AI (on the cover, it was cropped using OIE):