Introduction to Clean Code

Clean code
Cleaner, cleaner, cleaner!

What is clean code?
Clean code

Clean code
Code example: product XML-feed parser
class FeedParser
{
public function doParse()
{
$products = array(); //array of products to return
$xml = simplexml_load_file("/tmp/products.xml"); //read xml file
if ($xml === FALSE) {
throw new Exception("feed not found"); //file not found
} else {
if (count($xml) === 0) {
throw new Exception("empty feed");
} else {
foreach($xml as $elem) {
$prod = $this->parse_elem($elem);
array_push($products, $prod); //add Product object
}
}
}
return $products;
}
(...)

Clean code
http://bit.ly/seminariUPCexample
class FeedParser
{
(...)
private function parse_elem($elem)
{
$name = $this->getElementErrorHandler($elem, "title");
$url = $this->getElementErrorHandler($elem, "link");
//Product not active
return new Product($name, $url, $elem->id, false);
}
private function getElementErrorHandler($elem, $attr) {
$item = (string)$elem->$attr;
if ($item == "") {
throw new Exception("incorrect item");
}
return $item;
}
}

● Code surface
○ Code style, DRY (duplication), comments
● Naming
● Easier functions
● Cleaner logic
○ Guards, configuration over hardcoding
Clean code
Index

Clean code
Code style: let’s find fails
class FeedParser
{
(...)
{
}
private function getElementErrorHandler($elem, $attr) {
$item = (string)$elem->$attr;
if ($item == "") {
throw new Exception("incorrect item");
}
return $item;
}
}

● A repository with n developers should look homogeneous
● Code style (CS) tools
○ Verification
○ Automatic fixer
Clean code
Code style

● Impatient duplication
○ copy it and make a couple of changes
● Inter-developer duplication
○ Make it easy to use/reuse
Clean code
Don’t Repeat Yourself (DRY)

● Imposed duplication (unavoidable case)
○ Multiple representations of information
● Use a copy-paste detector
Clean code
Don’t Repeat Yourself (DRY)

● The less, the better!
● Usually comments are not needed
○ Redundant
○ Outdated
● Or even worse..
○ Commented out code
Clean code
Comments

Clean code
Any useful comment here?
class FeedParser
{
{
$products = array(); //array of products to return
$xml = simplexml_load_file("/tmp/products.xml"); //read xml file
throw new Exception("feed not found"); //file not found
} else {
} else {
$prod = $this->parse_elem($elem);
array_push($products, $prod); //add Product object
}
}
}
return $products;
}
(...)

● Use the code itself to explain the logic
○ Use a variable instead of a comment
○ Use intention revealing names in vars and functions
Clean code
Comments

Clean code
Use a variable instead of a comment
{
}

Clean code
Use a variable instead of a comment
{
}
--------
{
$isActive = false;
return new Product($name, $url, $elem->id, $isActive);
}

● Intention-revealing names
○ int days; //days since last purchase
○ int daysSinceLastPurchase;
● Shared vocabulary with the team
● Precise vocabulary
○ No “manageUser(...)” but “updateUserContactInfo(...)”
○ No “killUserInDb()” but “deleteUserFromDb()”
Clean code
Naming

Clean code
Looking for meaningful names
{
$isActive = false;
}

Clean code
Looking for meaningful names
{
$isActive = false;
}
--------
private function createProductFromXmlData($productXmlData)
{
$name = $this->getAttribute($productXmlData, "title");
$url = $this->getAttribute($productXmlData, "link");
$isActive = false;
return new Product($name, $url, $productXmlData->id, $isActive);
}

● Small! Really small!
○ 2, 3, 4 lines
● Do ONLY one thing!
Clean code
Easier functions

Clean code
Does doParse() do only one thing?
{
$products = array();
$xml = simplexml_load_file("/tmp/products.xml");
throw new Exception("feed not found");
} else {
} else {
$prod = $this->createProductFromXmlData($elem);
array_push($products, $prod);
}
}
}
return $products;
}

Clean code
{
$xmlData = $this->readXML("/tmp/products.xml");
$products = $this->extractProductsFromXmlData($xmlData);
return $products;
}
private function readXML($filename)
{
$xmlData = simplexml_load_file($filename);
if ($xmlData === FALSE) {
} elseif (count($xml) === 0) {
}
return $xmlData;
}
private function extractProductsFromXmlData($xmlData)
{
$products = array();
foreach($xmlData as $productXml) {
$prod = $this->createProductFromXmlData($productXml);
array_push($products, $prod);
}
return $products;
}

● Keep same level of abstraction
○ From top to bottom, outside in
● Arguments
○ Avoid many arguments: use objects or DTOs instead
○ Caution with flags (bool arguments)
Clean code
Easier functions

Clean code
Avoiding flags, and keeping same level
{
$isActive = false;
}

Clean code
Avoiding flags, and keeping same level
{
$isActive = false;
}
{
$id = $this->getAttribute($productXmlData, "id");
return new Product::createInactive($name, $url, $id);
}

● Guard clauses
● Configuration over hardcoding
Clean code
Cleaner logic

Clean code
{
}
return $xmlData;
}
// Let’s add guard clauses

Clean code
{
}
return $xmlData;
}
// Let’s add guard clauses
{
$this->checkFileExists($filename);
$this->checkXmlHasContent($xmlData);
return $xmlData;
}
private function checkFileExists($filename)
{
if (!file_exists($filename)) {
throw new Exception("File $filename not found");
}
}

Clean code
class FeedParser
{
{
return $products;
}
// Let’s remove the hardcoding

Clean code
class FeedParser
{
{
return $products;
}
// Let’s remove the hardcoding
class FeedParser
{
public function __construct($filename)
{
$this->XmlFilename = $filename;
}
{
$xmlData = $this->readXML($this->XmlFilename);
return $products;
}

● Books:
○ Clean Code (Robert “Uncle Bob” Martin)
○ The Pragmatic Programmer (Hunt & Tomas)
○ Refactoring (Fowler)
Clean code
And you can continue cleaning… forever

Introduction to Clean Code

More Related Content

What's hot

Viewers also liked

Similar to Introduction to Clean Code

Recently uploaded

Introduction to Clean Code