DEV Community: Palak Hirave

Day 29 : Password Manager

Palak Hirave — Sun, 06 Sep 2026 16:15:24 +0000

This is a local version of Google's Password Manager, in which the user has to manually input all of their passwords, which then gets saved in a text file to view later.

Screenshots

Main screen, the email field is pre-set with your email however you can change it

Confirmation popup

Error message if you try to add a new entry but have blank fields

All entires get saved into a text file

Program

from  tkinter import *
from tkinter import messagebox
from random import choice, randint, shuffle
import pyperclip
#---------------------------- PASSWORD GENERATOR ------------------------------- #
def generate_password():
    letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z']
    numbers = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9']
    symbols = ['!', '#', '$', '%', '&', '(', ')', '*', '+']

    password_letters = [choice(letters) for _ in range(randint(8, 10))]
    password_symbols = [choice(symbols) for _ in range(randint(2, 4))]
    password_numbers = [choice(numbers) for _ in range(randint(2, 4))]

    password_list = password_letters + password_symbols + password_numbers

    shuffle(password_list)

    password = "".join(password_list)
    password_entry.insert(0, password)
    pyperclip.copy(password)
# ---------------------------- SAVE PASSWORD ------------------------------- #
def save_data():
    website = website_entry.get()
    email = email_entry.get()
    password = password_entry.get()

    if len(website) == 0 or len(email) == 0 or len(password) == 0:
        messagebox.showerror("Error", "Please fill in all fields")
    else:
        is_ok = messagebox.askokcancel(title=website, message=f"Here are the details: \nPassword: {password}"
                                                      f"\nEmail: {email} \n Is it okay to save?")
        if is_ok:
            with open("data.txt", "a") as file:
                file.write(f"Website: {website} | Email: {email} | Password: {password}\n")
                website_entry.delete(0, END)
                password_entry.delete(0, END)

# ---------------------------- UI SETUP ------------------------------- #
window = Tk()
window.title("Password Manager")
window.minsize(500, 250)
window.config(padx=30, pady=30)

canvas = Canvas(width=200, height=200)
logo = PhotoImage(file="logo.png")

canvas.create_image(100, 100, image=logo)
canvas.grid(column=1, row=0)

website_label = Label(window, text="Website:")
website_label.grid(column=0, row=1)
website_entry = Entry(width=50)
website_entry.focus()
website_entry.grid(column=1,row=1, columnspan=2)

email_label = Label(window, text="Email/Username:")
email_label.grid(column=0, row=2)
email_entry = Entry(width=50)
email_entry.insert(0,"example@gmail.com")
email_entry.grid(column=1,row=2, columnspan=2)

password_label = Label(window, text="Password:")
password_label.grid(column=0, row=3)
password_entry = Entry(width=50)
password_entry.grid(column=1,row=3, padx=5, sticky="w")
password_button = Button(text="Generate Password", command=generate_password)
password_button.grid(column=1, row=3, padx=5,sticky="e")

add_button = Button(text="Add", width=42, command=save_data)
add_button.grid(column=1, row=4, columnspan=2)

window.mainloop()

Day 28 : Pomodoro Timer

Palak Hirave — Mon, 31 Aug 2026 15:11:48 +0000

Many of you may have heard of the famous time management technique - the Pomodoro Timer. This is where you set a 'work' timer for 25 minutes and then a 'break' timer for 5 minutes. You repeat this set 4 times before taking a longer 15 minute break. Today, I decided to build that by combining my knowledge about GUIs and the Tkinter module alongside learning about the canvas widget and how dynamic typing in Python works. Overall, this project was straightforward in its steps though I did struggle a bit with figuring out how to smoothly run the timers. As of now, the timers are of 25 mins, with 5 min breaks and then 15 min breaks between the set, but I plan on improving this so that the user can specify their session breaks(with the min requirement of the amount of time being the standard pomodoro, and adding constraints so they don't abuse the break time).

While I cannot upload videos directly into dev.to posts, below are some screenshots of how the final product looks. My code is posted at the bottom as usual.

Screenshots

Work Timer Screen

Short Break Screen

Long Break Screen, keeps on adding check marks after each round of work + break

Program (main.py)

from tkinter import *
import math
# ---------------------------- CONSTANTS ------------------------------- #
PINK = "#e2979c"
RED = "#e7305b"
GREEN = "#9bdeac"
YELLOW = "#f7f5dd"
FONT_NAME = "Courier"
WORK_MIN = 25
SHORT_BREAK_MIN = 5
LONG_BREAK_MIN = 15
REPS = 0
timer = None

# ---------------------------- TIMER RESET ------------------------------- # 
def reset_screen():
    global REPS
    REPS = 0
    canvas.itemconfig(title_text, text="Timer", fill=GREEN)
    canvas.itemconfig(timer_text, text="00:00")
    check_marks.config(text=" ")

def reset_timer():
    window.after_cancel(timer)
    reset_screen()

# ---------------------------- TIMER MECHANISM ------------------------------- # 
def timer_time():
    global REPS
    REPS += 1
    if REPS % 8 == 0:
        countdown(LONG_BREAK_MIN * 60)
        canvas.itemconfig(title_text, text="Break", fill=RED)
    elif REPS % 2 == 0:
        countdown(SHORT_BREAK_MIN * 60)
        canvas.itemconfig(title_text, text="Break", fill=PINK)
    else:
        countdown(WORK_MIN * 60)
        canvas.itemconfig(title_text, text="Work", fill=GREEN)

# ---------------------------- COUNTDOWN MECHANISM ------------------------------- # 
def countdown(count):
    global timer
    count_mins = math.floor(count / 60)
    count_secs = count % 60
    if count_secs < 10:
        count_secs = "0" + str(count_secs)

    canvas.itemconfig(timer_text, text=f"{count_mins}:{count_secs}")
    if count > 0:
        timer = window.after(1000, countdown, count - 1)
    else:
        timer_time()
        checks = ""
        for rep in range(math.floor(REPS/2)):
            checks += "✔"
            check_marks.config(text=checks)

# ---------------------------- UI SETUP ------------------------------- #
window = Tk()
window.title("Pomodoro Timer : Get Work Done")
window.config(padx=100, pady=25, bg = YELLOW)

canvas = Canvas(width=200, height=350, bg=YELLOW, highlightthickness=0)
tomato = PhotoImage(file="tomato.png")

canvas.create_image(100, 180, image=tomato)
canvas.grid(row=1, column=2)

timer_text = canvas.create_text(100, 190, text="00:00", fill="white", font=(FONT_NAME, 35, "bold"))
canvas.grid(row=2, column=2)

title_text = canvas.create_text(100, 30,text="Timer", fill=GREEN, font=(FONT_NAME, 35, "bold"))
canvas.grid(row=2, column=2)

start_button = Button(text = "Start", command=timer_time)
start_button.grid(row=3, column=1)
restart_button = Button(text = "Restart", command=reset_timer)
restart_button.grid(row=3, column=3)

check_marks = Label(text="", font=(FONT_NAME, 10), fg=GREEN, bg=YELLOW)
check_marks.grid(row=3, column=2)


window.mainloop()

Day 27 of 100

Palak Hirave — Wed, 19 Aug 2026 14:27:28 +0000

Today I learnt about the Tkinter module and what args and kwargs are. It has got me thinking about what sort of games I can make with it. Below are the notes, and the final project is at the very bottom.

Notes

notes.py
for learning about args and kwargs

# Multiple positional arguments
def add(*args):
    total = 0
    for n in args:
        total += n
    print(total)

add(3,56,78,9,78)

# Multiple keyword arguments
# Optional parameters

def calculate(n, **kwargs):
    print(kwargs)
    n += kwargs["add"]
    n -= kwargs["sub"]
    n *= kwargs["mul"]
    n /= kwargs["div"]

calculate(3, add = 5)

class Drawing:
    def __init__(self, **kw):
        self.colour = kw.get("colour")
        self.width = kw.get("width")
        self.height = kw.get("height")

tkinter_notes.py
self-explanatory

from tkinter import *

print("DOCUMENTATION - https://www.tcl-lang.org/man/tcl8.6/TkCmd/contents.htm")

window = Tk()
window.title("My first GUI Program")
window.minsize(400, 300)
window.config(padx = 10, pady = 10)

# Label
my_label = Label(text="This is a label.")
my_label.pack(side="left")

# Update properties of previous component (any of these 2 methods)
my_label["text"] = "New text."
my_label.config(text = "New text.")
my_label.config(padx = 15, pady = 15)

# Entry
input = Entry(width = 20)
input.pack(side = "right")

# Button
def button_clicked():
    answer = input.get()
    my_label.config(text = str(answer))

button = Button(text = "A button.", command = button_clicked)
button.pack()

window.mainloop()

# pack() is straightforward to use, you can leave it at default, left, right or bottom,
# but it is very hard to precisely position something
# with place() you can add the x= and y= parameters, but it is sometimes too specific, and
# you need to work out the position in your head
# so, with gird() you can specify the row = and column =
# however, this is relative to the other entities positions on the display
# you cannot mix grid() and pack() in the same program

Tkinter_Widgets.py
notes provided by the course

from tkinter import *

#Creating a new window and configurations
window = Tk()
window.title("Widget Examples")
window.minsize(width=500, height=500)

#Labels
label = Label(text="This is old text")
label.config(text="This is new text")
label.pack()

#Buttons
def action():
    print("Do something")

#calls action() when pressed
button = Button(text="Click Me", command=action)
button.pack()

#Entries
entry = Entry(width=30)
#Add some text to begin with
entry.insert(END, string="Some text to begin with.")
#Gets text in entry
print(entry.get())
entry.pack()

#Text
text = Text(height=5, width=30)
#Puts cursor in textbox.
text.focus()
#Adds some text to begin with.
text.insert(END, "Example of multi-line text entry.")
#Get's current value in textbox at line 1, character 0
print(text.get("1.0", END))
text.pack()

#Spinbox
def spinbox_used():
    #gets the current value in spinbox.
    print(spinbox.get())
spinbox = Spinbox(from_=0, to=10, width=5, command=spinbox_used)
spinbox.pack()

#Scale
#Called with current scale value.
def scale_used(value):
    print(value)
scale = Scale(from_=0, to=100, command=scale_used)
scale.pack()

#Checkbutton
def checkbutton_used():
    #Prints 1 if On button checked, otherwise 0.
    print(checked_state.get())
#variable to hold on to checked state, 0 is off, 1 is on.
checked_state = IntVar()
checkbutton = Checkbutton(text="Is On?", variable=checked_state, command=checkbutton_used)
checked_state.get()
checkbutton.pack()

#Radiobutton
def radio_used():
    print(radio_state.get())
#Variable to hold on to which radio button value is checked.
radio_state = IntVar()
radiobutton1 = Radiobutton(text="Option1", value=1, variable=radio_state, command=radio_used)
radiobutton2 = Radiobutton(text="Option2", value=2, variable=radio_state, command=radio_used)
radiobutton1.pack()
radiobutton2.pack()


#Listbox
def listbox_used(event):
    # Gets current selection from listbox
    print(listbox.get(listbox.curselection()))

listbox = Listbox(height=4)
fruits = ["Apple", "Pear", "Orange", "Banana"]
for item in fruits:
    listbox.insert(fruits.index(item), item)
listbox.bind("<<ListboxSelect>>", listbox_used)
listbox.pack()
window.mainloop()

Final Project (Miles to Kilometer Conversion)

from tkinter import *
window = Tk()
window.title("Miles to Kilometers")
window.minsize(300, 100)
window.config(padx = 5, pady = 5)

# TODO : define a function to convert miles to kilometers rounded to the nearest .1
def conversion(answer):
    kilometers = float(answer) * 1.60934
    kilometers = round(kilometers, 1)
    return kilometers

# TODO : define a function to get the user's input and display conversion
input = Entry(width = 20)
input.grid(row=0, column=0)

label = Label(text="Miles is equals to")
label.grid(row=0, column=1)

answer_label = Label(text="0")
answer_label.grid(row=1, column=0)

final_label= Label(text="Km")
final_label.grid(row=1, column=1)

def button_clicked():
    answer = input.get()
    answer_label.config(text = str(conversion(answer)))

button = Button(text = "Calculate", command = button_clicked)
button.grid(row=2, column=2)

window.mainloop()

Day 26 of 100

Palak Hirave — Wed, 12 Aug 2026 10:42:17 +0000

I looked though how to do list and dictionary comprehensions as well as making a small project based off of it.

notes.py

import random
import pandas

# List Comprehension
# new_list = [new_item for item in list]

numbers = [1, 2, 3, 4, 5, 6]
numbers_plus_one = [n + 1 for n in numbers]
print(numbers_plus_one)

name = "Palak"
letters = [letter for letter in name]
print(letters)

numbers = [n for n in range(1,6)]
print(numbers)

# Conditional List Comprehension
# new_list = [new_item for item in list if test]

names = ["Alex", "Beth", "Jane", "Roger", "Freddie", "Max", "Maximus", "Tyler"]
short_names = [name for name in names if len(name) <= 4]
print(short_names)

uppercase_names = [name.upper() for name in short_names if len(name) < 5]
print(uppercase_names)

print("----------------------------------------------------")

# Dictionary Comprehension
# new_dict = {new_key:new_value for item in list}
# new_dict = {new_key:new_value for (key,value) in dict.items()}

names = ["Alex", "Beth", "Jane", "Roger", "Freddie", "Max", "Maximus", "Tyler"]
random_scores = {students:random.randint(1,101) for students in names}
print(random_scores)

passed_students = {students:random_scores[students] for students in names if random_scores[students] >= 60}
# OR passed_students = {students:score for (students,score) in random_scores.items() if score >= 60}
print(passed_students)

# Turn dict into DataFrame
colours = {"Red" : ["Bright", "Dark"],
            "Blue" : ["Sky", "Deep"]}

students_dataframe = pandas.DataFrame(colours)
print(students_dataframe)

# Loop through a data frame
for (key, value) in students_dataframe.items():
    print(value)

# Loop through rows in a dataframe
for (index, row) in students_dataframe.iterrows():
    print(row)

NATO Alphabet Mini-Project (main.py)

import csv

#TODO 1. Create a dictionary using dictionary comprehension:
with open("nato_phonetic_alphabet.csv") as file:
    reader = csv.reader(file)
    alphabet = {row[0]: row[1] for row in reader if row[0] != "letter"}

#TODO 2. Create a list of the phonetic code words from a word that the user inputs.
name = input("Enter your name: ")
broken_name = [letter.upper() for letter in name ]
words = [alphabet[assigned_letter] for assigned_letter in broken_name]
print("The NATO phonetic words for you name is: \n", words)

nato_phonetic_alphabet.csv

letter,code
A,Alfa
B,Bravo
C,Charlie
D,Delta
E,Echo
F,Foxtrot
G,Golf
H,Hotel
I,India
J,Juliet
K,Kilo
L,Lima
M,Mike
N,November
O,Oscar
P,Papa
Q,Quebec
R,Romeo
S,Sierra
T,Tango
U,Uniform
V,Victor
W,Whiskey
X,X-ray
Y,Yankee
Z,Zulu

Day 25 of 100

Palak Hirave — Sun, 09 Aug 2026 13:48:15 +0000

Whilst I had heard about the Pandas library, today I learnt how to use it. I also took some time later to just go though the 'getting started' part of the documentation(which can be found here). I took some notes and then did a project in which you have to guess all 50 of the United States. This list of various bits of code is ordered from what I did first and my final project at the bottom.

notes.py

print("------------------------------------------------------")

import csv
# Reading a file and collecting data from one of its
#   columns and converting it to an integer
with open("weather_data.csv") as data_file:
    data = csv.reader(data_file)
    temp = []
    for row in data:
        if row == ['day', 'temp', 'condition']:
            pass
        else:
            degree = int(row[1])
            temp.append(degree)
    print(temp)

print("------------------------------------------------------")

import pandas as pd
# With Pandas
data = pd.read_csv('weather_data.csv')
print(data["temp"])

print("------------------------------------------------------")

# Turns DataFrame to dictionary
data_dict = data.to_dict()
print(data_dict)

# Turns Series to list
temp_list = data["temp"].to_list()
print(temp_list)

print("------------------------------------------------------")

average = sum(temp_list) / len(temp_list)
# OR
average = data["temp"].mean()

print(data["temp"].max())

print("------------------------------------------------------")

# Get data in columns
print(data["condition"])
print(data.condition) #Behind the scenes, pandas
                    # converts each of the columns into attributes
# Get data in rows
print(data[data.day == "Monday"])
print(data[data.temp == data.temp.max()])

monday = data[data.day == "Monday"]
fahrenheit = monday["temp"] * 1.8 + 32
print(fahrenheit)

print("------------------------------------------------------")

# Create DataFrame from scratch
newdata_dict = {"names" : ["John", "Rebecca", "Myles", "Styles", "Anthony"],
                "test scores" : [24, 99, 57, 78, 80]}

data = pd.DataFrame(newdata_dict)
data.to_csv("new_data.csv", index=False)

weather_data.csv

day,temp,condition
Monday,12,Sunny
Tuesday,14,Rain
Wednesday,15,Rain
Thursday,14,Cloudy
Friday,21,Sunny
Saturday,22,Sunny
Sunday,24,Sunny

new_data.csv (created once notes.py runs)

names,test scores
John,24
Rebecca,99
Myles,57
Styles,78
Anthony,80

Squirrels!

The squirrel data for this project can be found here.

import pandas as pd
# TODO : take the Primary Fur Color column and make a
#  new .csv file that contains the three colours and
#  how many squirrels are in each one

black = 0
gray = 0
cinnamon = 0

data = pd.read_csv("squirrel_data.csv")
for color in data["Primary Fur Color"] :
    if color == "Black" :
        black += 1
    elif color == "Gray" :
        gray += 1
    else:
        cinnamon += 1

small_squirrel_data = {"Colour" : ["Black", "Gray", "Cinnamon"],
                       "Count" : [black, gray, cinnamon],}
data = pd.DataFrame(small_squirrel_data)
data.to_csv("small_squirrel_data.csv", index=False)

Output CSV file (small_squirrel_data.csv)

Colour,Count
Black,103
Gray,2473
Cinnamon,447

Main Project - Guess the USA's States

main.py

import pandas as pd
import turtle
import time

screen = turtle.Screen()
screen.title("U.S.A State Game")
image = "blank_states_img.gif"
screen.addshape(image)
screen.setup(height=500,width=730)
screen.bgpic("blank_states_img.gif")
turtle.shape(image)

# TODO : Get x and y values for all states on the image
# def mouse_click_coord(x,y):
#     print(x,y)
#
# turtle.onscreenclick(mouse_click_coord)
# turtle.mainloop()

game_on = True
states_guessed = 0
correct_guess = ""
guessed_states = []
pen = turtle.Turtle()
pen.penup()
pen.hideturtle()
pen.speed(0)

while game_on:
    answer_state = screen.textinput(title="Guess a state",
                                    prompt=f"{states_guessed}/50 states guessed", )

    states_list = pd.read_csv("50_states.csv")

    for states in states_list.state:
        if states == answer_state.title():
            correct_guess = answer_state.title()

            if correct_guess not in guessed_states:
                states_guessed += 1
                guessed_states.append(correct_guess)
                row_list = states_list[states_list.state == correct_guess]
                row_list = row_list.to_dict()
                xcor = list(row_list['x'].values())[0]
                ycor = list(row_list['y'].values())[0]
                pen.goto(x = xcor, y = ycor)
                pen.write(correct_guess, align="right", font=("Courier", 7, "bold"))

    if states_guessed == 50:
        screen.textinput("Finished", "You have guessed all the states!")
        time.sleep(1)
        game_on = False

screen.exitonclick()

50_states.csv
Note - the coordinates may not be exact for everyone, their a bit off for me as well but I can't be asked to individually change them all.

state,x,y
Alabama,139,-77
Alaska,-204,-170
Arizona,-203,-40
Arkansas,57,-53
California,-297,13
Colorado,-112,20
Connecticut,297,96
Delaware,275,42
Florida,220,-145
Georgia,182,-75
Hawaii,-317,-143
Idaho,-216,122
Illinois,95,37
Indiana,133,39
Iowa,38,65
Kansas,-17,5
Kentucky,149,1
Louisiana,59,-114
Maine,319,164
Maryland,288,27
Massachusetts,312,112
Michigan,148,101
Minnesota,23,135
Mississippi,94,-78
Missouri,49,6
Montana,-141,150
Nebraska,-61,66
Nevada,-257,56
New Hampshire,302,127
New Jersey,282,65
New Mexico,-128,-43
New York,236,104
North Carolina,239,-22
North Dakota,-44,158
Ohio,176,52
Oklahoma,-8,-41
Oregon,-278,138
Pennsylvania,238,72
Rhode Island,318,94
South Carolina,218,-51
South Dakota,-44,109
Tennessee,131,-34
Texas,-38,-106
Utah,-189,34
Vermont,282,154
Virginia,234,12
Washington,-257,193
West Virginia,200,20
Wisconsin,83,113
Wyoming,-134,90

Day 24 of 100

Palak Hirave — Sat, 08 Aug 2026 12:43:34 +0000

Today I learnt all about files, paths and directories. I learnt what a relative and absolute file path is as well as how to use both in Pycharm alongside reading and writing files. Rather than doing a singular main project I did multiple small ones, including upgrading my Snake game to have a high score that stays every time you load the game.

This is one of the mini-projects that I did -

with open("C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Input/Names/invited_names.txt", "r") as file:
    invited_names = file.read().splitlines()

with open("C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Input/Letters/starting_letter.txt") as letter:
    base_letter = letter.read()

for name in invited_names:
    with open(f"C:/Users/hirav/Desktop/Python Projects/Mail Merge Project/Output/ReadyToSend/letter.to.{name}.txt", "w") as email:
        email.write(base_letter.replace("[name]", name))

Day 23 of 100

Palak Hirave — Fri, 24 Jul 2026 10:33:11 +0000

Today I made the capstone project for the beginners section of my 100 days of python challenge. It is similar to the Crossy Roads game. There is a turtle which has to make it to the end of the screen before any of the colourful blocks(which move from the right to left) hit it. Each time it crosses the northern boundary(the turtle starts in the south and heads upwards) it returns to its original position for the next level, except this time the blocks are moving faster.

Overall I had a great time building this project. After a quick overview into how the game was supposed to work I found that it was quite straightforward and didn't need much problem solving. I flew though creating the turtle, scoreboard and game over screen but got a little stuck on how to make so many blocks and how to detect if a block has collided with the turtle. In the end, it worked out quite nicely.

When it comes to the actual program, I should have cleaned up the code a bit but was not quite sure how to. Mostly on the car_manager part(The cars are the blocks). I could have turned all of the workings for the blocks/cars I did in the while loop into separate functions in the CarManager class and then simply called them but I wasn't quite sure how to. That is definitely something to improve/look into next time. I am quite happy to finally be in the intermediate territory of python programming.

Here's the code -

main.py

import time
from turtle import Screen
from player import Player
from car_manager import CarManager
from scoreboard import Scoreboard

screen = Screen()
screen.setup(width=600, height=600)
screen.tracer(0)
screen.title("Turtle Crossing Game")

player = Player()
scoreboard = Scoreboard()
cars = []
car = CarManager()

cars.append(car)

loop_count = 0
MOVE_SEGMENT = 5

game_is_on = True
while game_is_on:
    time.sleep(0.1)
    screen.update()
    for c in cars:
        c.backward(MOVE_SEGMENT)

    screen.onkey(player.move_up, "Up")
    screen.listen()

    if player.ycor() >= 280:
        scoreboard.update_score()
        player.reset_pos()
        MOVE_SEGMENT += 7

    loop_count += 1
    if loop_count == 6:
        car = CarManager()
        cars.append(car)
        loop_count = 0

    for cr in cars:
        if player.distance(cr) < 20:
            game_is_on = False

screen.tracer(1)
scoreboard.game_over()

screen.exitonclick()

player.py

from turtle import Turtle

STARTING_POSITION = (0, -280)
MOVE_DISTANCE = 10
FINISH_LINE_Y = 280

class Player(Turtle):
    def __init__(self):
        super().__init__()
        self.color("black")
        self.shape("turtle")
        self.setheading(90)
        self.penup()
        self.goto(STARTING_POSITION)


    def move_up(self):
        self.forward(MOVE_DISTANCE)

    def reset_pos(self):
        self.goto(STARTING_POSITION)

scoreboard.py

from turtle import Turtle

FONT = ("Courier New", 22, "bold")

class Scoreboard(Turtle):
    def __init__(self):
        super().__init__()
        self.color("black")
        self.penup()
        self.hideturtle()
        self.goto(-280,260)
        self.write("Score:0", font = FONT)
        self.score = 0

    def update_score(self):
        self.score += 1
        self.clear()
        self.write("Score:" + str(self.score), font = FONT)

    def game_over(self):
        self.goto(-70,-10)
        self.write("Game Over.", font=FONT)

car_manager.py

from turtle import Turtle
import random

COLORS = ["red", "orange", "yellow", "green", "blue", "purple"]
STARTING_MOVE_DISTANCE = 5
MOVE_INCREMENT = 10

class CarManager(Turtle):
    def __init__(self):
        super().__init__()
        self.color(random.choice(COLORS))
        self.shape("square")
        self.penup()
        self.shapesize(stretch_wid=1, stretch_len=2)
        self.random_y = random.randint(-250, 250)
        self.goto(300,self.random_y)

    def collision(self):
        pass

Learning Log

Palak Hirave — Fri, 24 Jul 2026 05:42:24 +0000

Hello. Here I will be listing the resources I used for learning cybersecurity and in the order I completed them. Feel free to use any of the resources for your own learning. I'll make sure to update this list as I progress.

Day 22 of 100

Palak Hirave — Wed, 22 Jul 2026 07:12:47 +0000

I'm coming back to this series after quite a long time. It's nice to get back to programming.

Today I build the Ping Pong game with a simple UI. Here's the code -

main.py

from turtle import Screen
from paddle import Paddle
from ball import Ball
from scoreboard import Scoreboard
import time

screen = Screen()
screen.setup(width=800, height=600)
screen.bgcolor("black")
screen.title("Pong")
screen.tracer(0)

r_paddle = Paddle(350,0)
l_paddle = Paddle(-350,0)
ball = Ball()
scoreboard = Scoreboard()

screen.listen()
screen.onkey(r_paddle.up, "Up")
screen.onkey(r_paddle.down, "Down")
screen.onkey(l_paddle.up, "w")
screen.onkey(l_paddle.down, "s")

game_is_on = True

while game_is_on:
    time.sleep(ball.faster)
    screen.update()
    ball.move()

    if ball.ycor() > 280 or ball.ycor() < -280:
        ball.bounce_y()

    if ball.distance(r_paddle) < 55 and ball.xcor() > 320 or ball.distance(l_paddle) < 50 and ball.xcor() < -320:
        ball.bounce_x()

    if ball.xcor() > 380:
        ball.reset_pos()
        scoreboard.l_point()

    if ball.xcor() < -380:
        ball.reset_pos()
        scoreboard.r_point()


screen.exitonclick()

ball.py

from turtle import Turtle

class Ball(Turtle):
    def __init__(self):
        super().__init__()
        self.shape("circle")
        self.color("white")
        self.penup()
        self.x_new = 10
        self.y_new = 10
        self.faster = 0.1

    def move(self):
        new_x = self.xcor() + self.x_new
        new_y = self.ycor() + self.y_new
        self.goto(new_x, new_y)

    def bounce_y(self):
        self.y_new *= -1

    def bounce_x(self):
        self.x_new *= -1
        self.faster *= 0.7

    def reset_pos(self):
        self.goto(0,0)
        self.faster = 0.1
        self.bounce_x()

paddle.py

import turtle

class Paddle(turtle.Turtle):

    def __init__(self, xcord, ycord):
        super().__init__()
        self.color("white")
        self.shape("square")
        self.shapesize(stretch_wid=5, stretch_len=1)
        self.penup()
        self.x_cord = xcord
        self.y_cord = ycord
        self.setpos(self.x_cord, self.y_cord)
        self.jump = 20

    def up(self):
        self.goto(self.x_cord, self.y_cord + self.jump)
        self.y_cord += self.jump

    def down(self):
        self.goto(self.x_cord, self.y_cord - self.jump)
        self.y_cord -= self.jump

scoreboard.py

import turtle

class Scoreboard(turtle.Turtle):
    def __init__(self):
        super().__init__()
        self.color("white")
        self.penup()
        self.hideturtle()
        self.l_score = 0
        self.r_score = 0
        self.update_score()

    def update_score(self):
        self.clear()
        self.goto(-100, 200)
        self.write(self.l_score, align="center", font=("Arial", 70, "normal"))
        self.goto(100, 200)
        self.write(self.r_score, align="center", font=("Arial", 70, "normal"))

    def l_point(self):
        self.l_score += 1
        self.update_score()

    def r_point(self):
        self.r_score += 1
        self.update_score()

Proxies

Palak Hirave — Tue, 21 Jul 2026 04:36:27 +0000

A proxy is a mediator that sits between two points/connections. Unlike a gateway, which just checks the source and destination IP Address, a proxy opens up the data packets and inspects what is inside and then makes a call as the whether or not to send on the data packet. Proxies can filter content, scan for malware, cache data(save a copy of popular websites locally to speed up load times for everyone else on the network), and hide your identity or rewrite the web request before sending it along. Proxies almost always operate at layer 7 of the OSI Model.

Dedicated Proxy / Forward Proxy

A Forward Proxy sits in front of clients (like employees' laptops) and acts as an intermediary before their traffic hits the internet.

eg. When you try to visit example.com:

Your browser sends the request to the Forward Proxy inside your company.
The proxy inspects the request (checking rules like "Is this site allowed? Is it safe?").
The proxy reaches out to example.com on your behalf, gets the webpage, and hands it back to you.

Why Forward Proxies Block Malware (C2 Communication)
When malware infects a machine, it needs to reach back out to the attacker's server, known as a Command and Control (C2) server, to receive instructions or steal data.

In a corporate environment with a forward proxy the infected computer cannot connect directly to the internet. To talk to the outside world, the malware must know how to route its traffic through the proxy. If the malware tries to make a direct connection without going through the proxy, the corporate firewall simply drops the connection, leaving the malware stranded and unable to operate.

The "System Proxy" vs. Firefox Advantage

Windows Native Apps (Chrome, Edge, IE, WinSock): Most Windows malware uses built-in Windows network tools (like WinSock). Because these built-in tools automatically read and use the computer's "System Proxy" settings, the malware unintentionally routes its traffic right through the corporate proxy, where security teams can detect and block it.
Firefox (Cross-Platform/libcurl): Firefox ignores Windows' built-in system proxy settings and uses its own independent networking code (libcurl).

If a company exclusively uses Firefox and configures proxy settings inside Firefox itself (rather than at the Windows system level), standard malware using Windows built-in tools won't know how to find those proxy settings. The malware fails to talk to its C2 server because it doesn't know where the proxy is.

Alternative Malware Tactics
If malware realizes web traffic (HTTP/HTTPS) is blocked, it might try using DNS requests to leak data or get commands (since DNS requests often bypass web proxies). However, security tools like Sysmon easily log and alert on weird DNS patterns, catching the attacker anyway.

Burp Suite is a popular cybersecurity tool used by ethical hackers and security testers. While usually set up on a tester's machine as a forward proxy to capture and tweak web requests in real-time, it is flexible enough to be reconfigured as a reverse proxy or a transparent proxy depending on the test scenario.

Reverse Proxy

This is the reverse of the Forward Proxy. Rather than monitoring requests that go out, it monitors requests that come into the network. The most common goal of this type of proxy is to listen on and forward it to a closed-off network.

Penetration Testers will configure reverse proxies on infected endpoints. The infected endpoint will listen on a port and send any client that connects to the port back to the attacker through the infected endpoint. This is useful to bypass firewalls or evade logging. Organizations may have IDS (Intrusion Detection Systems), watching external web requests. If the attacker gains access to the organization over SSH, a reverse proxy can send web requests through the SSH Tunnel and evade the IDS.

(Non-) Transparent Proxy

All these proxy services act either transparently or non-transparently.

With a transparent proxy, the client doesn't know about its existence. The transparent proxy intercepts the client's communication requests to the Internet and acts as a substitute instance. To the outside, the transparent proxy, like the non-transparent proxy, acts as a communication partner.

If it is a non-transparent proxy, we must be informed about its existence. For this purpose, we and the software we want to use are given a special proxy configuration that ensures that traffic to the Internet is first addressed to the proxy. If this configuration does not exist, we cannot communicate via the proxy. However, since the proxy usually provides the only communication path to other networks, communication to the Internet is generally cut off without a corresponding proxy configuration.

Networking Topologies

Palak Hirave — Tue, 21 Jul 2026 03:51:19 +0000

A network topology is the layout of a network—how devices are connected to one another both physically and logically.

Networks are made up of two main types of hardware:

Hosts: The end devices using the network (computers, servers, phones, laptops).
Network Components: Devices that sit in the middle (routers, switches, bridges) to direct traffic and make sure data gets from host A to host B.

The topology you choose determines what hardware you need to buy and how data is allowed to travel across the system.

Physical vs. Logical Topology
This is one of the most important distinctions in networking:

Physical Topology: The physical setup you can see and touch. It includes the actual cables, where the devices are located in a room, and how cables run through walls.
Logical Topology: The invisible pathway data takes. It’s how signals actually travel from device to device across the network, regardless of what the cable setup looks like physically.

Example: You could arrange four computers physically in a circle on a single desk (looks like a ring), but if they all plug into a central box in the middle, data travels in a star pattern logically.

The Three Areas of Network Topologies

Connections (The Medium)
These are the channels data travels through:

Wired: Twisted-pair copper cables (standard Ethernet), coaxial cables (older cable TV style), and glass fiber cables (ultra-fast light pulses).
Wireless: Wi-Fi, cellular networks (4G/5G), and satellite links.

Nodes (The Intermediaries)
A node is any connection point where data is sent, received, or forwarded. This includes:

Network Interface Controller (NIC): The network card/chip inside your computer that allows it to talk to a network.
Traffic Hardware: Devices that manage signal flow—such as Repeaters (boost signal), Switches (direct traffic in a building), Routers (connect different networks/internet), and Firewalls (security filters).

Note: A node doesn't always have to be a full computer, it can be a small smart sensor or microcontroller.

Classifications (The Layout Patterns)
Networks generally follow eight fundamental structural shapes (or a combination of them):

Point-to-Point: A direct, dedicated line between exactly two devices.
Bus: Every device connects to one single central trunk cable.
Star: All devices plug directly into one central hub or switch (the most common modern setup).
Ring: Each device connects to two neighbors, forming a closed circle of data flow.
Mesh: Devices connect directly to multiple other devices (or all of them) for high reliability/redundancy.
Tree: A hierarchical setup combining star networks onto a main backbone cable (looks like a family tree).
Daisy Chain: Linking devices together in a linear chain, one after another.
Hybrid: Combining two or more of the above shapes (e.g., mixing a Star and a Mesh) to handle larger or more complex environments.

Types of Networks

Palak Hirave — Tue, 21 Jul 2026 03:15:02 +0000

Common Terms - networking terms and topologies that are commonly used
Book Terms - networking terms that are not so common and you don't need to be able to recite them unless you are taking a networking exam

Common Terms

We have already gone over most of these previously so I am just going to summarize them.

WAN - Stands for Wide Area Network and is most commonly known as the Internet however a WAN is just a collection of LANs put together. Companies and Governments also tend to have internal WANs.

LAN/WLAN - Stands for (Wireless) Local Area Network and tends to assign IP addresses for local use. In some cases you may be assigned an IP address to use over the internet but this is rare. There is no difference between a LAN and WLAN aside from the fact that one doesn't need cables and is wireless.

VPN - Stands for Virtual Private Network and is used to make it appear as though your device is physically plugged into a different network. There are three main types.

Site-To-Site VPN : The client and server are Network Devices, typically either Routers or Firewalls, and share entire network ranges. This is most commonly used to join company networks together over the Internet, allowing multiple locations to communicate over the Internet as if they were local.
Remote Access VPN : It connects your device to a private network by creating an encrypted tunnel, making your computer appear as if it is inside that network. Other devices then see the VPN server's IP address rather than your own, which adds a layer of security.
SSL VPN : Stands for Secure Sockets Layer VPN and rather than downloading VPN software, it runs directly in your browser and they can stream applications or desktop sessions.

Book Terms

GAN - This stands for Global Area Network and whilst the Internet is one of them, international companies also have them as they connect multiple WANs to connect company computers worldwide. This is typically done though international undersea cables or satellite transmission.

MAN - Stands for Metropolitan Area Network and is used to connect multiple LANs over a local area e.g. a city. Instead of sending sensitive corporate files over the public internet, which can slow down during peak traffic hours, the company rents or uses direct high-speed optical fiber cables. Because these fiber links are direct and high-powered, sending a file to an office 10 miles across town feels just as fast as sending a file to the printer in the next room. Internationally companies can then plug these MANs into a WAN(for countries/continents) or a GAN(for global reach).

PAN/WPAN - Stands for (Wireless) Personal Area Network and is used to connect devices for data exchange. These typically span a few meters and are therefore not suitable for connecting devices in a home/building.