<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Clean Code on Code4IT</title>
    <link>https://www.code4it.dev/tags/clean-code/</link>
    <description>Recent content in Clean Code on Code4IT</description>
    <generator>Hugo -- gohugo.io</generator>
    <lastBuildDate>Tue, 15 Nov 2022 00:00:00 +0000</lastBuildDate><atom:link href="https://www.code4it.dev/tags/clean-code/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Clean Code Tip: Methods should have a coherent level of abstraction</title>
      <link>https://www.code4it.dev/cleancodetips/coherent-levels-of-abstraction/</link>
      <pubDate>Tue, 15 Nov 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/coherent-levels-of-abstraction/</guid>
      <description>Don&amp;rsquo;t let the reader get lost in the code details!</description>
    </item>
    
    <item>
      <title>Clean Code Tip: DRY or not DRY?</title>
      <link>https://www.code4it.dev/cleancodetips/dry-or-not-dry/</link>
      <pubDate>Tue, 11 Oct 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/dry-or-not-dry/</guid>
      <description>DRY is a fundamental principle in software development. Should you apply it blindly?</description>
    </item>
    
    <item>
      <title>Clean Code Tip: throw exceptions instead of returning null when there is no fallback</title>
      <link>https://www.code4it.dev/cleancodetips/exceptions-instead-of-null/</link>
      <pubDate>Tue, 27 Sep 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/exceptions-instead-of-null/</guid>
      <description>In case of unmanageable error, should you return null or throw exceptions?</description>
    </item>
    
    <item>
      <title>Clean Code Tip: F.I.R.S.T. acronym for better unit tests</title>
      <link>https://www.code4it.dev/cleancodetips/f-i-r-s-t-unit-tests/</link>
      <pubDate>Tue, 26 Jul 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/f-i-r-s-t-unit-tests/</guid>
      <description>Good unit tests have some properties in common: they are Fast, Independent, Repeatable, Self-validating, and Thorough. In a word: FIRST!</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Avoid subtle duplication of code and logic</title>
      <link>https://www.code4it.dev/cleancodetips/avoid-subtle-duplication/</link>
      <pubDate>Tue, 28 Jun 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/avoid-subtle-duplication/</guid>
      <description>Duplication is not only about lines of code, but also about data usage and meaning. You should avoid that kind of duplication.</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Tests should be even more well-written than production code</title>
      <link>https://www.code4it.dev/cleancodetips/tests-should-be-readable-too/</link>
      <pubDate>Tue, 24 May 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/tests-should-be-readable-too/</guid>
      <description>Should you write your tests with the same care you write the production code? Of course you should! But what does it mean?</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Avoid using too many Imports in your classes</title>
      <link>https://www.code4it.dev/cleancodetips/too-many-imports/</link>
      <pubDate>Tue, 19 Apr 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/too-many-imports/</guid>
      <description>Having too many &amp;lsquo;using&amp;rsquo;s, or imports, is a good indicator that your class does too many things. You should work to reduce the number of dependencies of a class.</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Not all comments are bad</title>
      <link>https://www.code4it.dev/cleancodetips/good-comments/</link>
      <pubDate>Tue, 22 Mar 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/good-comments/</guid>
      <description>Is it true that we should always avoid comments in our code? In my opinion, no: let&amp;rsquo;s see when adding comments is not only good but necessary.</description>
    </item>
    
    <item>
      <title>Clean Code Tip: AAA pattern for tests: why is it important?</title>
      <link>https://www.code4it.dev/cleancodetips/aaa-pattern-for-tests/</link>
      <pubDate>Tue, 22 Feb 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/aaa-pattern-for-tests/</guid>
      <description>The most important trait of Tests? They must be correct. The second one? They must be readable. The AAA pattern helps you write better tests.</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Avoid mental mappings</title>
      <link>https://www.code4it.dev/cleancodetips/avoid-mental-mappings/</link>
      <pubDate>Tue, 25 Jan 2022 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/avoid-mental-mappings/</guid>
      <description>Mental mappings are a good way to write shorter code that you, and only you, can understand. Prefer clarity over brevity!</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Keep the parameters in a consistent order</title>
      <link>https://www.code4it.dev/cleancodetips/consistent-of-parameters/</link>
      <pubDate>Tue, 30 Nov 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/consistent-of-parameters/</guid>
      <description>Following a coherent standard, even for parameters order, helps developers when writing and, even more, reading code. How to do that?</description>
    </item>
    
    <item>
      <title>Clean Code Tip: Don&#39;t use too many method arguments</title>
      <link>https://www.code4it.dev/cleancodetips/too-many-method-arguments/</link>
      <pubDate>Tue, 02 Nov 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/too-many-method-arguments/</guid>
      <description>When a function has too many parameters, it&amp;rsquo;s clear that something is wrong. But&amp;hellip; why? What are the consequences of having too many parameters?</description>
    </item>
    
    <item>
      <title>Clean code tip: use the same name for the same concept</title>
      <link>https://www.code4it.dev/cleancodetips/use-same-name-for-same-concept/</link>
      <pubDate>Tue, 05 Oct 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/use-same-name-for-same-concept/</guid>
      <description>Smaller functions help us write better code, but have also a nice side effect: they help us to understand where an exception was thrown. Let&amp;rsquo;s see how!</description>
    </item>
    
    <item>
      <title>Clean code tip: small functions bring smarter exceptions</title>
      <link>https://www.code4it.dev/cleancodetips/smaller-functions-smarter-exceptions/</link>
      <pubDate>Tue, 17 Aug 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/smaller-functions-smarter-exceptions/</guid>
      <description>Smaller functions help us write better code, but have also a nice side effect: they help us to understand where an exception was thrown. Let&amp;rsquo;s see how!</description>
    </item>
    
    <item>
      <title>Code opinion: performance or clean code?</title>
      <link>https://www.code4it.dev/blog/clean-code-vs-performance/</link>
      <pubDate>Tue, 27 Jul 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-vs-performance/</guid>
      <description>In any application, writing code that is clean and performant is crucial. But we often can&amp;rsquo;t have both. What to choose?</description>
    </item>
    
    <item>
      <title>Clean code tip: Use pronounceable and searchable names</title>
      <link>https://www.code4it.dev/cleancodetips/use-pronounceable-names/</link>
      <pubDate>Tue, 20 Jul 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/use-pronounceable-names/</guid>
      <description>Two of the operations you often do with your code is to discuss it, or perform a search over it. So using good names will help in both situations.</description>
    </item>
    
    <item>
      <title>Clean code tip: Principle of Least Surprise</title>
      <link>https://www.code4it.dev/cleancodetips/principle-of-least-surprise/</link>
      <pubDate>Tue, 22 Jun 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/principle-of-least-surprise/</guid>
      <description>The Principle of Least Surprise is a simple principle that helps you writing clear, obvious code: this helps other developers foresee what a component does without worrying of unexpected behaviors.</description>
    </item>
    
    <item>
      <title>Clean code tip: How to choose meaningful names?</title>
      <link>https://www.code4it.dev/cleancodetips/choose-meaningful-names/</link>
      <pubDate>Tue, 25 May 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/cleancodetips/choose-meaningful-names/</guid>
      <description>Choosing meaningful names takes time! Time spent finding good names is time saved trying to figure out what you meant.</description>
    </item>
    
    <item>
      <title>Clean code tips - Tests</title>
      <link>https://www.code4it.dev/blog/clean-code-tests/</link>
      <pubDate>Tue, 23 Mar 2021 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-tests/</guid>
      <description>Tests are as important as production code. Well, they are even more important! So writing them well brings lots of benefits to your projects.</description>
    </item>
    
    <item>
      <title>Clean code tips - Error handling</title>
      <link>https://www.code4it.dev/blog/clean-code-error-handling/</link>
      <pubDate>Tue, 15 Dec 2020 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-error-handling/</guid>
      <description>The way you handle errors on your code can have a huge impact on the maintainability of your projects. Don&amp;rsquo;t underestimate the power of clean error handling.</description>
    </item>
    
    <item>
      <title>Clean code tips - Abstraction and objects</title>
      <link>https://www.code4it.dev/blog/clean-code-abstraction-and-objects/</link>
      <pubDate>Tue, 20 Oct 2020 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-abstraction-and-objects/</guid>
      <description>Are Getters and Setters the correct way to think of abstraction? What are pro and cons of OOP and Procedural programming? And, in the OOP world, how can you define objects?</description>
    </item>
    
    <item>
      <title>Clean code tips - comments and formatting</title>
      <link>https://www.code4it.dev/blog/clean-code-comments-and-formatting/</link>
      <pubDate>Tue, 18 Aug 2020 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-comments-and-formatting/</guid>
      <description>Are all comments bad? When they are necessary? Why formatting is so important? Writing clean code does not only refer to the executed code, but also to everything around.</description>
    </item>
    
    <item>
      <title>Clean code tips - names and functions</title>
      <link>https://www.code4it.dev/blog/clean-code-names-and-functions/</link>
      <pubDate>Tue, 21 Jul 2020 00:00:00 +0000</pubDate>
      
      <guid>https://www.code4it.dev/blog/clean-code-names-and-functions/</guid>
      <description>I don&amp;rsquo;t have to tell you why you need to write clean code. Here you&amp;rsquo;ll see some tips about how to name things and how to structure functions.</description>
    </item>
    
  </channel>
</rss>
