How to write code you won't hate tomorrow

How to write code you
won't hate tomorrow
<!/> "#

how do we measure code
quality?

how do we measure code quality?
4 number of classes
4 number of tests
4 using latest framework
4 PSR compliant
4 number of bugs shipped

how do we measure code quality?
can we:
4 read it easily
4 reason about it clearly
4 replace it quickly

readable
4 small functions/classes
4 good names
4 avoid nested code (ifs/loops) - extract methods
4 avoid else
4 return early or use a guard clause
4 avoid negation !

$data = $db->query("INSERT LONG, COMPLICATED SQL QUERY HERE");
echo '<ul>';
for ($i = 0; $i < count($data); $i++) {
echo "<li>$data[$i][0] - $data[$i][1]</li>";
}
echo '</ul>';

$people = $db->query("INSERT LONG, COMPLICATED SQL QUERY HERE");
echo '<ul>';
for ($i = 0; $i < count($people); $i++) {
echo "<li>$people[$i][0] - $people[$i][1]</li>";
}
echo '</ul>';

echo '<ul>';
foreach ($people as $person) {
echo "<li>$person[0] - $person[1]</li>";
}
echo '</ul>';

echo '<ul>';
foreach ($people as $person) {
echo "<li>{$person['name']} - {$person['email']}</li>";
}
echo '</ul>';

$listElements = array_reduce($people, function ($html, $person) {
return $html . "<li>{$person['name']} - {$person['email']}</li>";
});
return '<ul>' . $listElements . '</ul>';

return array_reduce($people, function ($html, $person) {
return $html . "<li>{$person['name']} - {$person['email']}</li>";
}, '<ul>') . '</ul>;

Input:
_ _ _ _ _ _ _ _
| | | _| _||_||_ |_ ||_||_|
|_| ||_ _| | _||_| ||_| _|
Output:
"0123456789"

return implode(array_map(function ($char) {
return $this->translate($char);
}, array_map('implode', transpose(array_map(function ($line) {
return str_split($line, 3);
}, explode("n", $ascii))))));

$lines = explode("n", $ascii);
$chunksOf3 = array_map(function ($line) {
return str_split($line, 3);
}, $lines);
$transposed = transpose($chunksOf3);
$characters = array_map('implode', $transposed);
$numbers = array_map(function ($char) {
return $this->translate($char);
}, $characters);
return implode($numbers);

if ($request->isValid()) {
$user = $request->getUser();
if ($user->hasPermissions()) {
foreach ($request->getUpdates() as $update) {
if ($update != null) {
$this->processUpdate($update);
}
}
} else {
throw new PermissionDeniedException;
}
} else {
throw new InvalidRequestException;
}

if (!$request->isValid()) {
} else {
}
}
} else {
}
}

if (!$request->isValid()) {
}
}
}
} else {
}

$this->guardAgainstInvalidRequest($request);
}
}
} else {
}

if (!$user->hasPermissions()) {
}
}
}

$this->guardAuthorisedUser($request->getUser());
}
}

$this->guardAuthorisedUser($request->getUser());
$updates = array_filter($request->getUpdates());
$this->processUpdates($updates);

Good code doesn't just
emerge by accident
1
Me

function example()
{
$data = ...;
if (!$this->resultIsOK($data)) {
$result = false;
} else {
$result = true;
}
return $result;
}

function example()
{
$data = ...;
if ($this->resultIsOK($data)) {
$result = true;
} else {
$result = false;
}
return $result;
}

function example()
{
$data = ...;
return true;
} else {
return false;
}
}

function example()
{
$data = ...;
return true;
}
return false;
}

function example()
{
$data = ...;
return $this->resultIsOK($data) ? true : false;
}

function example()
{
$data = ...;
return $this->resultIsOK($data);
}

understandable
4 small, composable functions - that do one thing
4 hide complexity
4 good names - variables, functions, namespaces,
classes
4 small public API
4 TDD
4 Value objects

How to write code you won't hate tomorrow

<?php
$d = 10;
$t = 3600;
$s = $d / t;
echo $s;

class Distance
{
private $km;
private function __construct() {}
public static function fromKm($km)
{
$d = new static;
$d->km = $km;
return $d;
}
public function asKm()
{
return $this->km;
}
}

class Time
{
private $seconds;
private function __construct() {}
public static function fromSeconds($seconds)
{
$t = new static;
$t->seconds = $seconds;
return $t;
}
public function inHours()
{
return $this->seconds / 3600;
}
}

class Speed
{
private $kmph;
public static function fromDistanceAndTime(Distance $d, Time $t)
{
$s = new static;
$s->kmph = $d->asKm() / $t->inHours();
return $s;
}
public function asMph()
{
return $this->kmph * 1.6093;
}
}

<?php
$d = Distance::fromKm(10); // 10 km
$t = Time::fromSeconds(3600); // 1 hr
$s = Speed::fromDistanceAndTime($d, $t); // 10 kmph
echo $s->asMph(); // will print 16.093

adaptable
4 Things change - new business knowledge/rules,
changing technologies
4 small functions/classes/modules
4 throw away code
4 dependency injection
4 be abstract, use interfaces

NO CODE IS SIMPLER
THAN NO CODE

Simple enables change = Opportunity

4 do katas - readable, efficient, flexible
4 exercism.io, projecteuler.net
4 pair/mob program
4 code review
4 read others code bases
4 mentor at http://phpmentoring.org
4 attend/speak conferences & user groups
4 write a blog

How to write code you won't hate tomorrow

More Related Content

What's hot (17)

Similar to How to write code you won't hate tomorrow (20)

Recently uploaded (20)

How to write code you won't hate tomorrow