Clean code - Revision history

Root at 07:45, 20 October 2025

2025-10-20T07:45:11Z

← Older revision		Revision as of 08:45, 20 October 2025
Line 17:		Line 17:
	}</syntaxhighlight>		}</syntaxhighlight>

	== ~~'''~~Reusability~~'''~~ ==		== Reusability ==
	It is another hallmark of clean code. Code that is modular and decoupled is like a set of versatile Lego blocks. Such blocks can be assembled in myriad ways to build diverse structures. Similarly, functions and modules written with a single, clear responsibility can be combined and recombined to achieve varied functionalities without reinventing the wheel. This not only speeds up the development process but also reduces the chances of introducing errors.		It is another hallmark of clean code. Code that is modular and decoupled is like a set of versatile Lego blocks. Such blocks can be assembled in myriad ways to build diverse structures. Similarly, functions and modules written with a single, clear responsibility can be combined and recombined to achieve varied functionalities without reinventing the wheel. This not only speeds up the development process but also reduces the chances of introducing errors.

Line 42:		Line 42:
	}</syntaxhighlight>		}</syntaxhighlight>

	== ~~'''~~Refactorability~~'''~~ ==		== Refactorability ==
	It pertains to the ease with which code can be changed or improved. In an ever-evolving tech landscape, software needs are constantly changing. Whether it's due to changing user requirements, new technologies, or unforeseen challenges, the ability to alter code without upheaval is a tremendous asset. Clean code, by its inherent organized and modular nature, can be refactored with minimal friction.		It pertains to the ease with which code can be changed or improved. In an ever-evolving tech landscape, software needs are constantly changing. Whether it's due to changing user requirements, new technologies, or unforeseen challenges, the ability to alter code without upheaval is a tremendous asset. Clean code, by its inherent organized and modular nature, can be refactored with minimal friction.

Root at 07:44, 20 October 2025

2025-10-20T07:44:44Z

← Older revision		Revision as of 08:44, 20 October 2025
Line 1:		Line 1:
	Clean Code: The Art of Writing Readable and Maintainable Software In the realm of software development, the final product is often evaluated by its functionality, efficiency, and user experience. While these aspects are undeniably crucial, the process and craftsmanship behind the ~~scenes—the code—plays~~ an equally vital role in ensuring the software's longevity and adaptability. Clean code stands at the heart of this craftsmanship. But what exactly is clean code, and why is it so pivotal?		Clean Code: The Art of Writing Readable and Maintainable Software In the realm of software development, the final product is often evaluated by its functionality, efficiency, and user experience. While these aspects are undeniably crucial, the process and craftsmanship behind the scenes, the code, plays an equally vital role in ensuring the software's longevity and adaptability. Clean code stands at the heart of this craftsmanship. But what exactly is clean code, and why is it so pivotal?

	Clean code is a concept that goes beyond the mere functionality of code. At its essence, clean code is readable, reusable, and refactorable. It is written by a developer who anticipates the needs of ~~others—be~~ it fellow developers, reviewers, or even their future ~~self—who~~ will interact with, modify, or build upon that code.		Clean code is a concept that goes beyond the mere functionality of code. At its essence, clean code is readable, reusable, and refactorable. It is written by a developer who anticipates the needs of others, be it fellow developers, reviewers, or even their future self, who will interact with, modify, or build upon that code.

	~~'''~~Readability~~'''~~ is paramount. Just as a well-written novel flows seamlessly from one chapter to the next, guiding the reader through its narrative, clean code guides its reader through its logic. It uses meaningful variable and function names, adheres to a consistent style, and is organized in a logical manner. Comments, when used, provide valuable context or explain complex decisions, rather than stating the obvious. The importance of readability cannot be overstated; code is read far more times than it is written. By ensuring clarity, we save countless hours of deciphering, debugging, and deducing.		== Readability ==
			It is paramount. Just as a well-written novel flows seamlessly from one chapter to the next, guiding the reader through its narrative, clean code guides its reader through its logic. It uses meaningful variable and function names, adheres to a consistent style, and is organized in a logical manner. Comments, when used, provide valuable context or explain complex decisions, rather than stating the obvious. The importance of readability cannot be overstated; code is read far more times than it is written. By ensuring clarity, we save countless hours of deciphering, debugging, and deducing.

	PHP Example:		PHP Example:
Line 15:		Line 16:
	return $firstNumber + $secondNumber;		return $firstNumber + $secondNumber;
	}</syntaxhighlight>		}</syntaxhighlight>
	'''Reusability''' is another hallmark of clean code. Code that is modular and decoupled is like a set of versatile Lego blocks. Such blocks can be assembled in myriad ways to build diverse structures. Similarly, functions and modules written with a single, clear responsibility can be combined and recombined to achieve varied functionalities without reinventing the wheel. This not only speeds up the development process but also reduces the chances of introducing errors.
			== '''Reusability''' ==
			It is another hallmark of clean code. Code that is modular and decoupled is like a set of versatile Lego blocks. Such blocks can be assembled in myriad ways to build diverse structures. Similarly, functions and modules written with a single, clear responsibility can be combined and recombined to achieve varied functionalities without reinventing the wheel. This not only speeds up the development process but also reduces the chances of introducing errors.

	PHP Example:		PHP Example:
Line 38:		Line 41:
	return $price + calculateTax($price) + calculateShipping();		return $price + calculateTax($price) + calculateShipping();
	}</syntaxhighlight>		}</syntaxhighlight>
	'''Refactorability''' pertains to the ease with which code can be changed or improved. In an ever-evolving tech landscape, software needs are constantly changing. Whether it's due to changing user requirements, new technologies, or unforeseen challenges, the ability to alter code without upheaval is a tremendous asset. Clean code, by its inherent organized and modular nature, can be refactored with minimal friction.
			== '''Refactorability''' ==
			It pertains to the ease with which code can be changed or improved. In an ever-evolving tech landscape, software needs are constantly changing. Whether it's due to changing user requirements, new technologies, or unforeseen challenges, the ability to alter code without upheaval is a tremendous asset. Clean code, by its inherent organized and modular nature, can be refactored with minimal friction.

	PHP Example		PHP Example

Root at 07:43, 20 October 2025

2025-10-20T07:43:27Z

← Older revision		Revision as of 08:43, 20 October 2025
Line 7:		Line 7:
	PHP Example:		PHP Example:

	<syntaxhighlight># Not Readable:		<syntaxhighlight lang="php"># Not Readable:
	function p($a, $b){		function p($a, $b){
	return $a + $b;		return $a + $b;
Line 19:		Line 19:
	PHP Example:		PHP Example:

	<syntaxhighlight># Not Reusable		<syntaxhighlight lang="php"># Not Reusable
	function calculateInvoice($price){		function calculateInvoice($price){
	$tax = 0.1 * $price;		$tax = 0.1 * $price;
Line 42:		Line 42:
	PHP Example		PHP Example

	<syntaxhighlight># Hard to Refactor		<syntaxhighlight lang="php"># Hard to Refactor
	function userRegistration($data){		function userRegistration($data){
	// Validation		// Validation
Line 95:		Line 95:
	return "User registered successfully.";		return "User registered successfully.";
	}</syntaxhighlight>		}</syntaxhighlight>
	~~<!-- From bodyContent 1543028.mraw -->~~

	[[Category:IT backend architecture]]		[[Category:IT backend architecture]]

Maintenance script: Added category IT backend architecture

2025-10-19T17:51:15Z

Added category IT backend architecture

← Older revision		Revision as of 18:51, 19 October 2025
Line 97:		Line 97:
	<!-- From bodyContent 1543028.mraw -->		<!-- From bodyContent 1543028.mraw -->

			[[Category:IT backend architecture]]

Maintenance script: Maintenance script moved page UserDocumentation:Knowledge Central/KC IT/IT backend team/IT backend policies/IT backend architecture/Clean code to Clean code: Cleaned title and categorized

2025-10-19T17:51:15Z

Maintenance script moved page UserDocumentation:Knowledge Central/KC IT/IT backend team/IT backend policies/IT backend architecture/Clean code to Clean code: Cleaned title and categorized

← Older revision	Revision as of 18:51, 19 October 2025
(No difference)

imported>Unknown user at 09:59, 19 April 2025

2025-04-19T09:59:41Z

← Older revision		Revision as of 10:59, 19 April 2025
Line 1:		Line 1:
			Clean Code: The Art of Writing Readable and Maintainable Software In the realm of software development, the final product is often evaluated by its functionality, efficiency, and user experience. While these aspects are undeniably crucial, the process and craftsmanship behind the scenes—the code—plays an equally vital role in ensuring the software's longevity and adaptability. Clean code stands at the heart of this craftsmanship. But what exactly is clean code, and why is it so pivotal?

			Clean code is a concept that goes beyond the mere functionality of code. At its essence, clean code is readable, reusable, and refactorable. It is written by a developer who anticipates the needs of others—be it fellow developers, reviewers, or even their future self—who will interact with, modify, or build upon that code.

			'''Readability''' is paramount. Just as a well-written novel flows seamlessly from one chapter to the next, guiding the reader through its narrative, clean code guides its reader through its logic. It uses meaningful variable and function names, adheres to a consistent style, and is organized in a logical manner. Comments, when used, provide valuable context or explain complex decisions, rather than stating the obvious. The importance of readability cannot be overstated; code is read far more times than it is written. By ensuring clarity, we save countless hours of deciphering, debugging, and deducing.

			PHP Example:

			<syntaxhighlight># Not Readable:
			function p($a, $b){
			return $a + $b;
			}
			# Readable:
			function addTwoNumbers($firstNumber, $secondNumber){
			return $firstNumber + $secondNumber;
			}</syntaxhighlight>
			'''Reusability''' is another hallmark of clean code. Code that is modular and decoupled is like a set of versatile Lego blocks. Such blocks can be assembled in myriad ways to build diverse structures. Similarly, functions and modules written with a single, clear responsibility can be combined and recombined to achieve varied functionalities without reinventing the wheel. This not only speeds up the development process but also reduces the chances of introducing errors.

			PHP Example:

			<syntaxhighlight># Not Reusable
			function calculateInvoice($price){
			$tax = 0.1 * $price;
			$shipping = 5;
			return $price + $tax + $shipping;
			}

			# Reusable
			function calculateTax($amount){
			return 0.1 * $amount;
			}

			function calculateShipping(){
			return 5;
			}

			function calculateInvoice($price){
			return $price + calculateTax($price) + calculateShipping();
			}</syntaxhighlight>
			'''Refactorability''' pertains to the ease with which code can be changed or improved. In an ever-evolving tech landscape, software needs are constantly changing. Whether it's due to changing user requirements, new technologies, or unforeseen challenges, the ability to alter code without upheaval is a tremendous asset. Clean code, by its inherent organized and modular nature, can be refactored with minimal friction.

			PHP Example

			<syntaxhighlight># Hard to Refactor
			function userRegistration($data){
			// Validation
			if(!isset($data['email']) \|\| !filter_var($data['email'], FILTER_VALIDATE_EMAIL)){
			return "Invalid email.";
			}

			// Database connection
			$conn = new mysqli('localhost', 'user', 'pass', 'test');
			if ($conn->connect_error) {
			die("Connection failed: " . $conn->connect_error);
			}

			// Inserting user data
			$sql = "INSERT INTO users (email) VALUES ('".$data['email']."')";
			if ($conn->query($sql) !== TRUE) {
			return "Error: " . $sql . "<br>" . $conn->error;
			}
			return "User registered successfully.";
			}

			# Easier to Refactor
			function validateEmail($email){
			return isset($email) && filter_var($email, FILTER_VALIDATE_EMAIL);
			}

			function createDatabaseConnection(){
			$conn = new mysqli('localhost', 'user', 'pass', 'test');
			if ($conn->connect_error) {
			die("Connection failed: " . $conn->connect_error);
			}
			return $conn;
			}

			function insertUser($conn, $email){
			$sql = "INSERT INTO users (email) VALUES ('".$email."')";
			if ($conn->query($sql) !== TRUE) {
			return false;
			}
			return true;
			}

			function userRegistration($data){
			if(!validateEmail($data['email'])){
			return "Invalid email.";
			}

			$conn = createDatabaseConnection();
			if(!insertUser($conn, $data['email'])){
			return "Error while registering user.";
			}
			return "User registered successfully.";
			}</syntaxhighlight>
	<!-- From bodyContent 1543028.mraw -->		<!-- From bodyContent 1543028.mraw -->

imported>Unknown user at 09:59, 19 April 2025

2025-04-19T09:59:41Z

← Older revision	Revision as of 10:59, 19 April 2025
(No difference)

imported>Unknown user at 09:59, 19 April 2025

2025-04-19T09:59:41Z

New page