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

More Related Content

What's hot

Similar to Why your code suxx

Recently uploaded

Why your code suxx