{"id":455,"date":"2020-03-22T20:33:35","date_gmt":"2020-03-22T20:33:35","guid":{"rendered":"http:\/\/pragmaticways.com\/?p=455"},"modified":"2021-01-26T05:56:18","modified_gmt":"2021-01-26T05:56:18","slug":"write-better-code-in-5-easy-steps","status":"publish","type":"post","link":"https:\/\/pragmaticways.com\/write-better-code-in-5-easy-steps\/","title":{"rendered":"Here&#8217;s 5 easy steps for you to write better code today"},"content":{"rendered":"\n<p>It is my firm belief that the most important aspect of writing code is <strong>writing code that&#8217;s easy to read<\/strong>, easy to understand, and easy to maintain. Here are 5 very easy things you can start doing today to write clean code. <\/p>\n\n\n\n\n\n<p>How many times have you come across a confusing and complex &#8220;algorithm&#8221; that you have no clue what it&#8217;s supposed to be doing? You mumble in your head &#8220;who the F*** wrote this piece of S***?!?&#8221;<\/p>\n\n\n\n<p>You check the <code class=\"pragmatic-ways\">git log<\/code> only to find out that you actually checked in this module 6 months ago&#8230;<\/p>\n\n\n\n<figure class=\"wp-block-image size-medium\"><img loading=\"lazy\" width=\"300\" height=\"300\" src=\"http:\/\/pragmaticways.com\/wp-content\/uploads\/2020\/03\/when-its-been-7-hours-300x300.png\" alt=\"Programmer Meme: When it's been 7 hours and you still can't understand your own code\" class=\"wp-image-456\" srcset=\"https:\/\/pragmaticways.com\/wp-content\/uploads\/2020\/03\/when-its-been-7-hours-300x300.png 300w, https:\/\/pragmaticways.com\/wp-content\/uploads\/2020\/03\/when-its-been-7-hours-150x150.png 150w, https:\/\/pragmaticways.com\/wp-content\/uploads\/2020\/03\/when-its-been-7-hours.png 540w\" sizes=\"(max-width: 300px) 100vw, 300px\" \/><\/figure>\n\n\n\n<p>(Hopefully you work in a high-performing team where code reviews are a natural part of your development process and this type of thing never [or at least rarely] occurs)<\/p>\n\n\n\n<p>The ugly truth about software development is that this type of thing happens all too often. A bunch of highly-motivated programmers just crushing code to meet deadlines. We get so wrapped up on one piece at a time that we accept the pre-mature finish line the first time our code works. As Robert &#8220;Uncle Bob&#8221; Martin says, <\/p>\n\n\n\n<blockquote class=\"wp-block-quote\"><p>Getting software to work and making software clean are two very different activities.  <\/p><cite>Robert &#8220;Uncle Bob&#8221; Martin &#8211; <a href=\"https:\/\/amzn.to\/3bijRDD\" class=\"rank-math-link\">Clean Code: A Handbook of Agile Software Craftsmanship<\/a><\/cite><\/blockquote>\n\n\n\n<p>Writing clean code is no easy task. Good software engineers write code that works. Great software engineers write code that&#8217;s clean. <\/p>\n\n\n\n<p>Below we&#8217;ll dive into 5 very simple things you can start implementing NOW to start writing cleaner code. However, if you want to really transform your clean code writing abilities and impress all your co-workers during code review, I&#8217;d highly recommend you pick up a copy of Robert Martin&#8217;s book on &#8220;<strong>Clean Code: A Handbook of Agile Software Craftsmanship<\/strong>&#8220;<\/p>\n\n\n\n<span style=\"font-size: 22px;max-width: 200px;display: inline-block;height: 240px;vertical-align: top;margin: 0;\"><span style=\"display: table-cell;vertical-align: middle;height: 240px; font-weight: bold; padding: 2px\">Every software engineer must read this book &gt;&gt;<\/span><\/span><iframe style=\"width:120px;height:240px;\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\" frameborder=\"0\" src=\"\/\/ws-na.amazon-adsystem.com\/widgets\/q?ServiceVersion=20070822&amp;OneJS=1&amp;Operation=GetAdHtml&amp;MarketPlace=US&amp;source=ac&amp;ref=tf_til&amp;ad_type=product_link&amp;tracking_id=selftaughtadu-20&amp;marketplace=amazon&amp;region=US&amp;placement=0132350882&amp;asins=0132350882&amp;linkId=7f65c4d0b47f42083c754c591b950f06&amp;show_border=true&amp;link_opens_in_new_window=true&amp;price_color=333333&amp;title_color=0066c0&amp;bg_color=ffffff\"><\/iframe>\n\n\n\n<h2>Focus on creating descriptive variable name<\/h2>\n\n\n\n<p>This is one of the easiest yet most beneficial things you can do, start using more descriptive and meaningful variable names. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-1\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ Code Snippet #1<\/span>\n<span class=\"hljs-keyword\">public<\/span> void <span class=\"hljs-keyword\">print<\/span>(int user) {\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= a) {\n    System.out.println(<span class=\"hljs-string\">\"User can drive.\"<\/span>);\n  }\n<span class=\"hljs-keyword\">if<\/span> (user &gt;= b) {\n    System.out.println(<span class=\"hljs-string\">\"User can vote.\"<\/span>);\n  }\n<span class=\"hljs-keyword\">if<\/span> (user &gt;= c) {\n    System.out.println(<span class=\"hljs-string\">\"User can drink.\"<\/span>);\n  }\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-1\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p class=\"272821\">The example above shows an example function with a poor choice of variable names. What are <code class=\"pragmatic-ways\">a<\/code>, <code class=\"pragmatic-ways\">b<\/code>, and <code class=\"pragmatic-ways\">c<\/code> supposed to represent? What is the argument <code class=\"pragmatic-ways\">user<\/code> supposed to indicate? <\/p>\n\n\n\n<p>From the context of reading the whole function, it probably wouldn&#8217;t take entirely too long to decipher that this function is checking the user&#8217;s age and printing out the user&#8217;s capabilities, such as if they can drive, vote, or drink a beer. But the use of poor variable names made us have to read and think about what&#8217;s actually happening. <\/p>\n\n\n\n<p>These variable names make us have to think. When reading code, we shouldn&#8217;t have to think. We should be striving to make code as readable as possible, as if we are just reading a story.<\/p>\n\n\n\n<p>Before we refactor this code to make it more readable, let&#8217;s take this same example to look at a worse example. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-2\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ Code Snippet #2<\/span>\n<span class=\"hljs-keyword\">public<\/span> void <span class=\"hljs-keyword\">print<\/span>(int user) {\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= <span class=\"hljs-number\">16<\/span>) {\n    System.out.println(<span class=\"hljs-string\">\"User can drive.\"<\/span>);\n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= <span class=\"hljs-number\">18<\/span>) {     \n    System.out.println(<span class=\"hljs-string\">\"User can vote.\"<\/span>);\n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= <span class=\"hljs-number\">21<\/span>) {\n    System.out.println(<span class=\"hljs-string\">\"User can drink.\"<\/span>);\n  }\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-2\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>What do you think? At the surface, it may appear that replacing the ambiguous named variables of <code class=\"pragmatic-ways\">a<\/code>, <code class=\"pragmatic-ways\">b<\/code>, and <code class=\"pragmatic-ways\">c<\/code> with hard-coded integers may make the code easier to understand. However, this is actually another poor practice called the <a href=\"http:\/\/pragmaticways.com\/31-code-smells-you-must-know\/#30_Magic_Numbers\" class=\"rank-math-link\">Magic Number Code Smell<\/a>. <\/p>\n\n\n\n<h3>Avoid using &#8220;magic numbers&#8221;<\/h3>\n\n\n\n<p>Magic numbers are hard-coded numbers inside the code. This is bad for a couple of reasons. <\/p>\n\n\n\n<p>For starters, just like before, it makes the user have to think. Why are we checking for the <code class=\"pragmatic-ways\">int 16<\/code>? Why are we checking for the <code class=\"pragmatic-ways\">int 18<\/code>, or <code class=\"pragmatic-ways\">21<\/code>? Using a number alone gives no context to its meaning without needing to read the surrounding code to fully understand its intent. <\/p>\n\n\n\n<p>Further more, how many other places is this number used? What happens if we need to change this number, we&#8217;d need to find all the hard-coded instances of this number. It becomes very easy to miss, even with a &#8220;Find and Replace&#8221; feature built into your IDE or text editor. It&#8217;s very easy for a <code class=\"pragmatic-ways\">16<\/code> to be hidden inside of a larger number elsewhere in the code, and you unintentionally update this instance too! <\/p>\n\n\n\n<p>Instead of magic numbers, you should create a named constant instead. Let&#8217;s refactor both examples above by creating named constants with descriptive names.<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-3\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ Code Snippet #3<\/span>\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_DRIVING_AGE = <span class=\"hljs-number\">16<\/span>;\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_VOTING_AGE = <span class=\"hljs-number\">18<\/span>;\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_DRINKING_AGE = <span class=\"hljs-number\">21<\/span>;\n\n<span class=\"hljs-keyword\">public<\/span> void printUserCapabilities(int userAge) {\n  <span class=\"hljs-keyword\">if<\/span> (userAge &gt;= MIN_DRIVING_AGE) {\n    System.out.println(<span class=\"hljs-string\">\"User can drive.\"<\/span>);\n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (userAge &gt;= MIN_VOTING_AGE) {\n    System.out.println(<span class=\"hljs-string\">\"User can vote.\"<\/span>); \n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (userAge &gt;= MIN_DRINKING_AGE) {\n    System.out.println(<span class=\"hljs-string\">\"User can drink.\"<\/span>);\n  }\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-3\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>The above example has updated the int user variable to int userAge, which gives a lot more context into its intent. In addition to the argument name improvement, it also has a more appropriate function name itself. The function name <code class=\"pragmatic-ways\">print<\/code> was rather ambiguous, but <code class=\"pragmatic-ways\">printUserCapabilities<\/code> helps tell this function&#8217;s story a little better.<\/p>\n\n\n\n<p>It also has created named constants with meaningful variable names, which further helps with the readability of this function. It&#8217;s getting easier to actually read this function like a story. But there&#8217;s still more work we can do, by breaking this function up into more functions!<\/p>\n\n\n\n<h2>Focus on creating more functions<\/h2>\n\n\n\n<p>I&#8217;m a big fan of creating smaller, very targeted functions. In general, I aim to make sure my functions don&#8217;t go over 25 lines each. However, 25 lines is getting pretty long. Some people will feel that 25 lines is crazy for a function, and would rather see only 10 lines maximum per function. Others shoot for 5, or even 2-3. <\/p>\n\n\n\n<p>There&#8217;s no right answer here. In general, functions should be as long as they need to be. But more often than not, you should be able to accomplish what you need to within 10-20 lines. To achieve this, it helps to break down large functions into smaller functions!<\/p>\n\n\n\n<h3>Replace conditionals with functions<\/h3>\n\n\n\n<p>If we look at Code Snippet #3 from above, we see that this function is really doing 3 things. It&#8217;s printing the user&#8217;s capability of being able to drive if the user is of driving age, then same for voting age, and same for drinking age. <\/p>\n\n\n\n<p>This presents  a great opportunity to extract out this logic into their own named functions (which will also help with readability).<\/p>\n\n\n\n<p>Exacting conditional logic can help tremendously with readability, especially when there are multiple, complex conditionals within one <code class=\"pragmatic-ways\">if<\/code> statement. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-4\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><div><code lang=\"java\" class=\"hljs language-javascript language-java\"><span class=\"hljs-comment\">\/\/ too many conditionals in one if statement<\/span>\n<span class=\"hljs-keyword\">if<\/span> (userAge &gt;= <span class=\"hljs-number\">16<\/span> &amp;&amp; userHasSubmittedApplicationState.equals(<span class=\"hljs-string\">\"submitted\"<\/span>) &amp;&amp; usersHoursOfDrivingEducation &gt;= <span class=\"hljs-number\">30<\/span> &amp;&amp; userKnowledgeTestScore &gt; <span class=\"hljs-number\">79<\/span> &amp;&amp; userRoadTestPoints &gt; <span class=\"hljs-number\">89<\/span>) {\n  ...\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-4\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-5\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ conditionals replaced with functions<\/span>\n<span class=\"hljs-keyword\">if<\/span> (userMetAllDrivingRequirements()) {\n  ...\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userMetAllDrivingRequirements() {\n  <span class=\"hljs-keyword\">return<\/span> \n    userIsOfDrivingAge() &amp;&amp;\n    userHasSubmittedApplication() &amp;&amp;\n    userMetMinimumHoursOfDrivingEducation()\n    userPassedKnowledgeTest() &amp;&amp;\n    userPassedRoadTest();\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userIsOfDrivingAge() {\n  <span class=\"hljs-keyword\">return<\/span> userAge &gt;= MIN_DRIVING_AGE; \n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userHasSubmittedApplication() {\n  <span class=\"hljs-keyword\">return<\/span> userHasSubmittedApplicationState.equals(<span class=\"hljs-string\">\"submitted\"<\/span>);\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userMetMinimumHoursOfDrivingEducation() {\n  <span class=\"hljs-keyword\">final<\/span> int MINIMUM_REQUIRED_HOURS = <span class=\"hljs-number\">30<\/span>;\n  <span class=\"hljs-keyword\">return<\/span> usersHoursOfDrivingEducation &gt;= MINIMUM_REQUIRED_HOURS;\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userPassedKnowledgeTest() {\n  <span class=\"hljs-keyword\">final<\/span> int MINIMUM_REQUIRED_SCORE = <span class=\"hljs-number\">80<\/span>;\n  <span class=\"hljs-keyword\">return<\/span> userKnowledgeTestScore &gt;= MINIMUM_REQUIRED_SCORE;\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userPassedRoadTest() {\n  <span class=\"hljs-keyword\">final<\/span> int MINIMUM_REQUIRED_SCORE = <span class=\"hljs-number\">90<\/span>;\n  <span class=\"hljs-keyword\">return<\/span> userRoadTestPoints &gt;= MINIMUM_REQUIRED_SCORE;\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-5\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<h3>Replace comments with functions<\/h3>\n\n\n\n<p>Many times, we will see comments in the code explaining the purpose of the code. Let&#8217;s look at back at Code Snippet #1 and assume that the developer at least added a comment to help explain it&#8217;s intent<\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-6\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ Code Snippet #1.1<\/span>\n<span class=\"hljs-keyword\">public<\/span> void <span class=\"hljs-keyword\">print<\/span>(int user) {\n  <span class=\"hljs-comment\">\/\/ check if the users age is at least the minimum driving age<\/span>\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= a) {\n    System.out.println(<span class=\"hljs-string\">\"User can drive.\"<\/span>);\n  }\n  <span class=\"hljs-comment\">\/\/ check if the users age is at least the minimum voting age<\/span>\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= b) {\n    System.out.println(<span class=\"hljs-string\">\"User can vote.\"<\/span>);\n  }\n  <span class=\"hljs-comment\">\/\/ check if the users age is at least the minimum drinking age<\/span>\n  <span class=\"hljs-keyword\">if<\/span> (user &gt;= c) {\n    System.out.println(<span class=\"hljs-string\">\"User can drink.\"<\/span>);\n  }\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-6\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>Comments like this, while with good intentions, end up just polluting the entire program. Why even go through the trouble of making this long comment when a properly named function would&#8217;ve done just as well, if not better. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-7\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-comment\">\/\/ Code Snippet #4<\/span>\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_DRIVING_AGE = <span class=\"hljs-number\">16<\/span>;\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_VOTING_AGE = <span class=\"hljs-number\">18<\/span>;\n<span class=\"hljs-keyword\">static<\/span> <span class=\"hljs-keyword\">final<\/span> int MIN_DRINKING_AGE = <span class=\"hljs-number\">21<\/span>;\n\n<span class=\"hljs-keyword\">public<\/span> void printUserCapabilities(int userAge) {\n  <span class=\"hljs-keyword\">if<\/span> (userIsOfDrivingAge(userAge)) {\n    System.out.println(<span class=\"hljs-string\">\"User can drive.\"<\/span>);\n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (userIsOfVotingAge(userAge)) {\n    System.out.println(<span class=\"hljs-string\">\"User can vote.\"<\/span>); \n  }\n\n  <span class=\"hljs-keyword\">if<\/span> (userIsOfDrinkingAge(userAge)) {\n    System.out.println(<span class=\"hljs-string\">\"User can drink.\"<\/span>);\n  }\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userIsOfDrivingAge(int userAge) {\n  <span class=\"hljs-keyword\">return<\/span> userAge &gt;= MIN_DRIVING_AGE;\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userIsOfVotingAge(int userAge) {\n  <span class=\"hljs-keyword\">return<\/span> userAge &gt;= MIN_DRIVING_AGE;\n}\n\n<span class=\"hljs-keyword\">private<\/span> boolean userIsOfDrinkingAge(int userAge) {\n  <span class=\"hljs-keyword\">return<\/span> userAge &gt;= MIN_DRIVING_AGE;\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-7\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>By creating these functions, we&#8217;re further abstracting the implementation logic from the higher-level <code class=\"pragmatic-ways\">printUserCapabilities<\/code> function, making it that much easier to read it like a story. Further more, the function name is descriptive enough to not even need a comment to explain its intent. <\/p>\n\n\n\n<h2>Create functions with less arguments<\/h2>\n\n\n\n<p>Here&#8217;s a bold statement that I firmly stand by: functions should have no more than 2 arguments. <\/p>\n\n\n\n<p>Thinking back to my grade-school algebra class, I learned that functions take in an input, do something to that input, and produce an output. <\/p>\n\n\n<pre class=\"wp-block-code\"><div><code class=\"hljs \">f(x) = 2x + 2<\/code><\/div><\/pre>\n\n\n<p>It&#8217;s a simple concept really, and it should stay as such. Yet somehow I continue to come across functions with 4 or more arguments. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-8\" data-shcb-language-name=\"JavaScript\" data-shcb-language-slug=\"javascript\"><div><code lang=\"java\" class=\"hljs language-javascript language-java\">public <span class=\"hljs-keyword\">void<\/span> logMessage(<span class=\"hljs-built_in\">String<\/span> message, <span class=\"hljs-built_in\">String<\/span> errorDescription, int requestTypeCode, <span class=\"hljs-built_in\">Date<\/span> dateRequested, int userId) {\n  ...\n} <\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-8\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">JavaScript<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">javascript<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>The more arguments a function has, the more confusing it tends to be. It requires more mental mapping. It requires the person who needs to implement that function to remember which position to include which parameter in. Given the above logMessage example, the developer needs to remember that the general logging message is the first position and the error description is in the second position. But why, what happens if the developer accidentally switches the two, and puts the error message first?<\/p>\n\n\n\n<p>If you&#8217;re creating a function that needs to perform some sort of logic on more than 2 variables, then those variable would probably benefit by being grouped together in their own class. <\/p>\n\n\n<pre class=\"wp-block-code\" aria-describedby=\"shcb-language-9\" data-shcb-language-name=\"PHP\" data-shcb-language-slug=\"php\"><div><code lang=\"java\" class=\"hljs language-php language-java\"><span class=\"hljs-keyword\">public<\/span> <span class=\"hljs-class\"><span class=\"hljs-keyword\">class<\/span> <span class=\"hljs-title\">LoggerMessage<\/span> <\/span>{\n  <span class=\"hljs-keyword\">private<\/span> String message;\n  <span class=\"hljs-keyword\">private<\/span> String errorDescription;\n  <span class=\"hljs-keyword\">private<\/span> int requestTypeCode;\n  <span class=\"hljs-keyword\">private<\/span> Date dateRequested;\n  <span class=\"hljs-keyword\">private<\/span> int userId;\n\n  <span class=\"hljs-comment\">\/\/ getters and setters<\/span>\n  ...\n}\n\n...\n\n<span class=\"hljs-keyword\">public<\/span> void logMessage(LoggerMessage message) {\n  ...\n}<\/code><\/div><small class=\"shcb-language\" id=\"shcb-language-9\"><span class=\"shcb-language__label\">Code language:<\/span> <span class=\"shcb-language__name\">PHP<\/span> <span class=\"shcb-language__paren\">(<\/span><span class=\"shcb-language__slug\">php<\/span><span class=\"shcb-language__paren\">)<\/span><\/small><\/pre>\n\n\n<p>By grouping the 5 variables together in a <code class=\"pragmatic-ways\">LoggerMessage<\/code> class, we eliminate the need for the mental mapping when using the logMessage function now. Now it&#8217;s just a matter of creating an instance of <code class=\"pragmatic-ways\">LogMessage<\/code> and passing in 1 argument to the function. <\/p>\n\n\n\n<h2>Create small classes<\/h2>\n\n\n\n<p>I think we&#8217;re seeing a trend here. Smaller is better when it comes to code. Smaller functions, smaller parameter lists, smaller classes, smaller file sizes, etc. Smaller code equals a smaller chance of bugs. It equals a smaller amount of time to debug and maintain. All of this &#8220;smallness&#8221; equates to a dollar amount. Smaller code essentially equals smaller cost for the company. <\/p>\n\n\n\n<p>Every class you create should handle one responsibility and one responsibility only (are you familiar with the <a href=\"http:\/\/pragmaticways.com\/5-solid-principles-all-software-engineers-need-to-follow\/#Single_Responsibility_Principle\" class=\"rank-math-link\">Single Responsibility Principle<\/a>?)<\/p>\n\n\n\n<p>Another way to think about it, create a class that will only have one reason to change in the future. <\/p>\n\n\n\n<p>I just recently refactored a project that contains a very large questionnaire. There several different features to this questionnaire, such as the ability to start a new blank questionnaire, copy an old questionnaire into a new questionnaire, save a questionnaire, submit the questionnaire for review, etc. <\/p>\n\n\n\n<p>The reason I wanted to refactor this project is because all of these features were contained inside 1 giant <a href=\"http:\/\/pragmaticways.com\/31-code-smells-you-must-know\/#7_Large_Class\" class=\"rank-math-link\">super class<\/a> that handled all of this logic, called <code class=\"pragmatic-ways\">QuestionnaireService<\/code>. This class was over 1000 lines long! <\/p>\n\n\n\n<p>If we take into account our Single Responsibility Principle, this <code class=\"pragmatic-ways\">QuestionnaireService<\/code> class essentially has many reasons to change. If the process to submit a questionnaire needs to change, we need to update the class. If the process to copy a questionnaire ever changes, we&#8217;d again need to update this class. etc. etc. <\/p>\n\n\n\n<p>So during refactoring, I broke up this class into separate, smaller classes with more targeted scopes, such as <code class=\"pragmatic-ways\">NewBlankQuestionnaireService<\/code>, <code class=\"pragmatic-ways\">CopyOldQuestionnaireService<\/code>, <code class=\"pragmatic-ways\">SaveQuestionnaireService<\/code>, <code class=\"pragmatic-ways\">SubmitQuestionnaireService<\/code>. <\/p>\n\n\n\n<p>All of these classes do still share similar functions though, so instead of duplicating all of this logic, they all extend and inherit from the common <code class=\"pragmatic-ways\">QuestionnaireService<\/code> class to share this common logic. <\/p>\n\n\n\n<p>This allows the main <code class=\"pragmatic-ways\">QuestionnaireService<\/code> class to contain all the shared functions. But functions that are only relevant to submitting a questionnaire were contained inside the <code class=\"pragmatic-ways\">SubmitQuestionnaireService<\/code> class. Functions that were only relevant to copying a questionnaire were only inside of the <code class=\"pragmatic-ways\">CopyOldQuestionnaireService<\/code> class. <\/p>\n\n\n\n<p>This refactoring effort of breaking up the large super class into separate smaller classes made the code a lot easier to read, understand, and maintain. Each class is now only about 200 lines long each!<\/p>\n\n\n\n<p>It may seem like overkill in a sense, I have 5 classes all dealing with the same questionnaire. I suppose that&#8217;s just a school of thought though. I&#8217;m going to paraphrase one of Robert Martin&#8217;s thoughts on this concept of many small classes instead of a few large classes:<\/p>\n\n\n\n<p>If you have a collection of tools, would you prefer to have one large drawer where you throw all your tools in, or would you rather have your tools organized into many small drawers each containing well-defined labels? <\/p>\n\n\n\n<h2>Delete all dead (or commented out) code <\/h2>\n\n\n\n<p>I believe Jeff Atwood says it best:<\/p>\n\n\n\n<blockquote class=\"wp-block-quote\"><p>Ruthlessly delete code that isn&#8217;t being used. That&#8217;s why we have source control systems!<\/p><cite>Jeff Atwood &#8211; Co-founder of Stack Overflow and Discourse and Blogger of <a href=\"https:\/\/blog.codinghorror.com\/code-smells\/\" class=\"rank-math-link\">Coding Horror<\/a><\/cite><\/blockquote>\n\n\n\n<p>Dead code lives in the form of not only code that&#8217;s not being used, but also as commented out code. <\/p>\n\n\n\n<p>I&#8217;ve seen the later a lot so far in my career (and to be honest, I used to do it a lot myself too!). <\/p>\n\n\n\n<p>During a refactoring or technology migration effort, we write the new functions but comment out the old code to A) keep as a reference to ensure we coded it correctly and B) in case we need to roll back the changes, we could easily just un-comment out the code. <\/p>\n\n\n\n<p>I learned this practice from a (at the time) more senior developer than me, when I was still in my junior developer days. (I have since banned myself from the practice, and mentor others to follow along). <\/p>\n\n\n\n<p>Like Jeff Atwood mentions, we use source\/ version control systems for this exact reason! Commented out code and dead code just clutters the files, making them unnecessarily longer.<\/p>\n\n\n\n<p>Future developers of the project become too scared to delete the code in fear that it will break something if they do. Or they may see a function commented out and begin to question if it&#8217;s supposed to be commented out in the first place. <\/p>\n\n\n\n<p>&#8220;Why is this commented out?&#8221; &#8220;Did someone forget to uncomment it?&#8221; &#8220;Should I uncomment it?&#8221; &#8220;Is it needed?&#8221; &#8220;Why am I here?&#8221;<\/p>\n\n\n\n<p>During the major refactoring effort I mentioned before, I came across a very, very large SQL constants file. I hated this file. This file was over 6000 lines long, consisting of nothing but <code class=\"pragmatic-ways\">public final static String <\/code>queries. This one file consisted of probably 80% of all the queries for the entire application. In one file. Where probably 50% of the queries in here were old, obsolete, dead code that was no longer being used! <\/p>\n\n\n\n<p>It took me a good while to scrub through this file, removing the queries that were no longer needed, and more importantly removing these queries from this file into a more appropriate file. <\/p>\n\n\n\n<p>What I did was moved the queries into their appropriate DAO interfaces instead of <code class=\"pragmatic-ways\">private final static String<\/code> queries. By doing this, it is now tremendously easier to tell when one of these queries has been re-written into a new function and the old query is no longer needed. Since it&#8217;s a private variable, the IDE now informs us when the variable isn&#8217;t being used anymore. This gives any future programmer the absolute confidence that they may safely delete this function if it is in fact dead code. <\/p>\n\n\n\n<h2>Conclusion<\/h2>\n\n\n\n<p>Writing better code that&#8217;s clean and easy to understand is different than writing code that works. There are some quick and easy things you can start doing right now to write better code that will impress your team. <\/p>\n\n\n\n<ol><li>Take your time to think of very descriptive variable names, function names, and class names. Don&#8217;t use ambiguous names that have no context. It should be very simple to understand what a variable\/function\/class is used for by its name alone. <\/li><li>Break down large functions into smaller functions with descriptive names. Replace complex conditionals and comments with functions when appropriate. <\/li><li>Limit function signatures to no more than 2 arguments. If a function needs 3 or more parameters, consider grouping those variables into their own class. <\/li><li>Create small and targeted classes with one specific responsibility. The smaller the class, the better. <\/li><li>Delete all dead code and commented out code. Make it a habit. <\/li><\/ol>\n\n\n\n<h3>Where to go from here?<\/h3>\n\n\n\n<p>This blog really just stratches of surface of learning how to write better code that&#8217;s clean and easy to understand and maintain. If you really want to take your clean code skills to the next level and impress your development team during code reviews, then I&#8217;d highly suggest you get Robert Martin&#8217;s book on Clean Code. You can use my affiliate link to purchase a copy for yourself here:<\/p>\n\n\n\n<span style=\"font-size: 22px;max-width: 200px;display: inline-block;height: 240px;vertical-align: top;margin: 0;\"><span style=\"display: table-cell;vertical-align: middle;height: 240px; font-weight: bold; padding: 2px\">Every software engineer must read this book &gt;&gt;<\/span><\/span><iframe style=\"width:120px;height:240px;\" marginwidth=\"0\" marginheight=\"0\" scrolling=\"no\" frameborder=\"0\" src=\"\/\/ws-na.amazon-adsystem.com\/widgets\/q?ServiceVersion=20070822&amp;OneJS=1&amp;Operation=GetAdHtml&amp;MarketPlace=US&amp;source=ac&amp;ref=tf_til&amp;ad_type=product_link&amp;tracking_id=selftaughtadu-20&amp;marketplace=amazon&amp;region=US&amp;placement=0132350882&amp;asins=0132350882&amp;linkId=7f65c4d0b47f42083c754c591b950f06&amp;show_border=true&amp;link_opens_in_new_window=true&amp;price_color=333333&amp;title_color=0066c0&amp;bg_color=ffffff\"><\/iframe>\n","protected":false},"excerpt":{"rendered":"<p>It is my firm belief that the most important aspect of writing code is writing code that&#8217;s easy to read, easy to understand, and easy to maintain. Here are 5<\/p>\n","protected":false},"author":1,"featured_media":501,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":[],"categories":[33,32,42],"tags":[],"_links":{"self":[{"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/posts\/455"}],"collection":[{"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/comments?post=455"}],"version-history":[{"count":0,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/posts\/455\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/media\/501"}],"wp:attachment":[{"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/media?parent=455"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/categories?post=455"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/pragmaticways.com\/wp-json\/wp\/v2\/tags?post=455"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}