Why global state is dangerous in PHP - Visual Breakdown

Concept Flow - Why global state is dangerous in PHP

Start: Global variable set

↓

Function A reads/modifies global

↓

Function B reads/modifies global

↓

Unexpected changes in global

↓

Hard to track bugs

↓

Program behaves unpredictably

Global variables can be changed anywhere, causing unexpected results and bugs that are hard to find.

Execution Sample

PHP

<?php
$counter = 0;
function increment() {
  global $counter;
  $counter++;
}
increment();
increment();
echo $counter;
?>

This code uses a global variable $counter that a function increments twice, showing how global state changes.

Execution Table

Step	Action	Global $counter Value	Output
Start	Initialize $counter = 0	0
Call increment() #1	Increment $counter by 1	1
Call increment() #2	Increment $counter by 1	2
Echo $counter	Print current $counter value	2	2

💡 Program ends after printing the final value of $counter which is 2

Variable Tracker

Variable	Start	After increment() #1	After increment() #2	Final
$counter	0	1	2	2

Key Moments - 2 Insights

Why can changing a global variable in one function affect another function unexpectedly?

Because both functions use the same global variable, changes in one affect the shared state seen by the other, as shown in steps 2 and 3 of the execution_table.

Why is it hard to find bugs when using global variables?

Because any part of the code can change the global variable at any time, making it unclear where a wrong value came from, as the global $counter changes in multiple places.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of $counter after the first call to increment()?

A 1

B 0

C 2

D Undefined

💡 Hint

Check the 'Global $counter Value' column at step 'Call increment() #1'

At which step does the program output the value 2?

A Start

B Echo $counter

C Call increment() #1

D Call increment() #2

💡 Hint

Look at the 'Output' column in the execution_table

If we remove the 'global' keyword inside increment(), what happens to $counter?

A $counter increments globally as before

B Error: undefined variable

C $counter inside function is local and global $counter stays 0

D Program crashes

💡 Hint

Without 'global', the function uses a local variable, so global $counter does not change (see variable_tracker)

Concept Snapshot

Global variables in PHP can be accessed and changed anywhere using the 'global' keyword.
This shared state can cause unexpected bugs because changes in one place affect others.
Tracking bugs is hard since any function can modify the global variable.
Avoid globals for safer, predictable code by passing variables as parameters instead.

Full Transcript

This example shows a global variable $counter initialized to 0. Two calls to the function increment() increase $counter by 1 each time using the global keyword. The execution table traces each step: starting at 0, after first increment it becomes 1, after second increment it becomes 2, and finally the program prints 2. The variable tracker shows $counter changing from 0 to 2 across calls. Beginners often get confused because changes in one function affect the global state seen by others, making bugs hard to find. The quiz asks about $counter values at different steps and what happens if the global keyword is removed. The key lesson is that global state is dangerous because it can be changed anywhere, causing unpredictable behavior and making debugging difficult.