---

Phred is an open-source initiative aimed at providing PHP with a consistent, completely object-oriented coding standard that enjoys a comfortable API for creating modern-day web applications with native support for Unicode, with components for internationalization and localization, clear-cut fundamental data types focused on performance and reliability, enhanced testing and debugging, and other features.

Phred is also outlining a web application framework to let developers take the most advantage of the improved PHP in their projects as well as to ensure backward compatibility with the whole multitude of the existing PHP libraries and APIs.

One of the Phred's prime efforts is to maintain a clear and thorough documentation.

At a Glance

The OOP magic below is not natively supported by PHP but is available with Phred:

// An OOP Unicode string.
$str = "Юнікод Ооп";

echo $str->length();        // 10
echo $str->toUpperCase();   // ЮНІКОД ООП

$array = $str->split(" ");
echo $array->join(", ");    // Юнікод, Ооп
$array->sortOn("length");
echo $array->join(", ");    // Ооп, Юнікод

echo strlen($str);          // 19
echo strtoupper($str);      // Юнікод Ооп

---

Phred is still young and the currently implemented object-oriented library and framework features are not yet RC. Class names, method names, and other details need to be tuned in to the best preferences of PHP developers. And Phred might branch into an OOP library and a separate framework. But at this point, Phred mainly requires code contributions to enable PHP developers with the benefits of OOP and native Unicode support by the time when PHP 7 arrives. Hopefully, the advanced extension capabilities of PHP 7 will allow for more seamless backward compatibility and dedicated syntax for data structures.

Phred might be looking for a new owner. If you are someone who would take a good care of it, contact me at nazariyg@gmail.com

---

• Preface
  • PHP 6 or Uniphant vs. Elecorn
  • PHP 7 or Much Like PHP 5.6+ but Faster
  • こんにちは, Phred
  • The Zen of Phred
• Installation
  • Getting the Latest PHP Version
  • Installing Phred
  • Running Unit Tests
• Fundamental Types
  • OOP String
    • Regular Expressions
    • Character Encodings
  • OOP Array
  • OOP Map
  • Time and Time Zones
  • Comparison and Sorting
• Enhanced Testing and Debugging
  • Semantic Checks
  • Bug Tracking and Reporting
• U14n
  • Locales
  • Locale-Specific Formatting
• Batteries Included
  • Input Filtering

---

Preface

Any web developer is of course familiar with JavaScript. Highly object-oriented and with Unicode done right, JavaScript just feels comfortable to work in when developing for the client side and JavaScript has even made it to the server side as Node.js. Same kind of sentiments might go to other languages that were also designed with a vision in mind, such as Python, Ruby, and Scala.

But while the quality standards of web development have evolved over the past decade to match the increasing demands for clean, readable, and comprehensible code that can be efficiently shared with other people on the team or made public, PHP has remained mostly immature. This may be especially noticeable if you are a PHP developer trying to create an innovative web application that is required to offer a substantial value to many users all over the globe. It even seems bit unfair that PHP, which is the most popular language used by web servers with a share of about 80%, is not actually superior to JavaScript, even though the control flow of a web application may imply the opposite.

Still being largely procedural and hardly following any conventions in the naming of the daunting number of its functions, some of which start with "str" and some with "str_", being infamous for the order of "haystack", "needle", and "subject" parameters changing irregularly from one function to another, and without the long overdue support for Unicode, PHP has found itself in a weird relationship with the developers, where the amount of people's love for PHP is mixed with a nearly proportional amount of hate. It is true however that the PHP language is easy to get into thanks to the C-like syntax resembling JavaScript along with a good number of other popular languages and that PHP has become the lingua franca of web programming, with a huge community of developers and open-source contributors. But it's also true that PHP is steadily losing in quality to a bunch of rival languages.

Because PHP is going to stay around for many years to come, the demands for an up-to-date PHP standard can no longer be ignored.

PHP 6 or Uniphant vs. Elecorn

Most of the hopes for a better PHP were being put in PHP 6 announced around 2006. However, PHP 6 became more like a mythical creature over the time, a creature that no one has ever seen. The new features that were planned for PHP, including the highly anticipated Unicode support, had never got released under PHP 6 label. Instead, the PHP 6 development branch was discontinued and only some of the features were backported into the 5.x versions afterwards, still without built-in Unicode. There was no beta or even alpha version of PHP 6.

One of the main reasons behind PHP 6 getting abandoned was a disagreement inside the development team as to which character encoding would serve best for storing and processing Unicode strings. Despite of the fact that the team then picked UTF-16 as the internal encoding to be used for Unicode, the development ran out of steam and eventually came to a halt. This happened not only because the choice of UTF-16 turned out to be suboptimal, but also because of the immense body of work that was required to be done for the PHP's core and all the extensions by the developers becoming less and less enthusiastic with the direction that was chosen and due to other issues. Andrei Zmievski, who was the head of the PHP 6 project, later admitted that he would probably choose UTF-8 over UTF-16 if it was possible to start over.

PHP 7 or Much Like PHP 5.6+ but Faster

In July of 2014, a vote was held by the PHP's steering group to decide under what name the next major version of PHP should be presented to the public when its development branch, called PHPNG for "PHP New Generation", would become a release candidate. The name that outvoted "PHP 6" and other names was "PHP 7". Skipping over "6" in the PHP's version was probably for the reason that PHP 6 had bit too much of disappointment associated with it and a number of books already existed at the time with "PHP 6" in their titles.

With the advent of PHPNG, which is going to become the basis for PHP 7, the mainstream implementation of PHP made a substantial progress in speed and memory consumption thanks to a great deal of optimization and code refactoring that eliminated numerous bottlenecks in the PHP's performance, while not breaking any backward compatibility. The modified engine also brought PHP closer to being able to benefit from just-in-time compilation in some of its future versions. The benchmarks that were run with PHPNG showed surprisingly good results, indicating almost double increase in speed and significantly smaller memory footprint.

こんにちは, Phred

The idea of Phred is resonating with the principle of separation of concerns. Let the PHP's core contributors remain focused on the language's underpinnings and further improve the PHP's engine to make it even faster, effectively providing a high-performance foundation upon which a consistent and completely object-oriented coding standard can be implemented by PHP developers themselves.

By extending PHP 7, which is now twice as fast, Phred converts PHP into an up-to-date and clean standard advantageous for creating sophisticated web sites and applications to be used by people all over the world, while keeping performance at a high level. Fortunately, the OOP-related features that are already present in PHP 5.6 and PHP 7 have made this possible. And not to forget the vital OOP infusions into the language that were faithfully made by some of its core contributors, most notably Nikita Popov.

The following is an example of how Phred may look like at work:

// Sign up a new user.

$inputUserName = "たかし やまもと ";
$inputBirthday = 491702400;  // converted to Unix time by JS

// Sanitize the username if it's not a valid Unicode string and remove any
// leading or trailing whitespace including any Unicode whitespace.
$userName = $inputUserName->isValid() ? $inputUserName : $inputUserName->sanitize();
$userName = $userName->trim();

if (!$userName->isEmpty()) {
    // The username is not empty.
    if ($userName->length() <= MAX_USERNAME_CHARS) {
        // Search for the first and last names within the username using
        // a regular expression pattern.
        if ($userName->reFindGroups("/^(\pL+)\s+(\pL+)$/u", $foundGroups)) {
            $firstName = $foundGroups[0];
            $lastName =  $foundGroups[1];
            echo $firstName;  // たかし
            echo $lastName;   // やまもと

            // Transliterate the username into the Latin script for searching.
            $userNameT = $userName->transliterateFromAny("latin")->toLowerCase();
            // "たかし やまもと" becomes "takashi yamamoto".

            // Store the names and the rest of the profile info to the database.
            // ...

            // Let's see how many days we are currently away from the user's birthday.
            $currTime = Tm::now();
            $birthday = new Tm($inputBirthday);
            $currYear = $currTime->yearUtc();
            $bdMonth =  $birthday->monthUtc();
            $bdDay =    $birthday->dayUtc();
            if (Tm::areComponentsValid($currYear, $bdMonth, $bdDay)) {
                $bdThisYear = Tm::fromComponentsUtc($currYear, $bdMonth, $bdDay);
                if ($currTime->diffInDays($bdThisYear) <= BD_SPEC_OFFER_DAYS) {
                    // Make a gift to the user on the service's behalf.
                    // ...
                }
            }
        }
    }
}

The classes used in the above example are OOP string, OOP array, and the time class.

The Zen of Phred

• In the world of open-source development where most of the code is shared, code clarity and readability is important.
• Object-oriented code architecture allows for much higher clarity and readability than procedural one, especially in complex code.
• Clean and eloquent code is easier to review and independently reviewed code is more reliable and secure.
• Code clarity largely influences the code's r