After last week’s Bash scripting marathon, I thought this week would be lighter. I was wrong.

I tackled Git (again), jumped into Python basics, wrestled with exceptions and generators, started my AWS journey, and even squeezed in a Caesar cipher. Somewhere between lambda expressions and cloud design principles, it all began to click.

🗓️ Day 1 — Git Is Not Just Push and Pull

I started the “Git for Beginners” course on KodeKloud. I thought it would be a quick revision — I already knew git init, git commit, git push, and git pull.

But this time, I understood why teams choose branching strategies and how pull requests are not just a GitHub feature but a crucial part of team collaboration.

🔧 Git Tools I Now Rely On

git stash: Save and switch context mid-task
git cherry-pick: Move single commits across branches
git revert vs git reset: One is safe, one rewrites history
git reflog: The ultimate undo

🔍 Git Internals Made Visible

Discovered Git’s object model — blobs, trees, commits — and explored them using:

git hash-object <file>
git cat-file -p <hash>

Git stopped feeling magical. It started making sense.

🗓️ Day 2 — Python: “Beginner” is a Lie 😅

I finished the KodeKloud Python Basics course in one day. It lacked labs but had 38 quizzes and 5 mock exams.

🧪 Mock Exam Scores

Mock 1: 27/30
Mock 2: 25/27
Mock 3: 29/29
Mock 4: 27/29
Mock 5: 25/28

🔍 Lessons I Won’t Forget

.upper() returns a new string — because strings are immutable
[::3] = "every third", not "skip three"
list2 = list1 → same object, not a copy
range('abcd') throws a TypeError
(0,) is truthy because it's a non-empty tuple

Python may look clean, but it hides surprising complexity.

🗓️ Day 3 — Strings, Packages & Cipher Experiments 🔐

After finishing the basics, I officially started the PCAP (Certified Associate in Python Programming) course from KodeKloud. The jump in difficulty was real — more real-world examples, deeper concepts, and an emphasis on writing clean, modular code.

✂️ Cleanups and Transformations

Practiced with small string transformation scripts:

txt = ",$,,   chocolate   banana ice-cream..."
txt = txt.strip(",$ .")
txt = " ".join(txt.split())
print(txt)  # chocolate banana ice-cream

🔁 Caesar Cipher — My Version

Wrote a Caesar cipher from scratch using just loops and logic:

def encrypt(msg):
    result = ""
    for char in msg:
        if char.isalpha():
            if char == 'Z': result += 'A'
            elif char == 'z': result += 'a'
            else: result += chr(ord(char)+1)
        else:
            result += char
    return result

🛠️ Tools & Modules I Explored

pip install, pip show, pip uninstall
random, math, platform, sys
Encoding: ASCII → Unicode → UTF-8
Also learned to avoid wildcard imports — clarity wins.

🗓️ Day 4 — Headache #17, Generators & PCAP Mock Exams

This day hit hard — I continued with the PCAP course and tackled some dense topics like OOP, iterators, and exception handling.

I also completed two PCAP mock exams from KodeKloud:

Mock Exam 1: 34/40 (85%)
Mock Exam 2: 31/40 (80%)

The format and difficulty felt much more aligned with real-world coding — not just theory.

💣 Headache #17

list(map(lambda x: x*x, filter(lambda x: x % 2 == 0, range(10))))

Looked easy. Read it five times. Got it wrong. I’ll never forget this line.

🧯 Try/Except and File Handling

try:
    stream = open("not_here.txt", "rt")
except FileNotFoundError:
    print("File missing!")
finally:
    print("Done.")

👨‍🏫 From Procedural to OOP

Wrote a basic stack class:

class Stack:
    def __init__(self):
        self.__items = []

    def push(self, val):
        self.__items.append(val)

    def pop(self):
        return self.__items.pop()

Also explored:

Multiple inheritance
Method Resolution Order (MRO)
Composition vs inheritance

⚙️ Generators & Closures

def custom_range(n):
    for i in range(n):
        yield i

def multiplier(factor):
    def multiply(num):
        return num * factor
    return multiply

times3 = multiplier(3)
print(times3(5))  # 15

📁 File I/O & Confidence Boost

After all that, file handling felt like a reward.

read(), readline(), readlines()
readinto() for binary files
os.mkdir, os.rmdir, os.system("ls")

Back in Linux territory — and it felt great.

🗓️ Day 5 — Into the Cloud ☁️

Started the AWS Cloud Practitioner course from KodeKloud. No labs, just pure theory — but eye-opening all the same.

☁️ What I Learned About Cloud Computing

Compared traditional IT (hardware, approvals, delays) with cloud (API-driven, instant, scalable). Key models:

All-in-Cloud — Fully hosted on AWS
On-Premises — Managed privately (legacy)
Hybrid Cloud — Best of both worlds

💸 Cloud Economics

Studied AWS billing options:

Free Tier — Explore for free (for 12 months or forever)
On-Demand — Pay only for what you use
Reserved Instances — Commit 1–3 years, save up to 72%
Volume Discounts — Use more, pay less per unit

🧠 Cloud Design Principles

Design for Failure — Expect breakdowns. Plan recovery.
Decouple Components — Use queues to isolate failures.
Implement Elasticity — Auto-scale up/down with demand.
Think in Parallel — Speed things up by splitting work.

🗓️ Day 6 — Security Overload & IAM Rabbit Hole 🔐

This was the day I truly realized how overwhelming AWS security can be — not because it's hard to understand, but because it’s packed with concepts, services, and a ton of theory. Most of it was documentation-style learning with only small demos here and there. It honestly felt a bit dry. No hands-on labs, no clicking around — just concepts. But I also knew this was foundational knowledge I needed to absorb, whether I liked it or not.

The day started with AWS IAM (Identity and Access Management). I explored IAM users, groups, roles, and policies — all the building blocks of how AWS controls access. The course briefly showed how to create IAM entities, but the focus was more on understanding the why behind each component. I also learned how permissions are inherited, how policies are structured in JSON, and how roles differ from users when it comes to temporary credentials.

From there, it expanded into AWS Organizations, where I learned about Organizational Units (OUs) and Service Control Policies (SCPs). These act like guardrails for entire accounts — you can block services even if the IAM user has permissions. It’s powerful but abstract, and I had to watch that section twice to really get it.

Then came the alphabet soup of AWS security services. I explored preventative security tools like AWS WAF (Web Application Firewall), AWS Shield, and AWS Network Firewall. Detection-based services included Amazon GuardDuty, AWS Inspector, AWS Config, Security Hub, Amazon Detective, and even Security Lake. There was also a deep dive into management services like Firewall Manager, Resource Access Manager, Cognito, and Secrets Manager. By this point, my brain was buzzing with acronyms.

I wrapped up the day with cryptographic key management — a core part of securing AWS workloads. I learned how AWS KMS, CloudHSM, Certificate Manager, and Private Certificate Authority all play roles in encrypting and securing data in the cloud. Again, no labs here — but I now understand how AWS handles sensitive data protection and encryption.

This wasn’t the most exciting day of the week, but it was one of the most important. If you don’t understand access control, you don’t understand AWS. Simple as that.

🗓️ Day 7 — Docs, GitHub, and Deep Breaths

After six days of Git, Python, and Cloud, I took Day 7 to reflect and document.

Wrote this entire blog
Organized my notes
Pushed everything to GitHub

Somehow, writing it all down made the learning feel real — like I actually owned it.

✅ What I Took Away This Week (now feels even more true):

Git isn’t just push/pull — it’s a version control machine
Python is “simple” on the surface, but complex inside
Writing my own Caesar Cipher taught me more than reading docs
Cloud isn’t just hosting — it’s a design shift
You don’t memorize code. You test, break, rebuild, and learn

🤝 A Word of Thanks

Special thanks to ChatGPT — my rubber duck, error explainer, and Python therapist 😅. From Caesar ciphers to debugging lambda chains, you’ve helped me make sense of it all.

🚀 My DevOps Journey — Week 7: Git Internals, Python Pitfalls, Cipher Fun & Cloud Realizations