PHP 4: A Historical Overview

PHP 4 was one of the most significant milestones in the history of web development.

Released on May 22, 2000, it transformed PHP from a simple scripting tool into a powerful, production-ready language used by millions of developers around the world.

This is the story of where it came from, what it introduced, and why it mattered so much.

Background: Before PHP 4

Before PHP 4 arrived, developers were working with PHP 3, which was functional but had serious limitations.

PHP 3 lacked a proper engine underneath it. Each script was parsed and executed in a slow, inconsistent manner.

Large applications were difficult to build. Performance was a constant concern. Object-oriented programming support was minimal and unreliable.

The web was growing at an enormous pace in the late 1990s. Developers needed something faster, more structured, and more capable.

PHP 4 was the answer.

The Zend Engine: The Heart of PHP 4

The single most important change in PHP 4 was the introduction of the Zend Engine 1.0.

The Zend Engine was built by Zeev Suraski and Andi Gutmans, the same developers who had rewritten PHP 3.

It replaced the old parsing and execution model with a two-step process:

1. The script was first compiled into intermediate bytecode
2. The bytecode was then executed by the Zend Engine

This approach made PHP 4 dramatically faster than PHP 3.

It also made the language far more consistent and predictable, which was critical for building larger, more complex web applications.

Key Features of PHP 4

Output Buffering

PHP 4 introduced output buffering, which allowed developers to capture all output before sending it to the browser.

This gave developers control over headers, cookies, and page content in ways that were not possible before.

ob_start();
echo "This is buffered output.";
$content = ob_get_clean();
echo $content;

Sessions

One of the most celebrated additions in PHP 4 was native session support.

Before this, developers had to manage sessions manually using cookies or custom database logic.

With PHP 4, sessions became straightforward.

session_start();
$_SESSION['username'] = 'John';
echo $_SESSION['username'];

This single feature opened the door to building real user-driven web applications like login systems, shopping carts, and user dashboards.

Improved Object-Oriented Support

PHP 4 improved object-oriented programming significantly compared to PHP 3.

Developers could now define classes, create objects, use inheritance, and call methods in a more reliable way.

class Animal {
    var $name;

    function Animal($name) {
        $this->name = $name;
    }

    function speak() {
        echo "I am " . $this->name;
    }
}

$dog = new Animal("Dog");
$dog->speak();

It was far from perfect — there was no visibility control, no type hinting, and objects were passed by value rather than by reference — but it was a significant step forward.

HTTP Authentication

PHP 4 added support for HTTP authentication, allowing developers to protect pages with username and password prompts natively through PHP.

if (!isset($_SERVER['PHP_AUTH_USER'])) {
    header('WWW-Authenticate: Basic realm="My Site"');
    header('HTTP/1.0 401 Unauthorized');
    exit;
}
echo "Welcome, " . $_SERVER['PHP_AUTH_USER'];

COM and .NET Support on Windows

For Windows developers, PHP 4 introduced support for COM (Component Object Model) objects.

This allowed PHP scripts to interact with Windows applications and services, which was particularly useful in enterprise environments at the time.

PCRE — Regular Expressions

PHP 4 bundled PCRE (Perl Compatible Regular Expressions), giving developers a powerful and standardized way to work with patterns in strings.

$string = "The year is 2000";
preg_match('/\d+/', $string, $matches);
echo $matches[0]; // 2000

PHP 4 and the Rise of Open Source Web Development

PHP 4 arrived at exactly the right moment.

The internet was exploding. Businesses were rushing online. Developers needed tools that were free, fast, and flexible.

PHP 4 checked every box.

It ran on Linux, Windows, and macOS. It worked seamlessly with Apache. It connected to MySQL with ease.

The combination of Linux + Apache + MySQL + PHP became known as the LAMP stack, and it powered a generation of websites.

Forums, blogs, news sites, e-commerce stores, and community platforms were all built on PHP 4 during this era.

Popular projects born during or shaped by the PHP 4 era include:

• phpBB — one of the most widely used forum platforms
• osCommerce — an early e-commerce solution
• Mambo — a content management system that later evolved into Joomla
• Early versions of WordPress — which launched in 2003, late in the PHP 4 era

Limitations of PHP 4

Despite its success, PHP 4 had well-known weaknesses that developers had to work around constantly.

Objects were passed by value, not by reference.

This meant that when you passed an object to a function, PHP copied the entire object rather than passing a reference to it. For large objects, this was both slow and confusing.

// In PHP 4, this did NOT modify the original object
function setName($obj, $name) {
    $obj->name = $name;
}

To work around this, developers had to use the & reference operator manually, which was error-prone.

No visibility control.

PHP 4 had no public, protected, or private keywords. All class properties and methods were accessible from anywhere, making encapsulation nearly impossible.

No exceptions.

PHP 4 had no try/catch exception handling. Error handling relied entirely on return values and custom error functions, which made error management inconsistent and difficult to maintain.

No abstract classes or interfaces.

There was no way to enforce contracts between classes. Developers had to rely on documentation and convention rather than the language itself.

No namespaces.

All functions and classes existed in a single global space. As applications grew larger, naming conflicts became a serious problem.

PHP 4 vs PHP 3 — What Changed

The End of PHP 4

PHP 5 was released on July 13, 2004, introducing the Zend Engine 2.0, true object-oriented programming, exceptions, interfaces, abstract classes, and proper object references.

PHP 5 was everything PHP 4 was not in terms of object-oriented design.

Despite this, PHP 4 remained in wide use for years. Many shared hosting providers were slow to upgrade, and countless applications had been written specifically for PHP 4.

The PHP development team officially declared PHP 4 end-of-life on December 31, 2007, urging all users to upgrade to PHP 5.

Even after that date, PHP 4 continued running on servers around the world for years — a testament to both how widespread its adoption had been and how difficult it was to migrate legacy code.

The Legacy of PHP 4

PHP 4 did something remarkable.

It took a scripting language that many serious developers dismissed and turned it into the backbone of the modern web.

It proved that open source software could power real, production-grade applications at scale.

It gave an entire generation of developers their first experience with server-side programming.

It built the LAMP stack, which remains influential to this day.

And it laid the foundation for PHP 5, PHP 7, and the modern PHP ecosystem that powers platforms like WordPress, Laravel, Symfony, and countless others.

Timeline

Final Thoughts

PHP 4 was not a perfect language.

Its object model was flawed. Its error handling was primitive. Its lack of namespaces became a genuine problem as applications grew.

But none of that diminishes what it achieved.

At a time when the web needed a fast, free, and accessible server-side language, PHP 4 delivered.

It empowered beginners to build real things. It gave businesses an affordable path to the web. It created a community that continues to grow and innovate more than two decades later.

Looking back, PHP 4 was not just a programming language version.

It was the foundation upon which the modern web was built.

A piece of web history worth remembering.