<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Cleancode-tips on Code4IT</title>
    <link>https://www.code4it.dev/cleancode-tip/</link>
    <description>Recent content in Cleancode-tips 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/cleancode-tip/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>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>
    
  </channel>
</rss>
