So, starting after the holiday (Arefa), I will intensively learn and log here, inshallah, the deep concepts I understood clearly and the projects I built, even if small, focusing on system understanding and architectures. No log in this channel most probably means I am not learning that day.
Until then, share this channel with those who want to learn.

Eid Mubarak ❤️

Action is what brings clarity not endless thinking!

🔥🔥 Deadline extended 🔥🔥

🔄 Get $300 Free Claude Opus 4.8 Access 💻🔥


A Chinese platform is giving FREE Opus 4.8 API credits and Codex access for new users! 🎉🔄

✅ $300 total free credits🦇
✅ additional $10 for every user you invited
✅ $66 credits every week💎
✅ $10 every 5 hours


https://freemodel.dev/invite/FRE-8a619b08

Create your account and start using Opus 4.8 APIs for free before the offer ends. ⏳

💥 Make sure to verify with your telegram account to be eligible.

Today learned how to use an AK-47 fr.

fr.. here the 4 Universal Firearm Safety Rules as told me by... : man yaqal titafesu yhonal.

1. Treat every firearm as if it is loaded
2. Never point it at anything you are not willing to destroy
3. Keep your finger off the trigger until ready to fire
4. Be sure of your target and what is beyond it

deep Git skill helps u Scale Your Codebase

I think being very comfortable with Git and understanding it deeply is one of the highest-leverage skills right now.

Code is becoming cheaper to generate. With AI, you can spin up a repo and add multiple features in a day. The challenge is no longer just writing code it's managing the codebase as it grows.

That's where Git shines.

When you understand branching, merging, tags, stash, and history well, you can keep moving forward without getting overwhelmed by the size of your own code (or your LLM's code 😉).

And honestly, that's how real software works. Think about a huge codebase with thousands or millions of lines of code. No single developer understands every part of it. What makes it manageable is architecture, collaboration, and tools like Git. so be smooth and playing very comfy with git so u can manage Ur next large project ..

Saying this lemme share the big picture about Git - just the concept:

* Git is just a software installed on your machine (usually comes with Linux and Mac 😭). When you run git init, it creates a hidden .git folder in your project root that stores everything - commits, history, branches, tags, etc... U can see it making hidden files visible.
* Git is a graph of commits(directed acyclic graph) , where every commit is a node pointing back to the previous commit(node), so your project history becomes a chain/graph of nodes (commits)

* A branch is just a movable pointer to a commit; creating a branch means creating another pointer at the same commit, and then each branch can evolve independently as new commits are added.
* tag is also a fixed pointer to a commit, used to mark stable versions like v1.0, v2.0, releases, etc., and unlike branches, tags never move.
.. Etc...

So basically like :
git = a graph of commit,
branches = moving pointers on commits ,
tags = fixed pointers,
and the .git folder is where the entire system lives.

git graph - vs code extension helps u visualize the graph of Ur commits than source control.

[link]

A clear, detailed beginner-to-intermediate system design note.

[link]

Junior = burning tokens through conversation
Senior = burning tokens through code generation

Both are still burning tokens tho 🙁

When llms laughing at u.. It hurts

Not proved scientifically tho. I just shared it so u guys think about.
Sometimes let's brainstorm ideas outside coding guys.

morocco energy 🔥

docker is really complex than I tot.

I was playing around with this concept called background jobs (or multi-process apps).

Normally we have one HTTP server handling requests. But what if the request includes heavy work like video processing, image processing, generating files, or even sending emails? Keeping those tasks inside the request-response cycle can make users wait for seconds or even minutes.

The idea is simple: let the server respond quickly and move the heavy work into its own process (a worker).

For example, when a user signs up, they don't need to wait for the welcome email to be sent. The server can immediately say "Registration successful", save the email job in Redis, and a separate worker process will pick it up and send the email a few seconds later.

Same with YouTube. The uploader doesn't wait for the entire video processing to finish. The upload is accepted, and the heavy processing happens later in the background.

So basically, background jobs are about separating slow, heavy work from the normal request-response flow and letting another process handle it. Since we now have a server process and a worker process running independently, we've built a simple multi-process application.

The old generation struggled with a lack of information. The new generation struggles with too much information. Yesterday's problem was access; today's problem is focus.