
<h4>A look into the hierarchy of log levels in Software Engineering. What they mean, as well as some practical use cases.</h4>
<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*2-zjQaIsF4S8FtZV"><figcaption>Photo by <a href="https://unsplash.com/@cgower?utm_source=medium&amp;utm_medium=referral">Christopher Gower</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Monitoring is an essential part of quality software engineering. It helps us know if and when something goes wrong in our software.</p>
<p>In the case something goes wrong; if we know where to look, we can find out what is wrong; debugging and troubleshooting will become a hundred times easier — this is where logging comes in.</p>
<p>Every good programming language/framework has support for logging. If you’re reading this article, chances are, you wish to find out what log level to use when logging out certain information.</p>
<p>In this article, we’ll take a look at the entire hierarchy, learn what each level means, as well as some appropriate use-cases.</p>
<h3>Log Level Order</h3>
<ol>
<li><strong>Trace</strong></li>
<li><strong>Debug</strong></li>
<li><strong>Information</strong></li>
<li><strong>Warning</strong></li>
<li><strong>Error</strong></li>
<li>
<strong>Critical</strong> (or Fatal)</li>
</ol>
<h3>What Each Log Level Means</h3>
<p>Before delving further, it is important to know that an application will log out anything falling above, or matching the set loglevel.</p>
<h4>Trace</h4>
<p>This log level captures all the details about an application. Trace is mostly used to identify issues with a program. This level is ideal when you need to see what happened in your program or perhaps, identify what happened in a third-party library you used. Trace ideally shows every single step in an algorithmic process.</p>
<h4>Debug</h4>
<p>This level is a bit higher up the hierarchy than Trace. Think of this, as showing the result of some <strong>crucial </strong>computation. When something goes wrong, this is the level most developers will look, so be sure to log out the results of crucial computations and steps here. If something could potentially go wrong, a good practice, is to log out statements before and after the step, at Debug level.</p>
<h4>Information</h4>
<p>This is the standard log level. At this level, we generally give updates about state changes in an application. While it’s difficult to draw a fine line between Debug and Information levels, a good rule of thumb in deeming something fit for the Information level, is if they are not things to be worried about. A good fit for an information-level log, will be logging out a message, when a record is saved in a database, or when a request is received in an API Controller, or a response is returned.</p>
<h4>Warning</h4>
<p>This level is used to show when you have detected something not usual about the application, but at the same time is not an error, neither is it fatal to the program. This could include things like an out-of-date library, or a vulnerability with a package.</p>
<h4>Error</h4>
<p>At this level, developers will be able to view the exception messages their applications and programs encountered. As not all exceptions are fatal for a program, at this level, we want to log the non-fatal exceptions. Examples of this may include “ArgumentException”, “ValueException”, “NullPointerError”, etc.</p>
<h4><strong>Critical (or Fatal)</strong></h4>
<p>This is the highest log level. Here, all the developers would see, are the reasons an application or program exited unexpectedly. This may be when the operating system manually closes a program, or a user manually closes a program abruptly.</p>
<p><em>Till next time, compadre!</em></p>
<img src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=8758bbbd0686" width="1" height="1" alt="">


A look into the hierarchy of log levels in Software Engineering. What they mean, as well as some practical use cases.

Log Level Hierarchy

<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*7PLF5_fdmmyDnaEU" /><figcaption>Photo by <a href="https://unsplash.com/@efekurnaz?utm_source=medium&amp;utm_medium=referral">Efe Kurnaz</a> on <a href="https://unsplash.com?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>It could be confusing to differentiate between the two major delegate types in C# — Func and Action, due to their similar syntax and parent type. While both delegate types could receive arrow functions or method group values, the difference lies in what they are expected (or not expected) to return. Func methods are expected to return a value while Action methods are expected to be void.</p><p>In this article, we would explore the differences between the two delegate types as well as appropriate use-cases.</p><p>To understand the two types, we need to first understand what a delegate is and how it is intended to be used.</p><h3>What are Delegates in C#</h3><p>Delegates (simply put) help us assign methods to variables. As such, a delegate could be used to pass a method as a parameter to other methods.</p><p>For the sake of <a href="https://www.freecodecamp.org/news/orthogonality-in-software-engineering/#:~:text=Orthogonality%20is%20a%20software%20design,a%20term%20borrowed%20from%20mathematics.">orthogonality</a>, we sometimes have the need to pass a method, based on some criteria to an executing method to invoke — and that’s where delegates come in.</p><p>Delegates can be declared at namespace-level. They are also used for callbacks. It is also possible to have either arrow functions or class methods assigned to a delegate. There is also support for chaining delegate callbacks, provided they have the same signatures.</p><p>Declaring a delegate is similar to declaring a class in C#. Take this for example.</p><pre>public class DelegateExample<br />{<br />    public delegate string Greet();<br />  <br />    public DelegateExample()<br />    {<br />        Greet greet = this.SayHelloWorld;<br />        greet();<br />    }<br />  <br />    private string SayHelloWorld()<br />    {<br />        return &quot;Hello world&quot;;<br />    }<br />}</pre><h3>Func in C#</h3><p><strong>The last type parameter in a </strong>Func<strong> declaration is the type of the output value. </strong>As we know, a Func must return a value.<strong> </strong>So,<strong> we must always have at least one type parameter</strong>.</p><p>Let’s see a simple example of a Func in C#.</p><pre>public class FuncExampleOne<br />{<br />    Func&lt;string&gt; Greet;<br />  <br />    public FuncExampleOne()<br />    {<br />        Greet = this.GreetUserInEnglish;<br />        Greet();<br />    }<br />  <br />    public string GreetUserInEnglish()<br />    {<br />        return &quot;Hello! How are do you today&quot;;<br />    }<br />}</pre><p>In the example above, we have a method GreetUserInEnglish which returns a string. We then assign it to a Func&lt;string&gt; variable, which we later invoke right before exiting the constructor.</p><p>Let’s take another example of a Func, taking a number parameter and returning a string output.</p><pre>public class FuncExampleTwo<br />{<br />    Func&lt;int, string&gt; SayTemperature;<br /><br />    public FuncExampleTwo()<br />    {<br />        SayTemperature = this.GiveTemperatureSummary;<br />        Console.WriteLine(SayTemperature(30));<br />    }<br />    <br />    public string GiveTemperatureSummary(int temp)<br />    {<br />        return $&quot;It's {temp} degrees outside.&quot;;<br />    }<br />}</pre><p>A Func variable could also be an arrow function and we could pass a Func variable as a parameter to other methods, as we see the example below.</p><pre>public class FuncExampleThree<br />{   <br />    public FuncExampleThree()<br />    {<br />        Func&lt;int, string&gt; GetFriendlyTemp = (int temp) =&gt;<br />        {<br />            return $&quot;It's {temp} degrees outside.&quot;;<br />        };<br />    <br />        DisplayTempText(GetFriendlyTemp);<br />        // It's 30 degrees outside.<br />    }<br />    <br />    public void DisplayTempText(Func&lt;int, string&gt; getFriendlyTemp)<br />    {<br />        Console.WriteLine(getFriendlyTemp());<br />    }<br />}</pre><h3>Action in C#</h3><p>Most of the convention of Func variables also apply to Action. The major difference being that an Action does not return anything. As such, all the type parameters of any Action declaration are of input parameters. In the case where the Action does not accept any parameter, no type parameter is required.</p><p>For example, this would be a valid Action declaration in C#.</p><pre>public class ActionExampleOne {<br />    Action Greet;<br />  <br />    public DelegateExample() {<br />        Greet = this.SayHelloWorld;<br />        Greet();<br />    }<br />  <br />    public void SayHelloWorld() {<br />        Console.WriteLine(&quot;Hello world!&quot;);<br />    }<br />}</pre><p>From the signature of an Action, we can tell that they’ll be perfect for callbacks.</p><p>Another feature unique to Action variables, is the ability to chain them. <strong>We could chain</strong> Action <strong>variables</strong>, so long as they have the same signatures. In this case, the methods will be invoked in the order they were chained.</p><pre>public class ActionChainExample<br />{   <br />    public ActionChainExample()<br />    {<br />        Action&lt;int&gt; GetFriendlyTemp = (int _) =&gt; { };<br />  <br />        GetFriendlyTemp += (int temp) =&gt;<br />        {<br />            Console.Write($&quot;It's {temp} degrees outside.&quot;);<br />        };<br />  <br />        GetFriendlyTemp += (int temp) =&gt;<br />        {<br />            string _season = temp &lt; 40 ? &quot;winter&quot; : &quot;summer&quot;;<br />            Console.Write($&quot; We are in {_season} season!&quot;);<br />        };<br />        <br />        GetFriendlyTemp(45);<br />        // It's 45 degrees outside. We are in summer season!<br />    }<br />}</pre><h3>Conclusion</h3><p>When having to choose between both delegate types, ask yourself the following questions</p><p><strong>What does this method return?<br /></strong>If it returns nothing, use an Action. If you have an async method or a method that returns anything, use a Func.</p><p><strong>Would I have a need to chain this method?<br /></strong>If you would have a need to chain this method, an Action would work better than a Func.</p><p>Thanks for reading! If you found the article helpful, <strong>clap</strong>,<strong> share </strong>and<strong> subscribe.</strong></p><img alt="" height="1" src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=82e4b1965d13" width="1" />

Learn the difference between two major delegate types in C# — Func and Action.

C# Delegates: Difference between Func and Action

<h4>
  Python has no native implementation of interfaces — but that’s where abstract
  classes and abstract methods come into play.
</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*39A3ujujxJZGu-VT"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@cdr6934?utm_source=medium&amp;utm_medium=referral"
      >Chris Ried</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Interfaces are so vital in software engineering, that one of the
  <a
    href="https://www.freecodecamp.org/news/solid-principles-explained-in-plain-english/"
    >SOLID Principles</a
  >
  (the bedrock of quality software design) is solely dedicated to it — <a
    href="https://en.wikipedia.org/wiki/Interface_segregation_principle#:~:text=In%20the%20field%20of%20software,are%20of%20interest%20to%20them."
    >Interface Segregation Principle</a
  >.
</p>
<h3>Why Are Interfaces so Vital in Software Engineering?</h3>
<p>
  Imagine you have a utility class which has a method which you will use
  seventeen times throughout your application. What happens when you change the
  parameters of a method in the utility class, or the output the method returns?
  You would have to refactor all the seventeen references to fit the new
  signature of the method. But, with an interface, the class itself will become
  invalid once there’s a mismatch with the interface’s contract — the class must
  stick with the interface, and have a different method, if it needs to change
  the signature. This way, all the seventeen references of the class are pretty
  much safe in the way they call the utility method.
</p>
<p>Cool, right?</p>
<p>
  Now, at some point in time, we Python-<em>istas</em> have needed a way to
  enforce implementations of certain methods in our classes, and you are
  probably reading this article because you have discovered that there are no
  native implementations of interfaces in Python. <em>Well, not quite so.</em>
</p>
<h3>How Would Interfaces Be Implemented in Python</h3>
<p>
  An <strong>interface</strong> would be implemented in Python as an
  <strong>abstract class</strong>.
</p>
<h4>What Is an Abstract Class</h4>
<p>
  An abstract class is a class which contains one or more abstract methods. An
  abstract method is a method that is declared but has no concrete
  implementation — the implementation is to be done by a derived class.
</p>
<p>
  <strong>The key characteristic of interfaces,</strong>
  <strong
    >is that they enforce the implementation of certain methods in
    classes,</strong
  >
  and by definition of abstract classes, <em>this,</em> is catered for.
</p>
<h4>Declaring an Abstract Class in Python</h4>
<p>
  Python provides an abstract base class module called abc. This module contains
  a helper class called abc.ABC (on which we base our abstract classes), and an
  abc.abstractmethod decorator (with which we mark the methods and properties,
  we want implemented by concrete classes).
</p>
<p>We could define an abstract class in any one of two ways:</p>
<pre>from abc import ABC, ABCMeta<br></pre>
<pre># using the abc.ABCMeta as a metaclass<br>class HumanInterface(metaclass=ABCMeta):<br>    pass</pre>
<pre># inheriting the abc.ABC class<br>class HumanInterface(ABC):<br>    pass</pre>
<p>
  <em
    >The latter is preferred as a shorthand to declaring an abstract class, as </em
  ><em>ABC<br />is a class which already has </em
  ><em
    >ABCMeta as its metaclass, thus it makes room easier for the developer to
    add another metaclass declaration.</em
  >
</p>
<p>Now, let’s add our first interface methods to our HumanInterface.</p>
<pre>
from abc import ABC, abstractmethod

class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass
</pre>
<p>
  We have our interface set in, it is time for a concrete implementation to test
  that our interface method will be enforced.
</p>
<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass

      
class Hispanic(HumanInterface):
    def sing(self):
        pass
    

if __name__ == '__main__':
    Hispanic();
</pre>
<p>
  The Python interpreter throws an error we expect from an interface’s concrete
  implementation.
</p>
<pre>
TypeError: Can’t instantiate abstract class Hispanic with abstract methods greet</pre
>
<p>
  Let us take a look at what happens when we implement the greet method in our
  Hispanic class.
</p>
<pre>
from abc import ABC, abstractmethod


class HumanInterface(ABC):
    @abstractmethod
    def greet(self):
        pass
    
    @abstractmethod
    def exercise(self):
        pass
    
    @abstractmethod
    def introduce_self(self):
        pass
      
      
class Hispanic(HumanInterface):
    def greet(self):
        print("Hola! Como estas?")
        
    def exercise(self):
        print("Comenzando el entrenamiento")
        
    def introduce_self(self):
        print("Me llamo Sam")

        
if __name__ == '__main__':
    Hispanic().greet()
    # Hola! Como estas?
</pre>
<p>
  <strong><em>Pretty neat, right?!</em></strong>
</p>
<p>
  Perhaps, the team behind the Python programming language were well aware of
  the fact that interfaces could be written in Python using abstract classes
  and methods.
</p>
<p>
  In the next <a href="https://tomisin.dev/blog">article</a>, we will be
  comparing and contrasting abstract class and interfaces.
</p>
<p>
  If you found this article useful or learnt something in this article, please
  clap, share and subscribe.
</p>
<p><a href="https://tomisin.dev/subscribe">Subscribe * Tomisin Abiodun</a></p>
<img
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=6d3658d248c"
  width="1"
  height="1"
  alt=""
/>

Python has no native implementation of interfaces — but that’s where abstract classes and abstract methods come into play. Photo by Chris Ried on Unsplash Interfaces are so vital in software engineering, that one of the SOLID Principles (the bedrock of quality software design) is solely dedicated to it — Interface Segregation Principle . Why Are Interfaces so Vital in Software Engineering? Imagine you have a utility class which has a method which you will use seventeen times throughout your application. Wha

How to Implement an Interface in Python

<h4>Know how to use static type checking and type annotation best practices</h4>
<figure>
  <img
    alt=""
    src="https://cdn-images-1.medium.com/max/1024/0*D2pTs4JZKVeT55C9"
  />
  <figcaption>
    Photo by
    <a
      href="https://unsplash.com/@artturijalli?utm_source=medium&amp;utm_medium=referral"
      >Artturi Jalli</a
    >
    on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral"
      >Unsplash</a
    >
  </figcaption>
</figure>
<p>
  Type-checking is one of the foremost features of any modern-day programming
  language; it’s the reason TypeScript was born. Type-checking not only makes a
  codebase easier to extend and work with in general, but it also detects many
  programming errors quickly, reliably and automatically.
</p>
<p>
  First introduced in Python 3.5, <strong>Type Hints</strong> are the primary
  way Python developers annotate types to variables and functions.
</p>
<blockquote>
  <strong>Type Hints — </strong>like the name suggests, do not enforce any type
  checks at the interpreter level. They are designed to be used by developers,
  IDEs, linters, type checkers, etc.
</blockquote>
<p>
  In technical term, <strong>Python has dynamic type checking</strong>, hence
  the types are known at runtime and not compile time (as is the case in static
  type checked languages like C#). Although, it is worth mentioning that the
  Python community has hacked together a
  <a href="http://mypy-lang.org/">variant</a> of the Python interpreter which
  enforces static type checking.
</p>
<p>
  In this article, we will explore how to incorporate Python’s type checking
  into our codebase in ways which would reduce friction in integrating with
  units of the projects.
</p>
<h3>Type Hints Syntax</h3>
<p>
  Python supports type annotation for the basic variable types supported by the
  language str, int, float, bool<strong> </strong>and None. It also comes with a
  typing library batteries included; this typing libraries provides us with
  means to use more special types.
</p>
<h4>Annotating Variables</h4>
<p>
  To indicate the type of a variable in Python, just add a colon-space followed
  by the type (str, int, List[],etc.), right after the variable name.
</p>
<pre>
# type_hints_tutorial.py

from typing import List

name: str = 'Tommy'
age: int = 24
height_in_meters: float = 1.7
colleagues: List[str] = ['Alicia', 'John']
</pre>
<h4>Annotating Functions</h4>
<p>
  The syntax for variable annotation of variables also works for the function
  parameters. However, to indicate the return type, we add an arrow “-&gt;”
  followed by its type.
</p>
<pre>
# type_hints_tutorial.py

from typing import Dict, List

def convert_celcius_to_fahrenheit(celcius_temp: float) -> float:
    return (celcius_temp * 9/5) + 32
  
def send_email(
    subject: str,
    body: str,
    recipients: List[str],
    cache: Dict[str, str]
) -> bool:
  
    # skipped for brevity

    return True # or False
</pre>
<h3>Using Special Types</h3>
<p>
  Now, that we are all warmed up and familiar with the type annotation syntax,
  let us get familiar with more complex types.
</p>
<h4>Any</h4>
<p>
  A variable of type Any is unconstrained. So, such variables are compatible
  with all other types (int, str, List, etc), and all other types are compatible
  with these.
</p>
<pre>
# type_hints_tutorial.py
from typing import Any

result: Any = "SUCCESS"
  
# also works because variables of type Any are compatible other types
result = 10

state: str = "PENDING"

# works because all other types are compatible with type Any.
state = result
</pre>
<h4>Literal</h4>
<p>
  Literals are used to indicate to type checkers that the value a variable or
  function holds, is equal to one of the values specified.
</p>
<pre>
# type_hints_tutorial.py

from typing import Literal


GENDER = Literal["male", "female", "non-conforming"]

def create_user(
    first_name: str,
    last_name: str,
    gender: GENDER,
) -> Dict[str, str]:
    return {
        "first_name": first_name,
        "last_name": last_name,
        "gender": gender
    }

create_user("John", "Bond", "male")
</pre>
<p>
  In the example above, gender will be one of the values in the GENDER literal
  declaration — “male”, “female” or “non-conforming”.
</p>
<h4>Union</h4>
<p>
  Sometimes, a variable may have properties cutting across two type
  declarations. A variable might also be of two types.
</p>
<pre>
# type_hints_tutorials.py

from typing import Union


def get_room_temperature() -> Union[int, float]:
    return 20.8  # 20 also works
</pre>
<h4>TypedDict</h4>
<p>
  Dictionaries being one of the simplest forms of Data Structure in Python, are
  among the most used variable types in the language.
</p>
<p>
  Using a TypedDict could greatly improve the readability of the code especially
  in a large project where there are lots of declarations in lots of places;
  keeping track of <em>what</em> goes <em>where </em>gets hectic as you scale.
</p>
<pre>
# type_hints_tutorials.py
from typing import TypedDict, Union


class Card(TypedDict):
    rank: Union[str, int]
    suit: str

# The Card class now has behaviours of both TypedDict and dict classes

# Card can be used to annotate a variable
ace_of_spade: Card = {'rank': 'A', 'suit': '♤'}

# or can be instantiated
ace_of_spade = Card(rank='A', suit='♤')
</pre>
<h4>NoReturn</h4>
<p>
  NoReturn type is similar to void in other programming languages. It is used to
  declare that a function does not have any return.
</p>
<pre>
# type_hints_tutorials.py
from typing import NoReturn


def say_greeting() -> NoReturn:
    print("Hello World!")
</pre>
<h4>Final</h4>
<p>
  This is a typing construct used to indicate that a variable is not to be
  re-assigned or overridden in a subclass.
</p>
<pre>
# type_hints_tutorials.py
from typing import Final


MIN_NAME_LENGTH: Final = 2

# error flagged by type-checker
MIN_NAME_LENGTH += 1


class Validator(object):
    MIN_NAME_LENGTH: Final[int] = 4


class UserValidator(Validator):
    # this line will be flagged by the interpreter
    MIN_NAME_LENGTH = 3
</pre>
<h3>Using Static Type Checking in Python</h3>
<p>
  Python’s interpreter my default does not enforce type-checking. However, a
  variation of the Python interpreter — mypy, has been created to enforce
  type-checking on the interpreter level.
</p>
<p>You can use mypy in two ways:</p>
<ol>
  <li>Download the mypy command line and use it to run your Python scripts.</li>
  <li>Install the mypy extensions available on VSCode and PyCharm.</li>
</ol>
<h3>Type Annotation Best Practices</h3>
<h4>1. Use of Any</h4>
<p>
  The Any type should only be used when the exact type of the return variable or
  the function parameter is not known to us; this could be when using a third
  party library which does not have type annotations, or using a module without
  type annotations.
</p>
<h4>2. Enable static type-checking</h4>
<p>
  Type checking’s benefits of preventing errors and guiding the developer will
  not be felt as much if it is dynamic. If you are not a fan of the mypy command
  line, you can also install it as a VSCode or PyCharm extension.
</p>
<h4>3. Use tuples for fixed length arrays</h4>
<p>
  Tuples serve a double use as a record. So, when you have a known number of
  items in the array especially when they are not all of the same type, the
  variable is better suited for a tuple type.
</p>
<h4>4. Function return types</h4>
<p>
  Functions should do one thing and one thing only, thus they should have a
  single deterministic type.
</p>
<pre><strong>Want to Connect?</strong></pre>
<pre>Get weekly articles and coding tricks by <a href="https://tomisin.dev/subscribe">subscribing to my newsletter</a>.</pre>
<img
  src="https://medium.com/_/stat?event=post.clientViewed&amp;referrerSource=full_rss&amp;postId=63cbdb16d97c"
  width="1"
  height="1"
  alt=""
/>
<hr />
<p>
  <a
    href="https://betterprogramming.pub/improving-your-python-projects-with-type-hints-63cbdb16d97c"
    >Improving Your Python Projects With Type Hints</a
  >
  was originally published in
  <a href="https://betterprogramming.pub/">Better Programming</a> on Medium,
  where people are continuing the conversation by highlighting and responding to
  this story.
</p>

Know how to use static type checking and type annotation best practices Photo by Artturi Jalli on Unsplash Type-checking is one of the foremost features of any modern-day programming language; it’s the reason TypeScript was born. Type-checking not only makes a codebase easier to extend and work with in general, but it also detects many programming errors quickly, reliably and automatically. First introduced in Python 3.5, Type Hints are the primary way Python developers annotate types to variables and funct

logging

Log Level Hierarchy

c-sharp-programming

C# Delegates: Difference between Func and Action

Get one coding trick and an article delivered every week at no extra cost

data-science

How to Implement an Interface in Python

data-science

Improving Your Python Projects With Type Hints