DEV Community: Tala Amm

10 Skills That Every Junior Developer MUST Have in 2026

Tala Amm — Sun, 15 Mar 2026 20:27:20 +0000

Most developers spend years learning frameworks but never learn how real systems work.

I reviewed a lot of junior developer portfolios, and I keep seeing the same pattern.

Every year juniors are told the same advice:

“Learn frameworks.”
“Build more projects.”

But the reality in 2026 is different. With the insane AI tools we have, companies don’t just hire juniors to write features anymore. Writing code alone is no longer enough...

They hire juniors to:

Deploy apps
Debug production issues
Automate tasks
Connect systems together

So here are the skills that actually make juniors valuable today. 😊

1. Debugging & Code Fixing

This is probably the most underrated skill.

Many developers can write code.

Few can debug broken systems.

The developer who fixes production issues quickly is often more valuable than the one who wrote the feature.

Especially with AI and “vibe coding” becoming common, this skill is now more valuable than ever.

Being able to:

Read logs
Trace errors
Inspect APIs
Find performance issues

Makes you extremely valuable as a junior.

In many teams, juniors spend more time fixing bugs than writing features.

2. Backend API Development

Every modern product is API-driven.

Juniors should understand how APIs work and how to build them for things like:

Authentication
Validation
Pagination
Error handling

Good API design is a huge advantage.

3. SQL & Databases

Many developers treat databases like a black box.

But understanding databases helps you:

Design good schemas
Optimize queries
Debug backend problems

Basic skills should include:

Joins
Indexing
Query optimization

4. Cloud & DevOps Basics

You don’t need to be a DevOps engineer.

But every developer should know how to ship software.

Basic knowledge should include tools like:

Docker
CI/CD pipelines
GitHub Actions
Cloud basics (AWS / GCP)

Many companies actually hire juniors to:

Deploy applications
Fix pipelines
Configure servers

5. Real-Time Systems

Modern apps are increasingly real-time.

Examples include:

Chat systems
Notifications
Collaborative tools

Understanding technologies like:

WebSockets
Event systems
Message queues

is a huge plus.

6. Automation & Scripting

One of the most in-demand skills today. Developers who automate tasks save companies huge amounts of time.

Common tools include:

Python scripts
CLI tools
Automation pipelines

You can automate things like:

Report generation
Data processing
Internal tools

7. AI API Integration

AI is now part of many products. But you don’t need to train models.

Most real products just integrate APIs.

Examples:

Chatbots
Summarization tools
AI assistants
Automation with AI

Knowing how to integrate these APIs is a valuable skill.

8. Understanding System Architecture

Great developers understand how systems connect together.

Not just writing backend code, but understanding the full flow of an application.

For example:

Frontend
↓
API
↓
Queue
↓
Worker
↓
Database
↓
Deployment

Developers who understand this flow can debug and build systems much faster.

9. Web Scraping & Data Automation

Many companies need automated data collection.

Developers are often hired to build tools that:

Monitor competitors
Collect market data
Track product information

Common tools include:

Python
Puppeteer
Playwright

Many startups rely heavily on scraped data.

10. Building Small SaaS Tools

One of the best ways to grow as a developer is building small software as a service (SaaS) tools.

Examples:

Dashboards
Automation tools
Niche productivity apps

Some developers even turn these tools into small SaaS products that generate side income.

Summary

If you're a junior developer in 2026, focus on learning:

Debugging real systems
Backend API development
SQL & databases
Cloud & DevOps basics
Real-time systems
Automation & scripting
AI API integration
System architecture
Web scraping & data automation
Building small SaaS tools

Note: I'm still early in my career myself, but after many conversations with senior engineers, CTOs, and founders, the same themes keep appearing.

Final Advice

Don't just learn frameworks. Learn how systems actually work.

Developers who understand systems will always be more valuable than developers who only know frameworks.

For Junior developers:

What skills are you currently working on this year?

For Senior engineers:

What skills do you wish you had focused on when you were a junior?

How I Built a Résumé that Passed High-Tech Companies (Google, Amazon, and Microsoft)!

Tala Amm — Fri, 06 Feb 2026 21:42:22 +0000

I’m writing this post after a long break, and honestly, I feel like this story deserved to be written.

I’m still a student. A computer engineering student.
I took an intensive full-stack development course that exposed me to a wide range of software engineering topics, but at the end of the day… I was still just a student with no previous job experience.

So when I say that my very first job application ever was for a
Part-Time Student Software Engineering Internship @ Google. Yes, I know. Bold. Maybe delusional. Definitely scary.

Was I excited? Absolutely.
Was I motivated? …not really.

I genuinely thought: “Nah. Will **GOOGLE* really look at Tala’s CV? Probably not.”*

But I shot my shot anyway.

And guess what?

They replied.

After a whole month, I got an email.
An actual reply.
An invitation to do an Online Assessment.

I was shocked. Like, sit-up-straight-and-re-read-the-email shocked.

(I’ll talk about the OA and interview experience in detail in another post 👀)

I did the assessment… and honestly?
I walked away feeling like I messed everything up. I completely deleted the idea of moving forward from my head.

But then. GUESS WHAT AGAIN???

They moved me to the interview stage.

Two technical interviews.

In the end, I wasn’t selected.
And yes, that was disappointing.

But I truly believe the reason wasn’t my technical skills, it was that my CV, portfolio, LinkedIn, and overall profile lacked extracurricular activities.

The recruiter literally encouraged me to:

“Get out of the classroom. Join hackathons. Be more active in the CS community.”

And that’s exactly what I’m doing now.

What did I learn from this?

1️⃣ Never underestimate yourself

Six months ago, if someone told me:

“You’ll get Google interviews before you even graduate”

I would’ve laughed.

Even though it didn’t work out, I walked away with something priceless:
self-confidence.

My first ever application was to Google, and I reached the last possible stage for a student internship. That alone changed how I see myself.

2️⃣ This was NOT a failure, it was a huge level-up

I always thought I wasn’t good at data structures and algorithms.

Now?

I can discuss and solve most problems put in front of me
I can analyze time & space complexity
I can think about optimizations
And most importantly... I can explain my thought process clearly

Compared to two months ago?
This is a completely different version of me.

So no, this wasn’t a rejection.
This was growth.

3️⃣ I got free feedback (lol)

I now know:

Where my weak points are in DSA
How technical interviews actually work
That I broke my fear barrier from interviews
That I lack extracurricular activities, and I’m actively fixing that

A review of myself and my résumé, for free?
I’ll take it.

So… how did I build my résumé?

Back to the main topic.

As a student who had never written a résumé before, I was lucky enough to have a Senior Software Engineering mentor.

I asked them for help, and they shared their own résumé as a template.
I didn’t reinvent the wheel, I followed the structure, adapted it to my experience, and built my first real résumé from there.

Was it perfect? No.
Was it a starting point? Absolutely.

We reviewed it together, refined it, and moved on.

Applying to Google: what I did differently

Before applying, I carefully read Google’s official résumé tips
👉 https://www.google.com/about/careers/applications/how-we-hire/

I especially used their XYZ formula to describe my projects:

““Accomplished [X] as measured by [Y], by doing [Z].””

Then I:

Read the job description at least 10 times
Highlighted what they were looking for in a candidate's resume, like:
- Relevant practical experience with: web application development, Unix/Linux,...
- Interest and ability to learn other coding languages as needed.
- Please include your expected graduation date (month and year) on your resume.

And I tailored my résumé specifically for that role.

Important details:

No images
No icons
One page only
Plain, selectable text (ATS-friendly)

How I used AI (the right way)

Once I had a solid draft, I used AI as a tool, not a writer‼️.

This was the idea of the prompt I used (you can improve it):

I’m applying for a Part-Time Software Engineering BS/MS Intern, 2026 at Google.
Here is the job description: [paste it].
Here is my résumé: [paste text or upload PDF].
Please analyze the job posting carefully and suggest edits to better align my résumé with the role, without adding false experience.

I iterated. Refined. Tailored. Rewrote.

But every word was mine.
No lies. No exaggerations.
AI helped me polish, not fabricate.

Final thoughts

My résumé wasn’t magic.
It wasn’t perfect.
But it was:

Honest
Focused
Tailored
Clear
And written with intention

And it got me further than I ever imagined.

After the Google rejection, I didn’t stop. I applied to student internship roles at Amazon and Microsoft, using the same résumé structure, the same tailoring process, and the same mindset.

And yes!! I did get moved forward in both processes.

That’s when it clicked for me: this wasn’t luck. The résumé was doing its job. And more importantly, I was definitely presenting myself properly.

If you’re a student doubting whether you’re “ready”, trust me:

You don’t need to feel ready.
You just need to start.

If you have more tips, mention them in the comments!

Thanks for reading 📖💞

My Linux Journey: From Intensive Bootcamp to BZU’s Linux Lab 🐧

Tala Amm — Sun, 05 Oct 2025 11:06:24 +0000

This semester, I’m taking the Linux Laboratory course at Birzeit University, and I’m genuinely excited about it!

The last month, during my Full Stack Development program at Notre Dame University, we spent two intensive weeks diving deep into Linux commands, shell scripting, and Python programming; the same topics we’ll be covering throughout this 4-month course at Birzeit University.

Those two weeks were intense but valuable. I learned how to navigate the Linux environment efficiently, automate repetitive tasks with shell scripts, and integrate Python into practical workflows.

During that period, I created a personal Linux command cheat sheet to help me quickly recall the most useful and commonly used commands. Since the Linux Lab at BZU covers similar material, I thought it might be helpful to share it with others who are starting their Linux journey too!

🗒️ Here’s my Linux Command Cheat Sheet:
Scripting Piscine pdf

I hope it helps other students and Linux enthusiasts make their learning process smoother and more enjoyable!

Big O Notation: Examples

Tala Amm — Sun, 21 Sep 2025 20:44:49 +0000

Hi again!

Below are clear, beginner-friendly step-by-step examples for how to calculate common Big-O classes, using Go code snippets.

O(n) - Linear time

Example: linear search (find a value in an array).

// Linear search: O(n)
func linearSearch(nums []int, target int) int {
    for i:= 0 ; i < len(nums) ; i++ {     // runs up to n times
        if nums[i] == target {         // constant-time comparison each iteration
            return i
        }
    }
    return -1
}

Step-by-step reasoning

n is the size of input which is length of nums.
In the worst case (target not present or last element), the for loop executes n iterations.
Each iteration (inside the loop) does O(1) work (compare and maybe assign).
O notation is O(1*n) = O(n)

O(log n) - Logarithmic time

Example: binary search in a sorted slice.

// Binary search: O(log n)
func binarySearch(nums []int, target int) int {
    lo, hi := 0, len(nums)-1
    for lo <= hi {
        mid := lo + (hi-lo)/2          // cut range in half
        if nums[mid] == target {
            return mid
        } else if nums[mid] < target {
            lo = mid + 1
        } else {
            hi = mid - 1
        }
    }
    return -1
}

Step-by-step reasoning

Each loop iteration halves the search range.
After k iterations the remaining range size is about n / 2^k.
It stops when n / 2^k ≤ 1 → 2^k ≥ n → k ≥ log₂(n).
So number of iterations ~ ⌈log₂ n⌉ → O(log n).
Note: base of the logarithm doesn't matter for Big-O (log₂, log₁₀, ln are all Θ(log n)).

O(n log n) - Typical of efficient sorts

Example: merge sort (divide & conquer).

// Merge sort: O(n log n)
func mergeSort(a []int) []int {
    if len(a) <= 1 {
        return a
    }
    mid := len(a) / 2
    left := mergeSort(a[:mid])
    right := mergeSort(a[mid:])
    return merge(left, right)
}

func merge(left, right []int) []int {
    res := make([]int, 0, len(left)+len(right))
    i, j := 0, 0
    for i < len(left) && j < len(right) {
        if left[i] <= right[j] {
            res = append(res, left[i])
            i++
        } else {
            res = append(res, right[j])
            j++
        }
    }
    // append remaining
    res = append(res, left[i:]...)
    res = append(res, right[j:]...)
    return res
}

Step-by-step reasoning

Recurrence: T(n) = 2·T(n/2) + O(n) (because we sort two halves then merge in O(n)).
Using Master Theorem or level-by-level cost:
- Level 0 (root): cost O(n) to merge at that level,
- Level 1: two merges of size n/2 → total O(n),
- Level 2: four merges of size n/4 → total O(n),
- ... there are about log₂(n) levels.
Total ≈ n * (log₂(n) + 1) → O(n log n).

O(n²) - Quadratic time

Example: printing every pair (nested loops), or naive pairwise compare.

// Print every ordered pair: O(n^2)
func printPairs(nums []int) {
    n := len(nums)
    for i := 0; i < n; i++ {
        for j := 0; j < n; j++ {
            // constant-time work inside
            _ = nums[i] + nums[j]  // pretend we do O(1) work
        }
    }
}

Step-by-step reasoning

Outer loop runs n times.
For every outer iteration, inner loop runs n times.
Total iterations = n * n = n².
Drop constants and lower-order terms → O(n²).

O(2ⁿ) - Exponential time (base 2)

Example: generate all subsets (power set). Each element either included or excluded → 2 choices per element.

// Generate all subsets: O(2^n)
func subsets(nums []int) [][]int {
    res := [][]int{}
    var helper func(int, []int)
    helper = func(i int, cur []int) {
        if i == len(nums) {
            tmp := append([]int(nil), cur...)
            res = append(res, tmp)
            return
        }
        // exclude current
        helper(i+1, cur)
        // include current
        helper(i+1, append(cur, nums[i]))
    }
    helper(0, []int{})
    return res
}

Step-by-step reasoning

At each index i you branch into two calls (include / exclude).
Tree depth = n, branching factor = 2 → number of leaves = 2ⁿ.
You do at least one constant amount of work per leaf (plus cost to build each subset).
Total work ≈ c · 2ⁿ → O(2ⁿ).
Note: Some recursive exponential algorithms (like naive Fibonacci) produce growth ~φⁿ where φ ≈ 1.618; often people use O(2ⁿ) to describe general exponential growth class.

O(n!) - Factorial time

Example: generate all permutations of n distinct elements.

// Generate all permutations: O(n!)
func permutations(nums []int) [][]int {
    a := make([]int, len(nums))
    copy(a, nums)
    res := [][]int{}
    var helper func(int)
    helper = func(k int) {
        if k == len(a)-1 {
            tmp := append([]int(nil), a...)
            res = append(res, tmp)
            return
        }
        for i := k; i < len(a); i++ {
            a[k], a[i] = a[i], a[k] // swap
            helper(k + 1)
            a[k], a[i] = a[i], a[k] // swap back
        }
    }
    helper(0)
    return res
}

Step-by-step reasoning

Number of permutations of n distinct items is n! = n × (n−1) × (n−2) × ... × 1.
The recursion produces all n! permutations.
If you also consider the cost to copy/print each permutation (of length n) then total time is O(n · n!) because for each of the n! permutations we may spend O(n) to copy or output it.
But the combinatorial explosion is already n!, so algorithms with factorial behavior are impractical even for small n (n = 10 → 3,628,800 permutations).

O(1) - Constant Time

Example: Get the first element of a slice

// O(1) - accessing the first element
func getFirst(nums []int) int {
    if len(nums) == 0 {
        return -1
    }
    return nums[0] // single operation
}

Step-by-step reasoning

Let n = len(nums).
The function performs:

One check: len(nums) == 0 → O(1)
One index access: nums[0] → O(1)
One return → O(1)
1. Total operations = 3 (or some small constant c). Does NOT depend on n.
2. Therefore, runtime = O(1) — it stays constant even if nums has 1 element or 1 million elements.

Key takeaway: Constant time algorithms do a fixed number of steps regardless of input size.

Quick rules / takeaways (for beginners)

Drop constants: c·n → O(n). 5n² → O(n²).
Drop lower-order terms: (n² + n)/2 → O(n²).
Log base doesn't matter: log₂ n, log₁₀ n, ln n are all Θ(log n).
Multiplicative rule: nested loops (n × n) → O(n²).
Additive rule: if you do O(n) then O(n²), total is O(n + n²) → O(n²) (keep the dominant term).
Recursive divide & conquer often gives O(n log n) or O(log n) depending on splitting and merging (use Master Theorem or count cost per level).
Output-size matters: generating all combinations/subsets/permutations means runtime grows at least as fast as the number of outputs (2ⁿ, n!, ...).

Big O Notation pt.1: Time Complexity

Tala Amm — Sun, 21 Sep 2025 18:36:43 +0000

Hello again 🙋🏻‍♀️
If you’re starting your programming journey, you’ve probably heard the term Big O notation or Time complexity of an algorithm. You may have also wondered why a solution is better than another, though they both do the same thing! At first, it might look like some scary math formula but don’t worry! In this post, we’ll break it down into simple words and examples so you can understand exactly what it means and why it matters.

This post is part one of a two-part series:

Part 1 (this post): Time Complexity
Part 2 (next post): Space Complexity

📑 Table of Contents

What is Big O Notation?
Why is Big O Notation Important?
How to Find Big O
Properties of Big O
Common Time Complexities
Big O, Big Omega, and Big Theta
Practice Exercises
Resources

What is Big O Notation?

Big O time is the language and metric we use to describe the efficiency of algorithms. Not understanding, not only will leave you judged harshly for not understanding it, but also you will struggle to judge your algorithms and solutions for coding problems.

Why is Big O Notation Important?

Big O notation is important for several reasons:

It provides a way to compare the performance of different algorithms and data structures, and to predict how they will behave as the input size increases.
It helps analyze the efficiency of algorithms.
It provides a way to describe how the runtime or space requirements of an algorithm grow as the input size increases.
Allows programmers to compare different algorithms and choose the most efficient one for a specific problem.
Helps in understanding the scalability of algorithms and predicting how they will perform as the input size grows.
Enables developers to optimize code and improve overall performance.

How to Find Big O

Ignore the lower order terms and consider only highest order term.
Ignore the constant associated with the highest order term.

Properties of Big O

Reflexivity: For any function f(n), f(n) = O(f(n)).
Transitivity: If f(n) = O(g(n)) and g(n) = O(h(n)), then f(n) = O(h(n)).
Constant Factor: For any constant c > 0 and functions f(n) and g(n), if f(n) = O(g(n)), then cf(n) = O(g(n)).
Sum Rule: If f(n) = O(g(n)) and h(n) = O(k(n)), then f(n) + h(n) = O(max( g(n), k(n) ) When combining complexities, only the largest term dominates.
Product Rule: If f(n) = O(g(n)) and h(n) = O(k(n)), then f(n) * h(n) = O(g(n) * k(n)).
Composition Rule: If f(n) = O(g(n)), then f(h(n)) = O(g(h(n))).

Common Time Complexities

Name	Notation	Meaning	Examples
Constant	O(1)	Runtime is constant regardless of input size	Accessing an array element by index, Stack push/ pop, if statement
Logarithmic	O(log n)	After each iteration, input size shrinks	Binary Search
Linear	O(n)	Runtime grows linearly with the size of input	Linear Search
Super Linear	O(n*log n)	Input of size n is processed across log n levels (a shrinking for loop idea)	Quick Sort, Heap Sort, Merge Sort
Polynomial	O(n^k)	ex: O(n^2) Runtime is proportional to the square of the input size	Strassen’s Matrix Multiplication, Bubble Sort, Selection Sort, Insertion Sort, Bucket Sort
Exponential	O(k^n)	ex: O(2^n) Runtime doubles with each addition to the input data set	Tower of Hanoi
Factorial	O(n!)	Runtime grows factorially with the size of the input	Determinant Expansion by Minors, Brute force Search algorithm for Traveling Salesman Problem

Graphs

If we plot the most common Big O notation examples, we would have graph like this:

Mathematical Examples of Runtime Analysis

Below table illustrates the runtime analysis of different orders of algorithms as the input size (n) increases.

O notation	Runtime (ex1)	Runtime (ex2)
n	10	20
log(n)	1	2.996
n * log(n)	10	59.9
n^2	100	400
2^n	1024	1048576
n!	3628800	2.432902e+1818

Big O, Big Omega, and Big Theta

Notation	Explanation
Big O (O)	Describes the upper bound of the algorithm's running time. (It describes the worst case scenario of an input) Most commonly used when analyzing time complexity
Big Ω (Omega)	Describes the lower bound of the algorithm's running time. (*It describes the best case scenario of an input*)
Big θ (Theta)	Describes a tight bound, meaning both the upper and lower bounds are the same order. (*When the best and worst scenarios are the same*) It represents the asymptotically exact growth rate.

Note: Average case is often analyzed separately and doesn’t always equal Θ.

Diagram for Big O, Big Omega, Big Theta

Ω(n) → lower bound curve (algorithm will never be faster than this).
O(n) → upper bound curve (algorithm will never be slower than this).
Θ(n) → sits between them when both bounds match.

Practice Exercises

Check out the following Blog that explain how to calculate time complexity for most common scenarios in details: Big O Notation Examples

Also, I would really recommend checking these exercises to test your knowledge: Big O Notation Exercises - GitHub

Resources

Cracking the Coding Interview Book
Big O Notation Tutorial - A Guide to Big O Analysis - GeeksforGeeks

Thanks for reading!

Happy Coding!💻😀

Will GPT-5 & Future AI Replace Junior Developers? Is Learning to Code Still Worth It?

Tala Amm — Sat, 09 Aug 2025 11:07:18 +0000

“GPT-5 can build a functional website in seconds. Is that the end of the junior developer… or the start of a completely new role?”

1. The Reality: AI as an Augmenter, Not a Replacer (For Now)

Every major AI release sparks the same debate: “Will it take my job?”
With GPT-5 and other apps ability to generate full-stack apps in one click, it’s tempting to think the answer is yes, especially for junior developers.

But the numbers tell a more nuanced story:

GitHub Copilot users reported finishing tasks 56% faster
Google’s internal AI experiments showed a 21% boost in developer productivity
Real-world teams report 30–50% time savings on repetitive tasks like refactoring and documentation

And adoption is exploding:
Nearly half of all developers are already using AI tools, and in some companies, the number is closer to 92%.

2. Where AI Still Struggles

Yes, GPT-5 can code, but it still falls short in:

Business context - AI doesn’t intuitively “get” the purpose behind features
Architecture decisions - It can suggest solutions, but not necessarily the right one for your system
Critical thinking & creativity - It can remix ideas, but human originality still sets projects apart
Reliability - AI may still produce flawed code in complex projects, that might slow teams down instead of speeding them up

In fact, a METR study found that for some senior devs, reviewing and fixing AI code made them 19% slower. Read more here

3. What Industry Leaders Are Saying

Goldman Sachs economists warn that Gen Z tech workers ~especially juniors~ are at the highest risk from AI-driven automation
GitHub’s CEO put it bluntly: “Embrace AI or get out”
Bill Gates and OpenAI’s Bret Taylor agree: AI changes the landscape, but deep programming skills, systems thinking, and human judgment remain irreplaceable

4. The Junior Developer’s Role is Evolving

Instead of writing every line of code from scratch, juniors may soon:

Act as curators of AI-generated code, ensuring it meets quality and business goals
Work more like product thinkers, shaping what AI builds instead of just building it themselves
Learn AI prompt engineering, code review at scale, and system integration

We’re not moving toward fewer skills, just different skills.

5. So… Should You Still Learn to Code in 2025?

Absolutely!! but with a twist.

Takeaway	Why It Matters
Learn core coding skills	You’ll need to understand AI output deeply enough to trust (or reject) it
Focus on system design & architecture	AI can code modules; humans still design the blueprint
Add AI literacy to your toolbox	Prompting, reviewing, and integrating AI into workflows is the new normal
Build soft skills	Collaboration, empathy, and creativity will never be automated

Final Thoughts

Learning to code in the GPT-5 era is not like learning to drive a horse carriage after cars were invented.
It’s more like learning to drive in a world where autopilot exists. You still need to know how to take the wheel when things get tricky. Watch This

The future isn’t AI replacing developers, it’s developers who understand AI replacing those who don’t.

💬 What do you think?
Are junior dev roles truly at risk, or are we just entering a new golden age of human-AI collaboration?

GPT-5 Is Here: What It Really Means for Junior Developers (Like Me)

Tala Amm — Fri, 08 Aug 2025 19:35:42 +0000

Yesterday, on August 7th, 2025, OpenAI released GPT‑5, and I've been exploring it ever since. As a junior developer, I’ve used earlier versions to help me learn, write and debug code better. But GPT‑5 genuinely changes the game.

This post isn’t a generic AI hype piece, I want to walk you through what’s actually new in GPT‑5, what’s improved, and how I (and other early-career developers) can really benefit from it right now.

1. A Smarter Brain with “Thinking Mode”

GPT‑5 introduces a new internal design where it can switch between two reasoning engines:

One for fast, lightweight responses
Another for deep, multi-step reasoning (it uses it when needed or when prompted with something like: “Think hard about this”)

Before GPT‑5, I often had to rephrase my prompts multiple times to get the model to really "think". Now, GPT‑5 does it automatically or on request.

Why it matters: When I’m stuck on a logic bug or trying to understand a concept deeply, I don’t just want an answer; I want reasoning. GPT‑5 gives me both.🫶

2. Improved Code Generation. Especially for Front-End

GPT‑5 isn’t just better at generating code, it’s more aware of structure, layout, and intent. Especially when it comes to front-end code (HTML, CSS, JS, Vue, React), the output is cleaner, more semantically correct, and closer to production-ready.

Before: We’d often get div soup or have to rework the styling logic manually.
Now: It understands component hierarchy, responsive layout, and even accessibility hints.

Why it matters: As someone still learning the ropes of clean UI/UX code, this accelerates my understanding by showing me better examples than ever before.🫶

3. “Vibe Coding” and Canvas Preview

This one blew my mind.

GPT‑5 (paired with OpenAI’s Canvas) lets us describe what we want, like: “a minimal to-do app with dark mode and animations” and it starts building a real UI with live previews. This isn't just generating code... it’s collaborative prototyping.

Why it matters: I learn faster by seeing and tweaking. Watching GPT‑5 create UI flows in real-time is like pair programming with a senior dev who also happens to be a designer and product thinker.🫶🤯

4. Explains Code Like a Mentor Would

GPT‑5 adapts explanations to our current knowledge level. If I say “explain like I’m new to JavaScript closures”, I get a beginner-friendly breakdown. If I ask for “the performance tradeoffs between useMemo and useCallback”, I get a much deeper dive.

Before: GPT sometimes gave generic or overly simplified responses.
Now: It feels like it's actually teaching, not just answering.

Why it matters: No one wants just to copy code. I want to understand it, how and why. GPT‑5 makes that learning curve smoother and more tailored.🫶

5. More Reliable: Fewer Hallucinations, More Honesty

OpenAI claims GPT‑5 hallucinates 45% less than GPT‑4o, and in my current short experience, that's true. It’s also better at admitting when it doesn’t know or when a question needs clarification.

Before: I had to double-check almost everything it generated.
Now: I still review the code (always should), but I trust the logic more.

Why it matters: As a junior dev, I don’t always know what's right or wrong, so having a more reliable assistant reduces time wasted on debugging misleading suggestions.🫶

6. Developer-Personality Presets

GPT‑5 includes four customizable response styles:

Listener – calm, reflective responses
Robot – concise, no-fluff logic
Nerd – super-detailed and technical
Cynic – sarcastic, for fun debugging

I tried the “Nerd” mode today and actually found it helpful! It gave me ultra-detailed answers, just as I wanted, with citations and theory.

Why it matters: Sometimes I need a mentor, other times I need a debugging partner. Now I have both all the time.🫶

7. It’s Everywhere Now — Not Just in ChatGPT

If you use GitHub Copilot, Cursor ,VSCode, Microsoft 365, or even Azure AI Studio, GPT‑5 is integrated or rolling out soon.

Why it matters: I can use GPT‑5 beyond side chats. It becomes part of my IDE, my editor, my docs, and my workflows.🫶

Final Thoughts

As someone still navigating the early stages of my developer journey, GPT‑5 isn’t just a tool. It’s a tutor, pair programmer, documentation companion, and sometimes even a confidence booster.

If you’re a junior dev like me: Don’t just use GPT‑5 to get answers. Use it to understand, ask better questions, and build faster.

We finally have a model that doesn’t just “respond”, it really helps you grow. Use it wisely.

Have you tried GPT‑5 yet? I’d love to hear how you’re using it in your learning or coding workflow.

Let’s keep learning together.

What Is a .env File and Why Should You Use It?

Tala Amm — Fri, 01 Aug 2025 06:01:01 +0000

In modern development, .env files are essential for managing environment-specific configuration. Whether you're building a Node.js backend, a Python app, or a full-stack project, you’ve probably seen a .env file somewhere. But what exactly is it?

What Is a `.env` File?

A .env file (short for environment) is a plain text file where you store environment variables as key-value pairs

These values are not hardcoded into your application, which means:

Your config stays clean
You can change settings without touching your code
Sensitive data stays out of your Git repo

What Should You Store in `.env`?

API keys
Database URLs
Secret tokens (like JWT secrets)
Environment flags (e.g., NODE_ENV=production)
Any config that varies by environment

How to Use `.env` in Your Project🛠️

In Node.js

Create a .env file in the root of your project, save in it your secret variables like a key-value pair:

PORT=3000
DB_HOST=localhost
JWT_SECRET=yourSuperSecretKeyHere

Install the dotenv package, in your terminal run:

npm install dotenv

Load the .env File in Your Code At the top of your main file (like server.js or index.js), add this line:

require('dotenv').config();

Now you can access your environment variables using:

const PORT = process.env.PORT;
const SECRET = process.env.JWT_SECRET;

Wait, What’s `process.env`? 🤔

In Node.js, process.env is a built-in object that gives you access to environment variables.

When you write process.env.JWT_SECRET, you're saying:

"Give me the value of the environment variable named JWT_SECRET."

It's how your app knows which port to use, what database to connect to, or what secret to use for signing tokens, without hardcoding them into your source files.

🚫 Don’t Commit `.env` to Git!

Always add it to your .gitignore:

# .gitignore
.env

Summary

.env files store environment variables
Keep secrets out of your code
Use libraries like dotenv to access them
Never commit .env to version control

Generate a Random String for a JWT Secret

Tala Amm — Thu, 31 Jul 2025 05:55:51 +0000

How to Generate a Random String for a JWT Secret (Safely!)

When working with JWT (JSON Web Tokens) in your authentication system, one of the most important things is your JWT secret key. This is the string used to sign and verify the token, like a password for your server to trust the token.

So, how do you generate a good, secure one?

🧠 What Makes a Good JWT Secret?

Long (at least 32+ characters)
Random (not guessable, not a real word)
Includes letters, numbers, and symbols
Stored securely (like in .env files)

🔧 Generate One Using Code

Bash terminal (Most Recommended)

openssl rand -hex 64

Node.js (JavaScript)

// Generate a 64-character random string
const crypto = require('crypto');
console.log(crypto.randomBytes(64).toString('hex'));

Python

import secrets
print(secrets.token_hex(64))

🛡️ Where Do You Store It?

In a .env file:

JWT_SECRET=9f7a41a6e23... (your generated key)

And in your code (JavaScript):

const jwtSecret = process.env.JWT_SECRET;

What NOT to Do ❌

Don't hard-code your secret in the codebase
Don't commit .env files to GitHub

✅ Final Tip

Regenerate your secret if you suspect a leak. Any old tokens will become invalid; which is exactly what you want in that case.

Regular Expressions (REGEX): A Quick Refresher

Tala Amm — Thu, 31 Jul 2025 05:47:40 +0000

If you've ever wanted to find, match, or validate patterns in text, phone numbers, passwords, etc.; then regular expressions are your best friend.

✅ What is a Regular Expression?

A regular expression, or regex, is a powerful pattern-matching language used to search, extract, or validate text based on specific patterns.

Think of it like a supercharged Ctrl+F, but smarter.

💡 Why Use Regex?

Validate emails, phone numbers, passwords, URLs
Search or replace specific text patterns
Clean or extract data from messy text
Apply rules flexibly in a single line

🛠️ What Does a Regex Look Like?

Here’s a simple one:

/^[A-Z][a-z]+$/

Breakdown:

^ → Start of string
[A-Z] → One uppercase letter
[a-z]+ → One or more lowercase letters
$ → End of string

✅ Matches: John, Alice
❌ Doesn’t match: john, ALICE, 123

📚 Common Regex Symbols

Symbol	Meaning
`.`	Any character except newline
`*`	Zero or more of previous item
`+`	One or more
`?`	Zero or one
`\d`	Any digit (0–9)
`\w`	Any word character (a-z, A-Z, 0-9, _)
`[]`	Match one of characters inside
`()`	Grouping
`^` / `$`	Start / end of string

🧪 Examples

✅ Match a phone number (IL mobile):

/^(\+972|00972|0)5[02345689]\d{7}$/

The string shall start with (+972 OR 00972 OR 0) followed by a 5 then one of these numbers [02345689] then have any 7 digits.
Supports local (05X...) and international formats (+9725X...)
Validates mobile prefixes like 050, 052, 054, etc.

✅ Match an email:

/^[\w.-]+@[a-zA-Z]+\.[a-zA-Z]{2,}$/

Breakdown:

Part	Meaning
`^`	Anchors the match to the start of the string
`[\w.-]+`	Matches one or more characters that are: - `\w`: word characters (letters, digits, underscore) - `.`: dot (.) - `-`: dash (-) ⚠️ This is the username before `@`
`@`	Matches the literal `@` symbol
`[a-zA-Z]+`	Matches one or more letters, uppercase or lowercase 📍 This is the domain name like `gmail`, `yahoo`, etc.
`\.`	Escaped dot, because `.` means "any character" in regex. Here we want a literal dot, like in `.com` or `.org`
`[a-zA-Z]{2,}`	Matches 2 or more letters for the domain extension like: `com`, `net`, `io`, `co`, etc.
`$`	Anchors the match to the end of the string

✅ Example Matches:

tala.dev@gmail.com
example-world_123@dev.to.org
a@b.co

🧑‍💻 Which Languages Support Regex?

Regex is supported in almost every major programming language:

Language	Regex Support
JavaScript	✅ Built-in (`RegExp`)
Python	✅ `re` module
Java	✅ `java.util.regex`
PHP	✅ `preg_match()`
Ruby	✅ Native
Go	✅ `regexp` package
Rust	✅ `regex` crate
Bash	✅ grep/sed/awk

⚠️ Gotchas

Regex can be powerful, but hard to read.
Overuse can reduce code readability.
Always test your regex with tools like regex101.com or RegExr.

Monolithic VS. Microservices

Tala Amm — Fri, 25 Jul 2025 08:02:13 +0000

It's nice when everything is manageable at the early stage of an app. One codebase. One team. One deploy. Boom💥done.

But as your app grows, your challenges grow.

At that point we get teams asking: "... Should we be monolithic or go Microservices ".

What is a Monolithic Architecture?

A monolithic application is built as one big unit. All your app’s features (authentication, database access, UI, payments, etc.) are packed into one codebase and deployed together.

Think of it like a giant LEGO block. Easy to build at first, but tough to reshape later.

Pros✅:

Simple to develop and deploy.
Easier debugging and testing.
One source of truth.

Cons❌:

Hard to scale specific parts.
One small bug can crash the whole app.
Slow updates. You have to redeploy everything, even for tiny changes.

What Are Microservices?

In a microservices architecture, your app is split into independent services, each doing only one job. Like: User service, payment service, notification service; they interact using APIs.

Pros✅:

Teams can work independently.
Easier to scale specific features.
Faster deployments (change just one service!).

Cons❌:

More moving parts = more complexity.
Requires strong communication between services.
Harder to test end-to-end.

Imagine💬:

Monolithic:
Like one big office where everyone (HR, Security, Accounting) works in the same room and shares the same desk.
If one team wants to update their process, the whole office has to change.
Microservices:
Like a company with separate departments (HR, Security, etc.), each in its own office with its own staff and tools.
They communicate by emails or phone calls (APIs).
Each department can upgrade or fix issues independently without disturbing the others.

The Netflix Story📺

Since Netflix was growing rapidly back in 2009; their monolithic architecture could not keep up with that. So, they pioneered a move to microservices (even before the term “microservices” existed!).

Today they run over 1,000 microservices, deploy code thousands of times a day, and deliver smooth streaming to millions.

So... Monolith or Microservices?

Feature	Monolith	Microservices
Codebase	One big app	Many small services
Deployments	All together	Independently
Scaling	Whole app	Per service
Speed (Early On)	Faster to build	Slower to start
Speed (Later On)	Slower to grow	Faster & more flexible

When to use a Monolith:

You’re a small team or a new project.
You want to build and iterate quickly.
You don’t have infrastructure complexity yet.

When to Consider Microservices:

Your app is growing fast.
Teams need independence to move faster.
You want to scale parts of your app separately (e.g., auth or payments).

Final Thoughts

Microservices aren’t better. They’re just better when scale demands it. For many teams, starting with a monolith makes perfect sense, and when things get too tangled, that’s when microservices can shine.

Start small. Grow wisely. And always build for the future, but don’t over-engineer for a future that isn’t here yet. 😉

JWT, JSON & Tokens in 4 minutes

Tala Amm — Wed, 23 Jul 2025 03:25:00 +0000

What is a JWT?

JWT stands for (JSON Web Token) defines for us a way to transfer information securely between endpoints as a JSON object.

What is JSON?

JSON (JavaScript Object Notation) is a lightweight format for storing and exchanging data. It looks like regular JavaScript objects; but it’s not limited to JavaScript! Almost every programming language understands JSON.

Here’s what a small JSON file might look like:

{
  "name": "Tala",
  "age": 32,
  "isStudent": true
}

It’s just a collection of key-value pairs (like a labeled list).

Why is JSON so popular?

JSON is the most common way to send and receive data between the frontend and the backend; for a few simple reasons:

✅ It’s language-independent: Whether you’re using JavaScript/Vue/React on the frontend, or Go/Python/Ruby on the backend; they all know how to read and write JSON.
✅ It’s perfect for APIs: When a user fills a form on a website, the data can be turned into JSON and sent to the backend server to be processed, saved, or validated.

This is exactly why JWT (JSON Web Tokens) are built using JSON — they’re easy to generate, send, and decode across systems.

🔑 What is a Token?

A token is a small piece of data used to prove that someone is allowed to do something — like accessing a private page, calling an API, or staying logged in.

Think of a token like a digital access card. 🪪
When you log in to a website, the server gives you this "card" (the token). Instead of logging in again and again, you just show your token — and if it's valid, you're allowed in.

🛠️ JWT In web development:

When a user logs in, the server checks their email/password.
If it’s correct, the server creates a token (like a JWT) and sends it back.
The frontend (browser/app) stores the token and uses it with future requests.
The backend verifies the token each time before allowing access to protected routes or actions.

Tokens help keep your app stateless, secure, and scalable — and JSON Web Tokens (JWTs) are one of the most popular ways to implement them.

What is the structure of a JWT?

A JWT (JSON Web Token) is just a string made of three parts, separated by dots:

xxxxx.yyyyy.zzzzz

1️⃣ Header

The header is a small JSON object that describes the token. It usually includes:

{
  "alg": "HS256",
  "typ": "JWT"
}

alg = which algorithm is used to sign the token (like HS256)
typ = token type, usually "JWT"

This JSON gets encoded in Base64Url and becomes the first part of the token.

2️⃣ Payload

The payload contains the data (claims) you want to include. Usually info about the user. Example:

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

There are 3 types of claims:

Registered: standard ones like exp (expires), iss (issuer), sub (subject)
Public: custom but shared publicly (to avoid conflicts)
Private: fully custom, shared between your frontend and backend

This also gets Base64Url encoded and becomes the second part of the token.

🚨 Important: The payload is not encrypted, it’s just encoded. Anyone can read it, so don’t put passwords or secret info inside.

3️⃣ Signature

This is what makes JWTs secure. To create it, we take:

The encoded header
The encoded payload
A secret key
The algorithm (like HS256)

Then we generate a signature using:

HMACSHA256(
  base64UrlEncode(header) + "." + base64UrlEncode(payload),
  secret
)

This makes sure the token hasn’t been changed. If someone tries to change it, the signature will no longer match.

⚠️ Example of Tampering

Original payload:

{ "username": "tala", "age": 22 }

The signature was created based on that.

But someone changes the payload to:

{ "user_id": "999", "password": "123456" }

Now the signature doesn’t match; the server will reject the token.
✅ This is how JWTs detect if someone has tampered with the data.

Final Result

The output is three Base64-URL strings separated by dots that can be easily passed in HTML and HTTP environments.

The following shows a JWT that has the previous header and payload encoded, and it is signed with a secret.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiYWRtaW4iOnRydWUsImlhdCI6MTUxNjIzOTAyMn0.KMUFsIDTnFmyG3nMiGM6H9FNFUROf3wh7SmqJp-QV30

Can Anyone Decode it? 😁 Write in the comments below the decoded data⬇️

HINT: Signing algorithm is HS256.

Sure! Here's a short and clear version:

🟡 When to Use JWTs

Authorization: After login, the JWT is sent with each request to access protected routes or services. It's widely used in Single Sign-On (SSO).
Data Sharing: JWTs can securely share info between systems. Their signature ensures the data is authentic and hasn't been changed.
Stateless: No need to store session data on the server — all needed info is inside the token.

Validation vs. Verification in JWT💯

Validation checks if the token is correctly built:
- Does it have 3 parts (header, payload, signature)?
- Is it using valid formatting (Base64)?
- Does it include valid claims (like exp, iat, etc.)?
Verification checks if the token is trustworthy:
- Is the signature correct (wasn’t changed or faked)?
- Does it come from the expected issuer?
- Is it meant for the right audience?

In short:
🧩 Validation = Is the token well-formed and valid?
🔐 Verification = Is the token real and untampered?

Most systems do both to stay secure.

DEV Community: Tala Amm

10 Skills That Every Junior Developer MUST Have in 2026

1. Debugging & Code Fixing

2. Backend API Development

3. SQL & Databases

4. Cloud & DevOps Basics

5. Real-Time Systems

6. Automation & Scripting

7. AI API Integration

8. Understanding System Architecture

9. Web Scraping & Data Automation

10. Building Small SaaS Tools

Summary

Final Advice

For Junior developers:

For Senior engineers:

How I Built a Résumé that Passed High-Tech Companies (Google, Amazon, and Microsoft)!

They replied.

What did I learn from this?

1️⃣ Never underestimate yourself

2️⃣ This was NOT a failure, it was a huge level-up

3️⃣ I got free feedback (lol)

So… how did I build my résumé?

Applying to Google: what I did differently

How I used AI (the right way)

Final thoughts

My Linux Journey: From Intensive Bootcamp to BZU’s Linux Lab 🐧

Big O Notation: Examples

O(n) - Linear time

O(log n) - Logarithmic time

O(n log n) - Typical of efficient sorts

O(n²) - Quadratic time

O(2ⁿ) - Exponential time (base 2)

O(n!) - Factorial time

O(1) - Constant Time

Quick rules / takeaways (for beginners)

Big O Notation pt.1: Time Complexity

📑 Table of Contents

What is Big O Notation?

Why is Big O Notation Important?

How to Find Big O

Properties of Big O

Common Time Complexities

Graphs

Mathematical Examples of Runtime Analysis

Big O, Big Omega, and Big Theta

Diagram for Big O, Big Omega, Big Theta

Practice Exercises

Resources

Will GPT-5 & Future AI Replace Junior Developers? Is Learning to Code Still Worth It?

1. The Reality: AI as an Augmenter, Not a Replacer (For Now)

2. Where AI Still Struggles

3. What Industry Leaders Are Saying

4. The Junior Developer’s Role is Evolving

5. So… Should You Still Learn to Code in 2025?

Final Thoughts

GPT-5 Is Here: What It Really Means for Junior Developers (Like Me)

1. A Smarter Brain with “Thinking Mode”

2. Improved Code Generation. Especially for Front-End

3. “Vibe Coding” and Canvas Preview

4. Explains Code Like a Mentor Would

5. More Reliable: Fewer Hallucinations, More Honesty

6. Developer-Personality Presets

7. It’s Everywhere Now — Not Just in ChatGPT

Final Thoughts

What Is a .env File and Why Should You Use It?

What Is a .env File?

What Should You Store in .env?

How to Use .env in Your Project🛠️

In Node.js

Wait, What’s process.env? 🤔

🚫 Don’t Commit .env to Git!

Summary

Generate a Random String for a JWT Secret

How to Generate a Random String for a JWT Secret (Safely!)

🧠 What Makes a Good JWT Secret?

🔧 Generate One Using Code

Bash terminal (Most Recommended)

Node.js (JavaScript)

Python

What Is a `.env` File?

What Should You Store in `.env`?

How to Use `.env` in Your Project🛠️

Wait, What’s `process.env`? 🤔

🚫 Don’t Commit `.env` to Git!