Forem: ryan

Git, Beginner to Master!

ryan — Wed, 26 Nov 2025 07:01:43 +0000

Videos for this topic can be viewed on my Youtube channel

Everything here is available on Github i'd love a star ;)

Git Command Reference Guide

Terminology used:

origin: the default name git gives to the remote repository you cloned from (origin = https://github.com/...)
tracked: when git add is used
staged: when git commit is used
linear: meaning commits follow a linear pattern like A -- B -- C -- D
non-linear: meaning commits don't follow a linear order

A -- B -- C
      \ 
       D -- E
            \
             M   (merge commit)

How to write good commits:

When applied, this commit with ___.

Try and explain everything you do in this format, if its clear and makes the commit!

1. Repository Initialization

1.1 Initialize Repository

Command: git init

Parameters:

--initial-branch: sets the initial branch in a newly created repository

Description:

Creates an empty git repository - basically a .git directory with sub-directories.

2. Basic Operations

2.1 Check Status

Command: git status

Parameters: NONE

Description:

Shows the difference between the staged area and working directory (the HEAD commit and the index file)

Use Case:

See modified, staged, and untracked files.
Whats staged but not committed?

2.2 View Changes

Command: git diff

Parameters:

--staged is staged changes that have not yet been committed.
-w ignore the white spacce

Description:

Compared the changes made in your working directory to the staged directory.

Use Case:

Whats changed but not staged?

Command: git show

Parameters:

HASH ID

Description:

Show changes made in a commit

3. Staging and Committing

3.1 Tracking Files

Command: git add <file>

Parameters:

-p / --patch hunks specific code to add them to the index. Gives you a chance to review the difference before adding modified contents to the index.

Description:

Adds files to be tracked.

3.2 Commit Changes

Command: git commit

Parameters:

NONE an interactive environment, allows for setting long-descriptions by using an empty space
-m "<message>" adds a message describing the commit
-a "<message>" does a git add . and provides an interactive environment.
-am "<message>" just like above but also does a git add .
-p exactly like git add -p just remember not to do a git add before
--amend allows you to edit commit message, and adds the most recent changes to your latest commit

Description:

Commits staged files and records a snapshot of the project.

A git commit should only be selective and include relevant changes

Use Case:

Saving a stable point, to revert back to in the future.

3.3 View Commit History

Command: git log

Parameters:

--oneline exactly what the name says (keeps simplicity by including commit hash and message)
--graph graphs logs in a horizontal format
--oneline --graph a simplified graph
-p logs actual changes in a file
--no-merges removes the merge commits
--decorate decorates with merge commits, branches, tags
--parents shows parents of each commit

for (commit/s) filters:

--grep for message
--after and --before for dates
--author by the author
-- for a specific file

to compare:
git log feature/login..main all commits that are in main but not in feature/login

Description:

Shows a timeline of project changes and commits.

4. Branching

4.1 Manage Branches

Command: git branch

Parameters:

NONE creates a new branch
-a shows all the branches
-m renames a branch
branch/subbranch adds sub-branches

Description:

Managing branches in a repository

Long-running branches are branches that have been in the complete life-cycle. You mirror this structure (used for releasing code)

Short-lived branches for new features, bug fix and refactoring

4.2 Switch Branches

Command: git checkout

Parameters:

<hash | commit id> checkout to a specific hash
<branch> checkout a branch
<tags> checkout to a tag
-b creates a branch and switches automatically

Description:

Switch to a commit, branch, or tag.

5. Remote Repositories

5.1 Add Remote

Command: git remote add

Parameters:

<origin-name> <url>

Description:

Links your local repository to a remote one

Use Case:

5.2 Fetch Changes

Command: git fetch

Parameters:

--depth to set how deep its history will go

Description:

Downloads objects and refs from a remote without merging

Use Case:

Check for updates but don't touch my files.

git fetch origin
git log main..origin/main

5.3 Pull Changes

Command: git pull

Parameters:

<origin> <branch> --rebase solve merge conflicts, meaning git will first pull changes, then reapply your unpushed commits on top of the latest version of the remote branch (no need to merge).

Description:

Acts exactly like fetch but also merges (or rebase) the two repositories

5.4 Push Changes

Command: git push

Parameters:

<origin> <branch>
--set-upstream / -u flags a local branch to a remote branch. (acts more as a setting option, set it once and forget about it, it links your branch to the origin/branch) ---tags push all the tags

Description:

Uploads the local repository with the staged changes to the remote

6. Integrating Changes

6.1 Merge Branches

Command: git merge

Parameters:

<branch> specifies the branch to merge from
--no-ff prevents git from making a linear history (no-fast-forward)

Description:

Combines two branches into one

Use Case:

Merge is additive meaning history is preserved.

Fast forwarding:

In the terminology, i mentioned that we have two types of repositories, linear and non-linear. This same concept can be applied to git merge, a linear merge will have all the commits after the commit, otherwise it git will keep the current branch and make a new commit with the branch creating a non-linear history.

This is useful when we have a collection of closely related branches.

6.2 Rebase

Command: git rebase

Parameters:

<branch> specifies the branch to rebase from
-i provides an interactive setup for rebasing

Description:

Reapplies commits on top of another branch.

Use Case:

Clean up local commit history. Rebase is reconstructive meaning history is rewritten.

6.3 Cherry-pick

Command: git cherry-pick

Parameters:

<commit-hash> the hash of the commit you want to cherry pick
<hash1> <hash2> <hash3> / A..B for selecting multiple hashes

Description:

Copies a specific commit from one branch and applies it onto the current branch. Notes that it duplicates commits.

Use Case:

When you've mistakenly committed to the wrong branch you use cherry-pick to revert.

7. Undoing Changes

7.1 Reset

Command: git reset

Parameters:

--hard completely discards commits and changes.
--soft uncommit changes but keep them staged (moves HEAD back to a previous commit).
--mixed uncommit and unstage changes.
<commit> you can also do some cool stuff like HEAD~1 meaning last commit from head

Description:

Resets branch to a specific commit

Use Case:

You committed too early or made a typo in the message.

7.2 Revert

Command: git revert

Parameters:

<commit-hash> the hash of the commit
-n tells git only to look at the changes

Description:

Creates a new commit that undoes changes from a previous one while keeping history intact.

Use Case:

You pushed a commit that breaks stuff, you cant change history so you revert it instead.

8. Temporary Storage

8.1 Stash Changes

Command: git stash

Parameters:

-p stash only some files
list view saved stashes
apply {stash} reaply a stash

Description:
Temporarily saves uncommitted changes.

Use Case:
You've made new changes yet need to prioritize something new, without committing save your code and commit later.

9. Conflict Resolution

9.1 Merge Tool

Command: git mergetool

Parameters: NONE

Description:

Launches a graphical or diff tool to help resolve merge conflicts.

10. Recovery and History

10.1 Reference Log

Command: git reflog

Parameters: NONE

Description:

Acts as gits "undo history", meaning even if you have rebased or reset you can see where your branch used to point

Use Case:

You mistakenly delete a branch, you can use reflog to get the hash and checkout back to it

git checkout def5678
git reset --hard def5678

11. Submodules

11.1 Manage Submodules

Command: git submodule

Parameters:

add <repository> self explanatory
update --remote pull all the latest versions of the submodules

Description:

A git repository inside another git repository.

FYI: when others clone your repo they should also initialize your submodules with submodule init or clone --recurse-submodules

Also submodules track commits and not branches (meaning when you clone a repository it goes to the exact commit at where the submodules was added, yet in web based github it opts to look at the default branch)

Use Case:

When wanting to use other repositories in your current repository you can have it set as a submodule

12. Working Trees

12.1 Manage Worktrees

Command: git worktree

Parameters:

list shows all the worktrees
remove ../ removes a worktree
add ../ -b new-branch adds a worktree

Description:

Allows for having multiple working directories for a single git repository. It allows for multiple workspaces in the same repository.

Use Case:

You want to work on multiple branches without having to switch all the time

13. Configuration

13.1 Configure Git

Command: git config

Parameters:

--global alias.l "log --oneline --graph"

Use Case:
Easily set aliases for commands you use all the time but don't want to type out the whole name

14. Tagging

14.1 Manage Tags

Command: git tag

Parameters:

NONE lists all the tags
v1.0 a pointer to the latest commit
v1.0 <hash> to a commit in the past
-a v1.0 -m "<message>" includes metadata

Description:

A git tag is a pointer to a specific commit in git.

Use Case:

Acts like a sticky note like releases and milestones. They don't move after they're created.

15. Cleaning

15.1 Clean Untracked Files

Command: git clean

Parameters:

-n show only what would be deleted
-f actually delete the files

Description:
Removes untracked files from your currently working directory

Use Case:
Remove artifacts, temp files, and debug outputs.

16. Cloning

16.1 Clone Repository

Command: git clone

Parameters:

--depth: add depth for the history of the repository

Description:
Cloning a repository

17. Bisect

17.1 Bisect Commits

Command: git bisect

Parameters:

start start the bisect
bad <hash> mark the bad comit
good <hash> mark the good commit
reset finish when the bisect is done

Description:
Helps you find a specific commit that introduced a bug in the code using binary search.

Lets do dates properly

ryan — Fri, 02 Aug 2024 20:36:24 +0000

As a beginner one of the most interesting topics you’ll learn are Dates. Even though it might sound a bit boring, it's one of the key things you might know; from your Database, API, GUI, and more learning how to deal with dates properly is a key factor in writing good applications.

Before we start

An important detail you must remember is Java was rushed for the web, thus you have a lot of quirky and somewhat stupid ways to do stuff. The goal of this guide will be to teach you how to use the latest Java APIs to write efficient good code. I’ll aim to teach you how not to code anything hard and rather use standardized ISO for a scalable application.

How to work with Dates

The Date API

As of Java 8 SE with the release of the Date Class defined as:

The class Date represents a specific instant in time, with millisecond precision.

Also further on we had the addition of the Abstract Calender Class (with significant upgrade with JDK 1.1) defined as:

The Calendar class is an abstract class that provides methods for converting between a specific instant in time and a set of calendar fields such as YEAR, MONTH, DAY_OF_MONTH, HOUR, and so on, and for manipulating the calendar fields, such as getting the date of the next week. An instant in time can be represented by a millisecond value that is an offset from the Epoch, January 1, 1970 00:00:00.000 GMT (Gregorian).

As noted by the Oracle docs the reason was the lack of internationalization abilities.

It’s good to note that the same documentation linked above goes into further detail about its timing if it interests you.

The LocalDate API

Also with Java 8 SE came the LocalDate Class which is referred to:

A date without a time-zone in the ISO-8601 calendar system, such as 2007-12-03.
LocalDate is an immutable date-time object that represents a date, often viewed as year-month-day. Other date fields, such as day-of-year, day-of-week and week-of-year, can also be accessed. For example, the value "2nd October 2007" can be stored in a LocalDate.

An important specification to take note of is:

This class does not store or represent a time or time zone. Instead, it is a description of the date, as used for birthdays. It cannot represent an instant on the timeline without additional information such as an offset or time zone.

Difference & Which one to use

Issues with the Date/Time API’s

Further reading the LocalDate class will lead you to “This class is immutable and thread-safe.” This brings us to our first problem.

Both the Date and Calender were not thread-safe. If you're a bit confused as to what it means - Threads are a way to implement concurrency with a computer application this allows for multiple tasks to be running concurrently rather than sequentially (If you have a programming background you can see this as async).

Another issue with the Date/Calender API was its poor design. Later on, it was revamped to be ISO-centric (If you are a bit lost on what this whole ISO thing is; in short ISO stands for “International Organization for Standardization”) And we will see the added benefits of this later on.

And lastly coming back to the lack of internationalization was that developers were required to write their logic for handling different time zones which can result in a lot of faults as miss-matches.

The actual difference

The biggest difference is despite the name Date would store both time and date (as mentioned by the docs with millisecond offset since epoch - we’ll talk about epoch later on). With the newer API, we get access to easier Formatting/Parsing/Manipulation of Dates.

What if I want to store time as well?

Well Java has you covered there as well with their LocalDateTime Class

A date-time without a time-zone in the ISO-8601 calendar system, such as 2007-12-03T10:15:30.
LocalDateTime is an immutable date-time object that represents a date-time, often viewed as year-month-day-hour-minute-second. Other date and time fields, such as day-of-year, day-of-week and week-of-year, can also be accessed. Time is represented by nanosecond precision. For example, the value "2nd October 2007 at 13:45.30.123456789" can be stored in a LocalDateTime.

If you would only want to store time then you can use the LocalTime Class

Quick little recap and use cases

Name	Should Use	Use Case	Example
LocalDate	✅	Interprating Dates	2021-02-28
LocalTime	✅	Interprating Time	19:32:25.457826
LocalDateTime	✅	Interprating Time/Date	2021-02-28T19:32:25.457826.
Date	prefer not	Represents Time	Tue Jul 12 18:35:37 IST 2016

LocalDate

Now that we have a good understanding of its background and what we can do with it, let's explore the methods of the LocalDate class.

ISO 8601

The ISO-8601 calendar system is the modern civil calendar system used today in most of the world. It is equivalent to the proleptic Gregorian calendar system, in which today's rules for leap years are applied for all time. For most applications written today, the ISO-8601 rules are entirely suitable. However, any application that makes use of historical dates, and requires them to be accurate will find the ISO-8601 approach unsuitable.

This is the standard Java will use to properly format our dates.

Temporal

Before we do a deep dive I want to introduce you to the Temporal object which all of the new Date APIs implement (LocalDate, LocalTime, LocalDateTime) it's defined as:

This is the base interface type for date, time, and offset objects that are complete enough to be manipulated using plus and minus. It is implemented by those classes that can provide and manipulate information as fields or queries. See TemporalAccessor for the read-only version of this interface.

Not going into depth into this just wanted you guys to understand what this is if you encounter it.

Methods

The format for this will be in order - The method name, the specified return description, and a quick summary of what it does/or an in-depth dive. If you want to follow along I’m going to use jshell just import java.time.LocalDate and copy the same methods.

`LocalDate.now()`: > the current date using the system clock and default time-zone, not null

As mentioned by the description it will return the current date format based on time zone as example for me it gives 2024-07-10 however the format might change based on your locale time dependent on the ISO 8601 format assigned for your country (ex. it might be 2024.07.10 or 24/7/10 this is a standard that your country would use)

The LocalDate.now() method can take an argument. To use this we will import java.time.ZoneId.

What is ZoneId?

ZoneId Released with Java 8SE defined as:

A ZoneId is used to identify the rules used to convert between an Instant and a LocalDateTime. There are two distinct types of ID:

Fixed offsets - a fully resolved offset from UTC/Greenwich, that uses the same offset for all local date-times

Geographical regions - an area where a specific set of rules for finding the offset from UTC/Greenwich apply

In simple terms, this resolves the internationalization issue we had with the old Date API. After importing java.time.ZoneId we can look at some of the methods it has to offer.

ZoneId.getAvailableZoneIds() Shows us all available zones here are some for example: Europe/Istanbul, America/Eirunepe, Etc/GMT-4, America/Miquelon (Remember each one of these is unique and we have two types of unique ID’s which are listed above).
ZoneId.systemDefault() The method is defined as “If the system default time-zone is changed, then the result of this method will also change.” Which is self-explanatory.
ZoneId.of("") We use this to define a custom set ZoneId from the .getAvailableZoneIds() list. Remember both UTC and Europe/Istanbul used as an example here can be used.
ZoneId.from() Remember the temporal we talked about before? Here we will pass it as an argument. If you're not entirely sure what this does, given a ==TemporalAccessor which represents an arbitrary set of date and time information we’ll get a ZoneId. If you are still a bit clueless you can import java.time.ZoneId and use ZonedDateTime.now() which will give you a precise time/date which then you could parse to a ZoneId. Basically ZoneId.from(ZonedDateTime.now())

There also a Clock argument you can pass, but I don’t see any use for it when you could just use ZoneID but feel free to explore that

Now that we learned that - Let’s get the current date in Paris!

LocalDate.now(ZoneId.of("Europe/Paris")) // 2024-07-10

`LocalDate.of(year, month, day of month)`: > Obtains an instance of `LocalDate` from a year, month, and day.

Remember LocalDate represents a Date. In this case, we can set that date to whatever year,month, and day we want!

`LocalDate.ofYearDay(year, dayOfYear)`: >

In a lot of cases, you might only have a year and a day. This function converts it to a Year-Month-Day format. Here’s an example LocalDate.ofYearDay(2023, 234) will be 2023-08-22. Leap years will also be accounted for.

`LocalDate.parse(text)` : > Obtains an instance of `LocalDate` from a text string using a specific format.

Basically, if we generate a String Date format like 2023-08-22 this will convert it into a LocalDate format

Epoch

There’s one last method I would like to talk about and even though it might not be that useful, it's a good thing to know.
Epoch in simple terms is a date set to the start. Virtually means it's “The start of time”. For example UNIX epoch is set to 1970/1/1 This is when all Unix time is calculated. Now this is not standardized between all computers. Most programming languages will use the UNIX epoch but not between all devices. For example NTP epoch is 1900/1/1. Now you might be asking why. And the simple answer is I don’t know. Unix was developed in 1969 and released in 71 but I guess the developers found 70 easier to work with and now that’s what we use!

`LocalDate.ofEpochDay(epochDay)` : >

Just going based on the description I gave about the output of this would be X days from 1970/1/1. Given epochDay is 1 => 1970-01-02 and so on.

~
~
~

By now I think you guys are all bored of all this nerdy talk and most likely lost interest completely but we are going to make it way more interesting in just a bit.
LocalDate methods have a ton of subsets to modify dates as we talked about above. Explaining all of these is just a waste of time. The best thing is for you guys to check ’em out and play around a bit, they are all very simple to understand.

Locale

The main idea of this whole article was to teach you internationalization and we are going to start that now.
If you recall above I talked about how LocalDate.now() might show different numbers/punctuations and this is standardized by Locale Class

A Locale object represents a specific geographical, political, or cultural region. An operation that requires a Locale to perform its task is called locale-sensitive and uses the Locale to tailor information for the user. For example, displaying a number is a locale-sensitive operation— the number should be formatted according to the customs and conventions of the user's native country, region, or culture.

Again the Locale class uses pre-defined ISO standards that Oracle has included.

As I said - In the early days of the web Java was rushed and we can really see that here.

Locale Constant & Why not to use

If you import java.util.Locale you can see that we have a few constants. Locale.CANADA as an example. If you're wondering what these are and why they were picked, it's quite simple. Due to the reason mentioned above, the Java devs just picked some Locale constants to support and you should not use them. Now if you look closely we have a Locale.French
and a Locale.France and you might be confused, what is this?? I’ll talk about it in a second

Now how do we go about using these Locales? By using Locale.availableLocales() you will see a large subset of available locales that you can use. you might see it in the format of en_US and you might get confused. Following up on the question listed above Java has accounted for different language subsets used in different countries. In this France/French example, We can refer to Canadian French versus French used in France. They are not entirely the same. Now a country like Iran will use Persian no matter the place, so you could just use Locale.of(language) to specify the Locale, But for French you could rather use Locale.of(language, country). Remember if you split what you got from Locale.availableLocales() by the _ you can just format it like that. An example would be Locale.of("en", "US") for en_US

Now let's implement this into our time for our different users around the globe.

System.out.println(
LocalDate.now().format(

DateTimeFormatter

.ofLocalizedDate(FormatStyle.SHORT)

.localizedBy(Locale.GERMAN)));

Now don’t mind the extra code, and even me using Locale.GERMAN cause honestly I was looking for a different output and the easiest way was to use Javas constants. I landed on Locale.GERMAN which outputs 10.07.24 as opposed to what Japan uses (2024/07/10).

Why not use `Locale.of()`

Now it might sound weird, but first of all i tell you not to use constants and prefer Locale.of(), then I tell you not to use Locale.of() an important factor to consider is Locale.of() was introduced with Java 19 which goes against supporting Java 8 SE to combat that from now on we will use

new Locale.Builder()
            .setLanguage("language")
            .setRegion("country").build();

Now another thing you could use is Locale.setDefault(language, country) which will work as well.

DateTimeFormatter

Now looking at the code above you might recall seeing DateTimeFormatter defined by docs as:

Formatter for printing and parsing date-time objects.

`LocalDate.format()`

As I mentioned above, one of the key features of Date/Time Local* APIs was formatting. And this is how we are going to format our dates. Looking at the code above - everything should make sense apart from the .ofLocalizedDate() method. The easiest way to show what it does is with an example.

LocalDate anotherSummerDay = LocalDate.of(2016, 8, 23);
System.out.println(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL).format(anotherSummerDay));
System.out.println(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG).format(anotherSummerDay));
System.out.println(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).format(anotherSummerDay));
System.out.println(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT).format(anotherSummerDay));

will output the following in order:

Tuesday, August 23, 2016
August 23, 2016
Aug 23, 2016
8/23/16

Now sometimes you might want to have your own pattern which you can easily do with

System.out.println(

LocalDate.now().format(

DateTimeFormatter

.ofPattern("dd-uuuu-MMM")));

Now I’ll quickly go over what these symbols mean:
dd => It's a representation of the day field, now you could also use d and the difference would be that d would not have a fixed character limit since it represents 1 digit from 0-9 and 2 from 10-31. if you're lost it basically means dd would show 01; however d would show 1. However, going into two digits it's the same
uuuu/yyyy => Is the field for years. And you could also do yy which would show only the last two digits of the year. ex. 24 rather than 2024
MMM => The last field as you might have guessed is for the month - MMM tells Java that we want a String representation rather than a number. If you want a number use MM

So by now, you should’ve guessed that the output would be:

10-2024-Jul

Instants

Now that you have a firm grip on Dates. I want to introduce you to Instants defined as:

An instantaneous point on the timeline.

Basically, this refers to Instants showing a specific moment.
By now you might have assumed that LocalDateTime has a timezone, but it doesn’t as the docs mentioned they are just a representation of date/time. However a ZoneId is in fact a representation of a time zone. Also, note that Instants don’t provide methods for altering our dates and times.

Instants capture the current moment in UTC with the Instant.now() . Now based on this, you realize that Local* really doesn’t have a meaning unless it's applied, that’s the reason why you would actually refrain from using it in a business-level application. So prefer using ZonedDateTime and Insant. As a general rule of thumb use Locale When it's a specific point on a timeline rather than a moment in time. A moment would be like the moment I publish this, or the moment you read this, or the moment the world explodes, however a point in a timeline would be like an appointment there’s no moment for an appointment. If you're going on a vacation it's a specific time on a timeline, not a moment.

Whats ZonedDateTime?

Quite simple. It's just an Instant with a ZoneId and this is why we say Insant has a timezone. No matter what you do it's not going to represent a time but rather be a specific moment.

Aigh’t well that was quite the thing, wasn’t it? phew
have a nice one >#

Lets make an quote-of-the-day instagram bot!

ryan — Wed, 23 Jun 2021 11:34:35 +0000

Lets get started

🎉 Demo

https://www.instagram.com/dailydouseofquotes/

Make a files:
main.py

Starting the code

🧪 Importing the libaries


import urllib.request
import os
from PIL import Image, ImageDraw, ImageFont, ImageOps
import requests
from instabot import Bot

📷 Getting an image and saving it

def dl_image():
    image_url = "https://source.unsplash.com/user/eberhardgross/1080x1080/"
    urllib.request.urlretrieve(image_url, "image.jpg")
    print("Installing image")

The following code will get an 1080x1080 image by the author eberhardgross from unsplash, Why him ? I haven't seen anything 18+ from this user and have seen amazing images only!

🙌 Getting the daily quote

def dailyquote():
    response = requests.get('https://quotes.rest/qod.json?language=en')
    response_output = response.json()
    return response_output

This code will get a json daily quote of the day response from quotes.rest, as you can see we will output certain results that we from FROM the dailyquote function later!

😎 Putting the quote and image in one!!

🐱‍🚀 Fixing the line order

We will be doing this so we can get a good word-per-line system, so we see the whole text!

def wrap_by_word(s, n):
    a = s.split()
    ret = ''
    for i in range(0, len(a), n):
        ret += ' '.join(a[i:i+n]) + '\n'
    return ret

🎨 Lets do it all!

def text_overlay_ig(quote, author):

    quote = wrap_by_word(quote, 6)

    image_file = os.path.join(os.path.dirname(
        os.path.realpath(__file__)), 'image.jpg')
    im = Image.open(image_file)

Fixing the quote line order and then opening our image file

Time to put on everything!

    draw = ImageDraw.Draw(im)
    font = ImageFont.truetype('font.ttf', size=60)
    (x, y) = (125, 300)
    shadowColor = (0, 0, 0)
    thickness = 4
    draw.text((x - thickness, y - thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y - thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x - thickness, y + thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y + thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x, y), quote, spacing=4, fill=(
        255, 255, 255), font=font)

    (x, y) = (125, 700)
    author = "— " + author
    draw.text((x - thickness, y - thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y - thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x - thickness, y + thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y + thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x, y), author, spacing=4, fill=(
        255, 255, 255), font=font)

    im.save("image.jpg")

🌁 Adding a font.tff file!

i'd recommend using https://github.com/9ebd7134/Python-quote-of-the-day-instagram-bot/blob/master/font.ttf just click on download and put it in your folder ! The font is easy to read so its perfect

And now lets put on the quote on the image

    (x, y) = (125, 300)
    shadowColor = (0, 0, 0)
    thickness = 4
    draw.text((x - thickness, y - thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y - thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x - thickness, y + thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y + thickness), quote,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x, y), quote, spacing=4, fill=(
        255, 255, 255), font=font)

The x, y are the position of the text we want to put, change this but be careful this won't change based on the text length! We could do that but lets stick with this for now

Everything else is us just putting the text alongside the text shadow on the image.

Time to put the author

    (x, y) = (125, 700)
    author = "— " + author
    draw.text((x - thickness, y - thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y - thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x - thickness, y + thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x + thickness, y + thickness), author,
              font=font, fill=shadowColor, thick=thickness)
    draw.text((x, y), author, spacing=4, fill=(
        255, 255, 255), font=font)

Same thing but we are changing the x, y positions AND also adding — to the author username

😎🙌 Final steps

quote = dailyquote()['contents']['quotes'][0]['quote']
author = dailyquote()['contents']['quotes'][0]['author']
tags = dailyquote()['contents']['quotes'][0]['tags']

dl_image()
text_overlay_ig(quote, author)

ptag = ''

for tag in tags:
    ptag += "#" + tag + ' '


content = "This bot was made by ryan s.(@9ebd7134 on github), Hope you enjoyed this quote, This quote was by"+author+"\nLinks:\n📷Image by: https://unsplash.com/user/eberhardgross\nTags:\n#️⃣ " + ptag;

bot = Bot()
bot.login(username="****", password="password1234")
bot.upload_photo("image.jpg", caption=content)

Simply change the caption/content and then bot.login username/password details for this to fully work!

🆘 Fixing up some issues

I'll be updating this and updating the github page for it, i will make an issue and a pull request talking all about the changes! If you want to fix my code i'd love to see it!

Link for the github:

https://github.com/9ebd7134/Python-quote-of-the-day-instagram-bot

My own extension

ryan — Sat, 10 Apr 2021 06:26:29 +0000

My own extension

Check out the extension:
Firefox Users
Chromium Browser users
Github

The first release

I was using the Nord windows theme and saw the amazing community behind it. I wanted to add something to it, something never seen before. My idea was a chrome extension which would make websites more or less like Nord.

The idea

I was really board , and i wanted to make something. So i decided to make nord web themes. I really liked the nord theme too and though many other would love it!

The changes

I have learned a lot ! I fixed a lot of issues and added a list of new websites, nevertheless , I really got board over the past weeks. I don't think i'll continue this project, since i am a web developer. I like to seek for challenges myself but making this extension isn't that easy. I'm doing what i want , not what people want.

Why am i leaving ?

Over the past years i want from a nord lover, to a nord hater. I just learned that looks don't matter. I wanted to focus on what i do, but, I was less productive. I always wanted to check for the new updates and such. I would understand that many are not like me , but i think it was for the better :)

Forem: ryan

Git, Beginner to Master!

Git Command Reference Guide

How to write good commits:

1. Repository Initialization

1.1 Initialize Repository

2. Basic Operations

2.1 Check Status

2.2 View Changes

3. Staging and Committing

3.1 Tracking Files

3.2 Commit Changes

3.3 View Commit History

4. Branching

4.1 Manage Branches

4.2 Switch Branches

5. Remote Repositories

5.1 Add Remote

5.2 Fetch Changes

5.3 Pull Changes

5.4 Push Changes

6. Integrating Changes

6.1 Merge Branches

6.2 Rebase

6.3 Cherry-pick

7. Undoing Changes

7.1 Reset

7.2 Revert

8. Temporary Storage

8.1 Stash Changes

9. Conflict Resolution

9.1 Merge Tool

10. Recovery and History

10.1 Reference Log

11. Submodules

11.1 Manage Submodules

12. Working Trees

12.1 Manage Worktrees

13. Configuration

13.1 Configure Git

14. Tagging

14.1 Manage Tags

15. Cleaning

15.1 Clean Untracked Files

16. Cloning

16.1 Clone Repository

17. Bisect

17.1 Bisect Commits

Lets do dates properly

Before we start

How to work with Dates

The Date API

The LocalDate API

Difference & Which one to use

Issues with the Date/Time API’s

The actual difference

What if I want to store time as well?

Quick little recap and use cases

LocalDate

ISO 8601

Temporal

Methods

LocalDate.now(): > the current date using the system clock and default time-zone, not null

What is ZoneId?

LocalDate.of(year, month, day of month): > Obtains an instance of LocalDate from a year, month, and day.

LocalDate.ofYearDay(year, dayOfYear): >

LocalDate.parse(text) : > Obtains an instance of LocalDate from a text string using a specific format.

Epoch

LocalDate.ofEpochDay(epochDay) : >

Locale

Locale Constant & Why not to use

Why not use Locale.of()

DateTimeFormatter

LocalDate.format()

Instants

Whats ZonedDateTime?

Lets make an quote-of-the-day instagram bot!

Lets get started

🎉 Demo

Starting the code

`LocalDate.now()`: > the current date using the system clock and default time-zone, not null

`LocalDate.of(year, month, day of month)`: > Obtains an instance of `LocalDate` from a year, month, and day.

`LocalDate.ofYearDay(year, dayOfYear)`: >

`LocalDate.parse(text)` : > Obtains an instance of `LocalDate` from a text string using a specific format.

`LocalDate.ofEpochDay(epochDay)` : >

Why not use `Locale.of()`

`LocalDate.format()`