Modern php

Modern PHP
Charles Anderson 
Hack Salem! - July 2019

TL;DR
• PHP has grown a lot over the last 15 - 20 years

• duh!

• It’s much more reasonable for larger projects

Me
• I’m a systems programmer -
code w/o a face

• I am not really a PHP
programmer

• Ruby, Puppet, bash, etc.

• I did some PHP back in the
early Naughties

• CGI and bare Servlets before
that Gorak aka Steve aka Larry

Acquia
• Acquia provides enterprise-grade Drupal CMS hosting

• Lots more, too

• Operate a ﬂeet of tens of thousands of AWS servers

• Controlled with a mix of PHP, Ruby, Puppet, etc.

• Acquia is hiring

PHP 4 and Before
• PHP started as a simple way to add some computation to
web pages

• The simplest (lamest) example was a visitor counter

Gotta Have a Counter
<!DOCTYPE html>
<html>
<body>
<h1>My first PHP page</h1>
<p>Hello world</p>
<?php
$path = './counter.txt';
$file = fopen($path, 'r');
$count = fgets($file, 1000);
fclose($file);
$count = abs(intval($count)) + 1;
?>
<p>Congratulations: you are visitor
number:
<b> <?php echo "{$count}n"; ?> </b>
</p>
<?php
$file = fopen($path, 'w');
fwrite($file, $count);
fclose($file);
?>
</body>
</html>
HTML
HTML
PHP Business Logic
HTML
PHP Presentation Logic
PHP Business Logic

PHP
• A simple mix of HTML and business logic - what could
possibly go wrong?

• Global functions and variables (unless local in a function)

PHP Language
• Variables - $name
• Dynamic typing: $name=‘Damien’; $name=666;

• Scalar types: boolean, integer, double, string

• Arrays: always hashes - array[1] or array[‘name’]

• Flow control: if, switch, for, foreach, while

• Including code: include or require

Classes
• PHP 4 added classes

• Methods and properties - all public

• $object->method() or $object->property

• Single inheritance with extends keyword

• Introspection - classes, methods, properties, parent class

• Example: PEAR database library to abstract underlying
DB

Objects and Classes
• Visibility - public, protected, private

• Interfaces - a list of methods that must be implemented

• Abstract classes - implement a subset of methods of an
interface

• Traits - a collection of method implementations to include
in a class without inheritance - mix-ins

• Basically, the kitchen sink

Visibility
class Politician {
public function promises() {}
protected function donors() {}
private function scandals() {}
private $slushFundBalance = 1000000;
}

Interfaces
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
class Template implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
public function getHtml($template)
{
foreach($this->vars as $name => $value) {
$template = str_replace('{' . $name . '}', $value, $template);
}
return $template;
}
}

Abstract Classes
interface iTemplate
{
public function setVariable($name, $var);
public function getHtml($template);
}
// no getHtml method - must be abstract
abstract class SetTemplate implements iTemplate
{
private $vars = array();
public function setVariable($name, $var)
{
$this->vars[$name] = $var;
}
}

Traits
trait Logger {
function log($msg) {
echo '(' . __CLASS__ . ') ' . $msg ;
}
}
class BankAccount {
use Logger;
function withdraw($amount) {
$this->log('withdraw ' . $amount);
}
...
}
class Database {
use Logger;
function query($sql) {
$this->log('query ' .$sql);
}
...
}

Type Hints
• Have the option (not required) to specify types on
parameters, properties, and return values

• If a type is speciﬁed, you must (strictly) abide

• Nullable types - e.g., a function could return Foo or NULL

• Variables can still be dynamically typed

• Provides a path to slowly introduce typing to an existing
body of software

Type Hints
function sum(int $a, int $b) {
return $a + $b;
}
$result = sum(3, 4); // OK
$result = sum(3, 'cats') //FAIL
$result = sum(3.5, 4); // OK - really?
// another file
declare(strict_types=1);
$result = sum(3.5, 4); // FAIL

Nullabe Types
function welcome(?string $name) {
echo $name;
}
welcome('world'); // OK
welcome(null); // OK
welcome(); // FAIL
function welcome($name): ?string
{
return null; // OK
}
{
return 'Welcome ' . $name; // OK
}
{
return 33; // FAIL
}

Large Scale Software
• Namespaces - no longer only a global, ﬂat namespace

• Packaging / Composer: install libraries and manage
dependencies

Namespaces
<?php
namespace MyApplication;
const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
<?php
namespace ThirdPartyDatabaseUtil;
const CONNECT_OK = 1;
class Connection { /* ... */ }
function connect() { /* ... */ }
$status = CONNECT_OK; // local namespace
$status = MyApplicationCONNECT_OK; // other namespace
Top-Level Namespace
Sub-Namespace

Packages
• PHP code can be packaged into a reusable collection
called simply a package - c.f., Ruby gems

• The Composer tool is a per-project package manager that
fetches the packages you need and all of the
dependencies - c.f., Ruby Bundler

Composer
• In your project directory, you can run 
composer require "twig/twig:^2.0"

• Creates composer.json and composer.lock ﬁles and
vendor directory

• composer install - install all the packages

• To use the packages, include one line of code: 
require_once __DIR__ . ‘/vendor/autoload.php';
• Auto-loading loads all the packages at runtime

Other Items
• Exceptions - code without checking return values

• Testing frameworks - phpUnit and Behat (BDD)

• Style/lint checkers - phpstan and phpcs

• see also John’s talk

Conclusions
• PHP has grown up a lot in the last 15 years - deﬁnitely no
longer Stone Age

• You can easily write large, well structured applications

• You can still write a mess of logic and presentation - it’s
a free country

Modern php

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Modern php

Similar to Modern php (20)

More from Charles Anderson

More from Charles Anderson (10)

Recently uploaded

Recently uploaded (20)

Modern php