Why your code suxx

Why Your Code Suxx
And why you should care about it ?

www.blubird.eu
Started mid 2013
Audit & consultancy
Project staffing
Project management
ABOUT BLUBIRD
Web & Mobile apps
Virtualization and cloud
Performance & optimization
Security
SMAC the picture
Security, Mobility, Apps & Cloud

Nicolas De Boose
➢ Freelancer
➢ PHP, Symfony2, (Node) Js, Css
➢ 10 yrs pro
➢ A wonderful fiancee <3
➢ @NicoDeBoose
➢ Blog: mechantblog.com
ABOUT ME

WHY THIS SUBJECT?
1. Laravel vs Symfony2 vs Zend Framework2 ? Google it!
2. “Clean code” is a subject I like
– Pull request
– Gave lots of reviews
– Read/watch Clean coders (book & website)
3. Every year, new coders must learn best practices, solid
principles, patterns, ... And it’s a good booster shot

HOW ?
1. Presentation of code that smells
2. Your opinion
3. Refactoring

//Let's go to the bar
interface Human{
public function getAge();
public function getFullName();
}
interface Drink{
public function getPrice();
}
interface Bar{
public function removeFromStock(Drink $drink);
public function hasInStock(Drink $drink);
}

class BarMan{
private $bar;
public function command(Human $human, Drink $drink){
if ($this->bar->hasInStock($drink) == true) {
if ($drink->doesNotContainAlcohol()) {
$this->prepare($human, $drink);
} else {
if ($human->getAge() >= 18){
} else {
$this->errorMessage = 'Too young :(';
return false;
}
}
} else {
$this->errorMessage = 'Not in stock :(';
}
return true;
}
}

class BarMan{
private $bar;
public function command(Human $human, Drink $drink){
} else {
} else {
return false;
}
}
} else {
}
return true;
}
}
Focus on this code

//In Barman::command(Human $human, Drink $drink)
} else {
} else {
return false;
}
}
} else {
return false;
}
return true;

} else {
} else {
return false;
}
}
} else {
return false;
}
return true;
== true) == true) ...

if ($this->bar->hasInStock($drink)) {
} else {
} else {
return false;
}
}
} else {
return false;
}
return true;

if ($this->bar->hasInStock($drink)) {
} else {
} else {
return false;
}
}
} else {
return false;
}
return true;
Nested if’s

if (!$this->bar->hasInStock($drink)) {
return false;
}
} else {
} else {
return false;
}
}
return true;

return false;
}
} else {
} else {
return false;
}
}
return true;
call to “prepare()” here
And here + nested if

return false;
}
if (!$drink->doesNotContainAlcohol()
&& $human->getAge() < 18
) {
return false;
}
return true;

return false;
}
if (!$drink->doesNotContainAlcohol()
) {
return false;
}
return true;
NOT doesNot… My head hurts!

return false;
}
if ($drink->containsAlcohol()
) {
return false;
}
return true;

return false;
}
) {
return false;
}
return true;
can we be more explicit?

return false;
}
&& $human->isYoungerThan(18)
) {
return false;
}
return true;

return false;
}
) {
return false;
}
return true;
It’s not my job to keep the error message
It’s not my job to keep the error message

throw new DrinkNotInStockException($drink);
}
) {
return new CommandResult(false,'Too young :(');
}
return true;
Solution 1: Throw an exception
Solution 2: Return a “Result” object
Solution 1: Return nothing
Solution 2: Return a “Result” object

}
) {
throw new TooYoungToDrinkAlcoholException();
}

}
) {
}
What is “18”?
It’s a magic number!

}
&& $human->isYoungerThan
(self::MINIMUM_AGE_FOR_ALCOHOL)
) {
}
Better but not the best place
to store the constant

}
(BarLegislation::MINIMUM_AGE_FOR_ALCOHOL)
) {
}
There, it’s good enough
for the moment

if (!$this->bar->hasInStock($drink))
(BarLegislation::MINIMUM_AGE_FOR_ALCOHOL)
)

interface Human{
// public function getAge(); => deleted
public function isYoungerThan($age); //New
public function getFullName();
}
interface Drink{
public function getPrice();
public function containsAlcohol(); //Rename
}
interface Bar{
}

//In Barman::prepare(Human $human, Drink $drink)
$tmp = explode(" ", $human->getFullName());
$ac = "";
foreach ($tmp as $w) {
$ac .= $w[0];
}
$human->addToBill($drink);
$this->bar->removeFromStock($drink);
/* ... Prepare the drink ... */
$drink->setAcronym($ac);
SmsSender::send(
$human->getMobilePhoneNumber(),
sprintf('Drink %s ready', $ac)
);

$tmp = explode(" ", $human->getFullName());
$ac = "";
foreach ($tmp as $w) {
$ac .= $w[0];
}
$drink->setAcronym($ac);
SmsSender::send(
sprintf('Drink %s ready', $ac)
);
What does “tmp” mean?
What does “ac” mean?

$nameParts = explode(" ",$human->getFullName());
$acronym = "";
foreach ($nameParts as $w) {
$acronym .= $w[0];
}
$drink->setAcronym($acronym);
SmsSender::send(
sprintf('Drink %s ready', $acronym)
);

$nameParts = explode(" ",$human->getFullName());
$acronym = "";
foreach ($nameParts as $w) {
$acronym .= $w[0];
}
SmsSender::send(
);
Can we compute the
acronym elsewhere?

$acronym = $this->getHumanAcronym($human);
SmsSender::send(
);
That’s better,
but ...

$acronym = $human->getAcronym();
SmsSender::send(
);

$acronym = $human->getAcronym();
SmsSender::send(
);
Now let’s remove
$acronym var

$drink->setAcronym($human->getAcronym());
SmsSender::send(
sprintf('Drink %s ready',$human->getAcronym())
);

SmsSender::send(
);
A bill for a “simple” human?

$client = new Client($human);
$client->addDrink($drink);
SmsSender::send(
);
Create a “Client” class:
He knows what he’s
drinking

SmsSender::send(
);
A drink should not be
more than a drink.

$labeledDrink = new LabeledDrink(
$drink,
$human->getAcronym());
SmsSender::send(
sprintf('Drink %s ready',
$labeledDrink->getLabel())
);
Create a class that
symbolizes the drink
with an acronym
Take the label from the new object

$drink,
SmsSender::send(
);
Is there a better
place to instantiate
the object?

$drink,
SmsSender::send(
);
Is there a better
place to instantiate
the object?
Maybe here?

$labeledDrink = $client->addDrink($drink);
SmsSender::send(
);

SmsSender::send(
);
Not all human have a phone number

SmsSender::send(
$client->getMobilePhoneNumber(),
);
Our clients have a phone number!

SmsSender::send(
);
Human becomes useless here

//In Barman::prepare(Client $client, Drink $drink)
SmsSender::send(
);

SmsSender::send(
);
Hello ugly hard coded content!

SmsSender::send(
);
Hello ugly hard coded content!
We actually send a message here...

SmsSender::send(
new DrinkIsReadyMessage($labeledDrink, $client);
);
//FYI
class DrinkIsReadyMessage implements Message{
public function getPhoneNumber(){
return $this->client->getMobilePhoneNumber();
}
public function getMessage(){/* … */}
}

SmsSender::send(
);

SmsSender::send(
);
Static is not testable!

SmsSender::send(
);
/*
Should the bar manage the sms messaging system?
*/

SmsSender::send(
);
/*
Why not, but it already manages the drinks stock.
*/

SmsSender::send(
);
/*
Why not, but it already manages the drinks stock.
Maybe the bar should be a facade?
*/

$this->bar->sendMessage(
);
Simplest solution...

$this->bar->sendMessage(
);
Simplest solution...
Voilà! Let's not over engineering for the moment :)

interface Bar{
public function sendMessage(Message $message);//New
}
interface Client{
public function addDrink(Drink $drink);
public function getMobilePhoneNumber();
}
interface labeledDrink extends Drink{ //New class
public function getLabel();
}
interface Message{ //New interface
public function getPhoneNumber();
public function getMessage();
}
interface DrinkIsReadyMessage extends Message{} //New

class BillPrinter{ //Let's print the bill!
public function __construct(string $type) {
$this->type = $type;
}
public function renderClientBill(Client $client){
if ($this->type === 'xml') {
$this->renderAsXml($client);
} elseif ($this->type === 'html') {
$this->renderAsHtml($client);
} else {
throw new Exception('Invalid input');
}
}
public function renderAsHtml(Client $client){}
public function renderAsXml(Client $client){}
}

class BillPrinter{
}
} else {
throw new Exception('Invalid input');
}
}
}
Generic exception

class BillPrinter{
}
} else {
throw new InvalidTypeException();
}
}
}

class BillPrinter{
}
} else {
}
}
}
Render an xml
Render an html
2 responsabilities

class BillPrinter{
}
(new XmlBillPrinter())->render($client);
} else {
}
}
}
Render an html
Delegate xml

class BillPrinter{
}
(new HtmlBillPrinter())->render($client);
} else {
}
}
}
Delegate html
Delegate xml

class BillPrinter{
}
} else {
}
}
}

class BillPrinter{
}
} else {
}
}
}
interface BillPrinterInterface{
public function render(Client $client);
}
NB: The same interface is used

class BillPrinter{
}
} else {
}
}
} It’s not my job to find what instantiate!
I just want to render a bill!

class BillPrinter{
}
} else {
}
}
} It’s not my job to find what instantiate!
I just want to render a bill!
Delegate to a private method first...

class BillPrinter{
}
$this->getPrinterInstance()->render($client);
}
public function getPrinterInstance(){
return new XmlBillPrinter();
return new HtmlBillPrinter();
} else {
}
}
}

class BillPrinter{
}
}
} else {
}
}
}
It’s really not my job to
find what instantiate!

class BillPrinter{
}
}
} else {
}
}
}
It’s really not my job to
find what instantiate!
It’s a factory job!

class BillPrinter{
}
BillPrinterFactory::create($this->type)
->render($client);
}
}
class BillPrinterFactory{
public static function create(string $type){
if ($type === 'xml') {
} else //...
}
}

class BillPrinter{
}
->render($client);
}
}
} else //...
}
}
What is the purpose of this class again?

class BillPrinter{
}
->render($client);
}
}
} else //...
}
}
Remove the unnecessary class :)

//What about the render of the bill in HTML?
class HtmlBillPrinter
implements BillPrinterInterface{
public function render(Client $client){
foreach($client->getDrinks() as $drink){
$render .= '<div class="drink-line"';
if ($drink->containsAlcohol()) {
$render .= ' data-alcohol="1"';
}
$render.= '>'. $drink->getPrice() .'</div>';
}
return $render;
}
}

}
}
return $render;
}
}
It renders lines

}
}
return $render;
}
}
It manages HTML and its attributes
It renders lines

}
}
return $render;
}
}
And who’s gonna escape string if necessary?
It renders lines

}
}
return $render;
}
}
And who’s gonna escape string if necessary?
It renders lines
It’s bibi!

return '<div class="drink-line"';
$div = new HtmlTag('div');
$div->addAttribute('class', 'drink-line');
}
}
return $render;
}
}

}
}
return $render;
}
}

return ' data-alcohol="1"';
$div->addAttribute('data-alcohol', '1');
}
}
return $render;
}
}

}
}
return $render;
}
}

}
$div->setHtml($drink->getPrice());
return $div;
}
}
}

It’s all about making
Your code comprehensible
WRAPPING UP

INFO@BLUBIRD.EU
+32 2 880 05 41

Why your code suxx

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Why your code suxx

Similar to Why your code suxx (20)

Recently uploaded

Recently uploaded (17)

Why your code suxx