DEV Community: Stephen Odogwu

Typer: Observations, Dos and Don'ts of the Python Command Line Application Builder

Stephen Odogwu — Wed, 27 Nov 2024 12:48:48 +0000

Typer is a library for building command line interface(CLI) applications based on Python type hints. We have seen CLI applications like Curl, Git and the likes, Typer comes in handy for projects like these. Currently building an application with it and I must say I like the whole concept behind it.

This article is not one to introduce us to Typer. It is for those already familiar with it. In this article, we will be making observations, looking at certain things that can cause errors in our code and how to avoid them. I won't be talking about things like installation as I believe we should be familiar with that.

Now going to look at some occurences, behaviors and implementations of Typer which could lead to errors if not followed, and how to avoid these errors.

Note: For our commands python3 and python were used interchangeably.You can use whichever applies to you.

One Function Module and Extra Argument Error

If we have a function as the only function in a module, Typer assumes that any argument passed on the command line must map to a defined argument for the function. Create a file script.py and add the following code.

import typer
app = typer.Typer()

@app.command(name="call_name")
def call_name(
    name: str
):
    print(f"Hi {name}")

if __name__ == "__main__":
    app()

This function is a command, as can be seen by the
@app.command() passed over it. The command name is inferred from that, and its arguments are treated as top level options. Including the function name as part of the command causes an extra argument error.

python3 script.py call_name steve

 Got unexpected extra argument (steve)

If the function has more than one argument, it pushes the first argument to the position of the second, since it assumes the function being passed is the first argument and that the first argument is the second. In this scenario if our arguments are of different types like int and str, it shows a value error.

from typing_extensions import Annotated
import typer


app = typer.Typer()

@app.command(name="call_name")
def call_name(
    name: str,
    age: Annotated[int, typer.Argument()] = 25
):
    print(f"Hi {name}")

if __name__ == "__main__":
    app()

python3 script.py call_name steve 23

Error here:

Invalid value for '[AGE]': 'steve' is not a valid integer.

Without function in command:

python3 script.py steve

No errors observed.

Hi steve

`typer.run()` Too

The above doesn't just happen in a single function module where the function is registered with @app.command(). It also occurs when we register the function with typer.run().

import typer

def callname(
    name: str
):
    print(f"Hi {name}")

if __name__ == "__main__":
    typer.run(callname)

python3 script.py callname steve

Error here:

 Got unexpected extra argument (steve)

This is because Typer sees this function as the sole command. Adding our function name in the CLI makes Typer think we are adding some unexpected argument.

Subcommands to The Rescue

However we can achieve something similar with the use of subcommands. The basic idea is adding a typer.Typer() app in another typer.Typer() app.
Typer application has a method known as add_typer which we can use to achieve this. It takes the second Typer instance created from typer.Typer() and the name of the group under which the commands in the typer instance will be accessible in the parent CLI application.

import typer

app = typer.Typer() #parent
sub_app = typer.Typer() #child

from typing_extensions import Annotated
import typer


app = typer.Typer() #parent
sub_app = typer.Typer() #child

@sub_app.command()
def callname(
    name: str,
    age: Annotated[int, typer.Argument()] = 25
):
    print(f"Hi {name}, are you {age}?")

app.add_typer(sub_app, name="cli")

if __name__ == "__main__":
    app()

Notice:

app.add_typer(sub_app, name="cli")

Commands will be accessible under cli which is the value of name.

So that:

python script.py cli callname steve 30

Will output:

Hi steve, are you 30?

Multiple Functions

If our module has more than one function, Typer uses the functions' names to route arguments properly. Using the command names to distinguish them in this scenario.

from typing_extensions import Annotated
import typer

app = typer.Typer()

@app.command()
def callname(
    name: str= typer.Argument(help="The name to call"),
    age:int= typer.Argument(help="Enter age here:")

):
    print(f"Hi {name}, are you {age}")


@app.command()
def checkdetails(
    name: str= typer.Argument(help="The name to call"),
    age:int= typer.Argument(help="Enter age here:")

):
    print(f"Hi {name}, are you {age}")

if __name__ == "__main__":
    app()

Run:

python script.py callname steve 22

Output is:

Hi steve, are you 22

Run:

python script.py checkdetails maka 36

Output is:

Hi maka, are you 36

Don't Use Snake Case Functions on the Command Line Unless....

Suppose we have this code in a script.py file.

import typer

app=typer.Typer()

@app.command()
def create_name(username:str):
    print(username)


@app.command()
def create_age(age:int):
    print(age)


if __name__=="__main__":
    app()

Run this command:

python script.py create_name Steve

Throws an error:

No such command create_name

This is because Typer automatically converts function names written in snake case to kebab case(i.e from underscores to dashes).

However if we want the CLI command to accept a snake case function name, we can explicitly specify it with the name parameter in command.

# Note name argument in decorator
import typer

app=typer.Typer()

@app.command(name="create_name")
def create_name(username:str):
    print(username)


@app.command(name="create_age")
def create_age(age:int):
    print(age)


if __name__=="__main__":
    app()

Now when we run the command:

python script.py create_name Steve

It outputs Steve.

Boolean Flags

Suppose we have an index.py file that has the function below.

@app.command(name="greet_older")
def greet_older(name: str="", older:bool=False):
    if older:
        print(f"Hello Mr {name}")
    else:
      print(f" Hello {name}")

If we run:

python index.py greet_older --name kelly --older

The above will trigger the if block. Without the --older flag, it will trigger the else block.

Hello Mr kelly

But What If....??

Suppose we had set the default value of older to True and not used --older on the command line like below:

@app.command(name="greet_older")
def greet_older(name:str="", older:bool=True):
    if  older:
        print(f"Hello Mr {name}")     
    else:
        print(f"Hello {name}")

python index.py greet_older --name kelly

Will output:

Hello Mr kelly

Why did this happen, even though we didn't use the --older flag; this is because, we hve changed value for what an unsued CLI flag is. From False to True.

In this scenario, the way we can handle the condition where we don't want to deal with the older argument/option is to add the flag --no-older.
So we can run:

python index.py greet_older --name Kelly --no-older

This will output:

Hello Kelly

This is because, if the default is True, Typer provides a --no-[flag] to set it to False. If the default is False, Typer provides a --[flag] to set it to True.

CLI Arguments With Help

We know that we can add help comments to our application by using a function's docstring. However we can do the same for specific arguments by adding a help parameter to typer.Argument().
Create a file somehelp.py and add the following code:

from typing_extensions import Annotated
import typer

def greet(
    name: Annotated[str, typer.Argument(help="The name to call")] = "spencer",   
):
    print(f"Hi {name}")

if __name__ == "__main__":
    typer.run(greet)

Run this:

python somehelp.py --help

The above outputs the name argument with the value in he help parameter(The name to call). Then it shows us the --help flag under options.

However when we run this command:

python somehelp.py steve --help

It doesn't print Hi steve instead it outputs what it did with our first command.

The reason for this is that when we pass --help as an argument, Typer processes it and exits after displaying the help message. The function greet is not executed when --help is used. The --help flag takes priority.

But if we run:

python somehelp.py steve

It prints Hi steve.

Conclusion

Even though I wrote on just these points, one thing to note however, is that this is not an exhaustive list of all Typer's behaviors. These are just some observations I made while learning to use the tool. I encourage further investigations. Any inconsistencies on my part should be pointed out. Thanks for reading.

Mimicking a List of Dictionaries with a Linked List in Python

Stephen Odogwu — Thu, 07 Nov 2024 09:24:10 +0000

I will be starting this article with my thought process and visualization. An experiment(you can choose to call it that) which opened my eyes to gain more clarity on what linked lists are. This made me stop looking at it as abstract, going by the cliche manner(data and next) which it is always explained.

Thought Process and Visualization

Lately I have started looking at code from a more physical perspective(OOP as it is usually refered to as). However, mine goes beyond classes and attributes; I started writing down steps and algorithms before every while and for-loop. Got tired of jumping into abstractions just for the sake. This led me to try a few more things which further taught me a few more things which I will be sharing in this article.

Three key questions and answers before we delve in deeper:

What makes up a linked list?
What do nodes look like?
What does a linked list look like at the start?

To answer the first; nodes make up a linked list.

For the second question; think of a node in a linked list like a car towing another car. In this scenario, assume both cars contain goods. The second car is attached to the back of the first car with a chain. A node does this in a Linked list by holding data like the goods or passengers in the cars. This data type can be simple like an integer or string or a more complex data structure. At the same time, each car has a connector (chain) linking it to the next car on the road. In a linked list, this is the next attribute which points to the memory address of the next node or the node before(in a doubly linked list). A list is not a linked list without the next attribute.

Each car knows only about the car directly in front or behind it (depending on the type of linked list). The last car has no chain, meaning it points to nothing. In a linked list this is often represented by None.

class Node:
    def __init__(self, data):
     self.data = data
     self.next = None

To answer the third question; the head node starts a linked list just as the first car starts the tow.

class LinkedList:
    def __init__(self):
      self.head = None

So far, we have looked at the basics of a linked list.We will now be going into the major reason why I wrote this article.

Introduction

Python's built-in data structures, like lists and dictionaries, provide flexible ways to store and manage data. Lists allow us to store ordered sequences, while dictionaries let us pair keys with values for easy access.

In this article, we will explore how to create a dictionary-like linked list by using composition. We will see disparities in memory use between our dictionary-like linked list and a list of dictionaries. We will also see how our node can get an inheritance from dict to make the node instances actual dictionaries. All these in a bid to provide more perspectives for our understanding of a linked list.

Creating Our Linked List

As examined previously, a linked list is made up of nodes. These nodes each have a data segment and a next segment. The data can be simple like a string or integer, or complex.

Simple:

class My_Int:
    def __init__(self, data):
        self.data=data
        self.next=None

The Node class (represented by My_Int) has data and next as attributes.

class My_Int:
          def __init__(self, data):
                 self.data=data
                 self.next=None


class LinkedList:
          def __init__(self):
                 self.head=None
          def  insert(self, node):
                  if self.head==None:
                     self.head = node
                     return

                  last_node = self.head
                  while(last_node.next):
                      last_node =last_node.next
                  last_node.next = node

          def traverse(self):
                current_node = self.head
                while(current_node):
                    print(current_node.data, end="->")
                    current_node = current_node.next
                print("None")

node1 = My_Int(5)
node2 = My_Int (10)
node3 = My_Int(15)

linked_list = LinkedList()
linked_list.insert(node1)
linked_list.insert(node2)
linked_list.insert(node3)
linked_list.traverse()

Going to be dealing with a complex case in this article:

Complex:

class My_Dict: #dict keys as attributes
    def __init__(self, **kwargs):
        self.username = kwargs['username']
        self.complexion = kwargs['complexion']
        self.next = None

The node class (represented by My_Dict) holds multiple attributes: username, complexion, and next. **kwargs as an argument, allows methods to accept any number of keyword arguments without explicitly defining each one.

Each node doesn’t just store a single piece of data but combines multiple pieces (username and complexion) into one, making it more complex than a basic data structure like an integer or a string.

We will now create a My_List class which will manage a linked list of My_Dict instances. It takes a head attribute. This head is usually the first node that initializes a linked list.

class My_List: #manager
    def __init__(self):
        self.head=None

This class also provides an insert method for adding new node entries at the end.
We also create an instance of My_Dict here(which is a node). My_List will act as a container for My_Dict objects in a linked list structure. Each My_Dict instance is connected by a next reference which enables My_List to manage the traversal and insertion of My_Dict instances dynamically. This basically exemplifies composition.

After the creation of a My_Dict instance, we check to make sure the list is not empty by checking for the presence of the head. If the head is not present, it means the list is empty, so we initialize self.head as the new node(which is my_dict). The return then immediately exits the function. No need to execute further.

def insert(self, **kwargs):
        my_dict = My_Dict(**kwargs) #instantiate dict
        #check if list is empty
        if self.head==None:
            self.head=my_dict
            return

        last_dict = self.head
        while(last_dict.next): 
            last_dict = last_dict.next
            last_dict.next = my_dict #makes the insertion dynamic

The line after return runs when there was a node previously in the list and we want to insert a new node. We initialize that node last_dict as head and this will be used to find the last node (the end of the list) so that the new node can be appended there. The while loop iterates the list until it reaches the last node. As long as last_dict.next is not equal to None, it moves to the next node by setting last_dict = lastdict.next.

Finally last_dict.next = my_dict appends my_dict to the end of the list completing the insertion. Once we know last_dict.next is None (i.e., we’re at the last node), we attach my_dict there.

We now deal with the traverse function:

def traverse(self):  
        current_dict = self.head
        while(current_dict!=None):
            print(f"('username':{current_dict.username}, 'complexion':{current_dict.complexion})", end=" -> ")
            current_dict = current_dict.next
        print("None")

The traverse function iterates through each node in the linked list and performs an action (in this case, printing) on each node, from the head to the end. The method provides a sequential view of all nodes in the list.

Peep the full code below:

class My_Dict: 
    #dict keys as attributes
    def __init__(self, **kwargs):
        self.username = kwargs['username']
        self.complexion = kwargs['complexion']
        self.next = None

class My_List: #manager
    def __init__(self):
        self.head=None

    def insert(self, **kwargs):
        my_dict = My_Dict(**kwargs) #instantiate dict
        #check if list is empty
        if self.head==None:
            self.head=my_dict
            return

        last_dict = self.head
        while(last_dict.next): 
            last_dict = last_dict.next
        last_dict.next = my_dict #makes the insertion dynamic


    def traverse(self):  
        current_dict = self.head
        while(current_dict!=None):
            print(f"'username':{current_dict.username}, 'complexion':{current_dict.complexion}", end=" -> ")
            current_dict = current_dict.next
        print("None")


my_list = My_List()
my_list.insert(username = 'Steve', complexion='fair')
my_list.insert(username='Khaled', complexion='dark')
my_list.insert(username='Mike', complexion='fair')
my_list.traverse()

Output

'username':Steve, 'complexion':fair -> 'username':Khaled, 'complexion':dark -> 'username':Mike, 'complexion':fair -> None

Our implementation above can be thought of as a custom linked list of dictionary-like objects, but it’s structured differently from a standard Python typical list of dictionaries. Here are points to note:

My_Dict Class: Each instance acts as a dictionary-like object with attributes (username and complexion) and a next pointer, allowing it to be linked to another My_Dict instance.
My_List Class: This class manages a linked list of My_Dict instances, maintaining the head and providing an insert method to add new entries at the end. Each node is connected to the next via the next pointer, simulating a linked list structure.

The Algorithm

It is always good to have an algorithm while writing code. This is known as the steps taken. Maybe I should have written them before the code above. But I just wanted to show the difference first between the every day cliche linked list and a more complex type. Without further ado, below are the steps.

Create a class with the attributes of a node structure.
Create another class call it LinkedList(or whatever). Add head as sole attribute. Make head=None.
To create and insert node:
- make an instance of Node.
- If the list is empty, let node instance be the value of head.
- If the list is not empty, set previous node with value as head.
- With condition check as; if the next attribute of the previous node is not None, loop through the list.
- Finally set next of previous node to point to the new node.
To traverse the list:
- Create a temporary node and set head as its start value.
- Loop with a condition of if temporary node is not None.
- Print data in temporary node.
- Move temporary node to next
- Finally at end, next is None, so print None.
Create class instances as required.

Comparison with a List of Dictionaries

We will now compare what we have above with a Python list of dictionaries by looking at some points:

Structure and Storage:

List of Dictionaries: In Python, a list of dictionaries stores each dictionary as an element in a contiguous list structure, making each dictionary accessible via an index.

list_of_dicts = [
    {"username": "Steve", "complexion": "fair"},
    {"username": "Khaled", "complexion": "dark"},
    {"username": "Mike", "complexion": "fair"},
]

Linked List of Dictionaries: Our code uses a linked list structure, where each node (dictionary-like My_Dict instance) holds a reference to the next node rather than using contiguous memory storage. This is more memory-efficient for large lists if elements frequently change, but it’s slower for access by position.

Access and Insertion: List of Dictionaries: In a standard Python list, accessing elements by index is O(1) (constant time) because Python lists are arrays under the hood. Adding a new dictionary to the end is usually O(1) but becomes O(n) if resizing is required.

Linked List of Dictionaries: In our linked list, accessing an element requires traversal (O(n) time), as we have to iterate node by node. Inserting at the end is also O(n) because we have to find the last node each time. However, inserting at the start can be O(1) since we can set the new node as the head.

Memory Usage:

List of Dictionaries: A Python list uses more memory for storing dictionaries in a contiguous block, as each item is stored sequentially. Memory is allocated dynamically for Python lists, sometimes resizing and copying the list when it grows. We can prove this in code using the sys module:

import sys

list_of_dicts = [
    {"username": "Steve", "complexion": "fair"},
    {"username": "Khaled", "complexion": "dark"},
    {"username": "Mike", "complexion": "fair"},
]

# Calculate the memory size of the regular list of dictionaries
list_of_dicts_size = sys.getsizeof(list_of_dicts)
for d in list_of_dicts:
    list_of_dicts_size += sys.getsizeof(d)

print("Memory usage of list of dictionaries:", list_of_dicts_size, "bytes")

Output
Memory usage of list of dictionaries: 776 bytes

Linked List of Dictionaries: The linked list uses memory efficiently for each node since it’s only allocating memory as needed. However, it requires extra space for the next reference in each node.

import sys
class My_Dict(): #dict keys as attributes
    def __init__(self, **kwargs):
        self.username = kwargs['username']
        self.complexion = kwargs['complexion']
        self.next = None

class My_List: #manager
    def __init__(self):
        self.head=None

    def insert(self, **kwargs):
        my_dict = My_Dict(**kwargs) #instantiate dict
        #check if list is empty
        if self.head==None:
            self.head=my_dict
            return

        last_dict = self.head
        while(last_dict.next): 
            last_dict = last_dict.next
        last_dict.next = my_dict #makes the insertion dynamic
         #traversal here

    def traverse(self):  
        size = sys.getsizeof(self.head)
        current_dict = self.head
        while(current_dict!=None):
            size += sys.getsizeof(current_dict)
           # print(f"'username':{current_dict.username}, 'complexion':{current_dict.complexion}", end=" -> ")
            current_dict = current_dict.next
        #print("None")
        print("Memory usage of linked list with dictionary-like nodes:", size, "bytes")

Output
Memory usage of linked list with dictionary-like nodes: 192 bytes

From the above, we can see the difference in bytes; 776 and 192.

Technically Not Dictionaries

In our code, the My_Dict instances are dictionary-like objects rather than true dictionaries.

Here are some reasons why:

The next attribute links My_Dict instances together, making them more like nodes in a linked list than standalone dictionaries. This next attribute is not a feature we'd find in a regular dictionary.
- Methods and Behavior: Dictionary-like objects (like My_Dict instances) can have methods and behaviors that resemble dictionaries but are technically not dictionaries. They lack methods like .keys(), .values(), .items(), and dictionary-specific operations such as hashing. If we wanted My_Dict objects to behave more like dictionaries, we could inherit from Python’s built-in dict for implementing methods to give them dictionary functionality. But as it stands, these objects are dictionary-like, since they store data in a key-value style but do not inherit from or behave exactly like Python dictionaries.

Below is a look at how we can inherit from dict class:

from typing import Dict

class My_Dict(dict):
    def __init__(self, username, complexion):
        super().__init__()
        self.username = username
        self.complexion = complexion
        self['username'] = username
        self['complexion'] = complexion
        self.next = None  # Initialize next to None for linked list functionality

    def keys(self):
        return super().keys()

class MyList:
    def __init__(self):
        self.head = None

    def insert(self, username, complexion):
        new_dict = My_Dict(username, complexion)
        if not self.head:
            self.head = new_dict
            print(new_dict.keys()) # Showing the python dictionary behaviour. Prints keys of head_node
            print(new_dict['username']) # Prints username of head node

        else:
            last_dict = self.head
            while last_dict.next:
                last_dict = last_dict.next
            last_dict.next = new_dict
            print(new_dict.keys()) # Showing the python dictionary behaviour. prints keys of other nodes
            print(new_dict['username']) # prints username of other nodes




    def traverse(self):    
        # Traversal
        current_dict = self.head
        while current_dict:
            print({key: getattr(current_dict, key) for key in current_dict.keys()}, end=" -> ")
            current_dict = getattr(current_dict, 'next', None)
        print("None")


my_list = MyList()
my_list.insert('Steve', 'fair')
my_list.insert('Khaled', 'dark')
my_list.insert('Mike', 'fair')
my_list.traverse()

Output
dict_keys(['username', 'complexion'])
Steve
dict_keys(['username', 'complexion'])
Khaled
dict_keys(['username', 'complexion'])
Mike
{'username': 'Steve', 'complexion': 'fair'} -> {'username': 'Khaled', 'complexion': 'dark'} -> {'username': 'Mike', 'complexion': 'fair'} -> None

The first line imports Dict from Python's typing module. This indicates that My_Dict is a specialized dictionary.

from typing import Dict

My_Dict class inherits from dict, meaning it will have the properties of a dictionary but can be customized.

class My_Dict(dict):

Let us take a look at the constructor:

def __init__(self, username, complexion):
        super().__init__()
        self.username = username
        self.complexion = complexion
        self['username'] = username
        self['complexion'] = complexion
        self.next = None  # Initialize next to None for linked list functionality

__init__ initializes an instance of My_Dict with username and complexion attributes. super().__init_() calls the parent Dict class constructor. self['username'] = username and self['complexion'] = complexion store username and complexion as dictionary entries, allowing My_Dict instances to be accessed like a dictionary (e.g., new_dict['username']). There is also a
next attribute initialized as None, setting up a linked list structure by allowing each My_Dict instance to link to another.

def keys(self):
        return super().keys()

The above method overrides the keys method from dict, allowing it to return all keys in My_Dict. Using super().keys() calls the parent
keys() method, ensuring standard dictionary behavior.

 def insert(self, username, complexion):
        new_dict = MyDict(username, complexion)
        if not self.head:
            self.head = new_dict
            print(new_dict.keys()) # Showing the python dictionary behaviour. Prints keys of head_node
            print(new_dict['username']) # Prints username of head node

        else:
            last_dict = self.head
            while last_dict.next:
                last_dict = last_dict.next
            last_dict.next = new_dict
            print(new_dict.keys()) # Showing the python dictionary behaviour. prints keys of other nodes
            print(new_dict['username']) # prints username of other nodes

In MyList class insert method, we can see how we make the created instance of our dictionary exhibit dictionary behavior. We chain the keys() method to it and we also assess the username key with it. We do this in the if and else blocks. In the if block it prints the keys of the head node and the username. In the else block it prints the keys of the other nodes and the username of the other nodes.

def traverse(self):    
        current_dict = self.head
        while current_dict:
            print({key: getattr(current_dict, key) for key in current_dict.keys()}, end=" -> ")
            current_dict = getattr(current_dict, 'next', None)

            print("None")

In the traverse method above inside the dictionary comprehension:

{key: getattr(current_dict, key) for key in current_dict.keys()}

We construct a dictionary with each key-value pair from current_dict. current_dict = getattr(current_dict, 'next', None) moves to the next node, continuing until current_dict becomes None.

Note: when it comes to memory use, Making our class inherit from dict means more memory use. Unlike the linked list of dictionary-like nodes which we created earlier.

Conclusion

The aim of this article is to provide more perspectives and insight to what linked lists are, beyond what I usually see it explained as. I wasn't being innovative. I was just experimenting with code, trying to provide more insight to those who might be considering it too abstract. However I would like to know from more senior programmers, what the drawbacks could be if used or when used in the past.

The Use of the ** Operator with Python and FastAPI Pydantic Classes

Stephen Odogwu — Sat, 31 Aug 2024 02:44:26 +0000

The ** operator in Python is contextual or dependent on what it is used with; when used with numbers(typically between two numbers), it serves as an exponentiation operator. However in this article we will be looking at another context which it is used. We will be looking at its use as an unpacking operator, used to unpack Python dictionaries.

Anyone who has coded in Python must have seen **kwargs. Short for keyword arguments. They are arguments passed to functions in a key = value syntax. kwargs is used when we do not know the number of keyword arguments that will be passed into our function. **kwargs is a dictionary type and is as good as passing a dictionary into a function. This dictionary contains:

Keys corresponding to the argument names.
Values corresponding to the argument values.

Going by this logic, in this article, we will be looking at its use cases in Python building up to its use case in FastAPI with Pydantic classes.

The following points will be looked at.

Use with Python functions.
Use with Python classes.
Use with FastAPI Pydantic classes.
Benefits of use.

Note: It is not compulsory to use kwargs, you can use any other naming convention e.g. **myArgs, **anything etc.

Prerequisites

Knowledge of Python classes and functions.
Some basic knowledge of FastAPI.

Use with Python Functions

In this example, we will have a number of keyword arguments passed to a function as **kwargs and since **kwargs is a dictionary, we will use the dictionary method .items() on it. The .items() method returns a view object that displays a list of the dictionary's key-value tuple pairs.

def print_details(**kwargs):
    # kwargs is a dictionary containing all keyword arguments
    print(type(kwargs))  # Output: <class 'dict'>
    print(kwargs.items())  # Displays the dictionary items (key-value pairs)

    # Iterate over the key-value pairs in kwargs
    for key, value in kwargs.items():
        print(f"{key}: {value}")

# Calling the function with multiple keyword arguments
print_details(name="Stephen", age=30, profession="Software Developer")

Output

<class 'dict'>

dict_items([('name', 'Stephen'), ('age', 30), ('profession', 'Software Developer')])

name: Stephen
age: 30
profession: Software Developer

Use with Python Classes

As we must have noticed, Python classes are callable; this means that we can call a class the same way we call a function. Calling a class creates an instance (an object) of that class.

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design
# Call class to create an instance
tech = Tech(dev, devops, design)

Calling Tech with argument values will return the instance tech.

In classes, the ** operator unpacks the dictionary allowing each key-value pair to be passed as a named argument to the class constructor.

In the example for this section, we define a class. We define a dictionary with properties matching the class parameters. We then create an instance of the class, using the ** to unpack the dictionary.

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design

# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class using ** to unpack the dictionary

tech = Tech(**tech_team)
print(tech.dev)
print(tech.devops)
print(tech.design)

The above code is equivalent to:

class Tech:
    def __init__(self, dev, devops, design):
        self.dev = dev
        self.devops = devops
        self.design = design


# Define a dictionary with properties matching the class's parameters
tech_team = {
    'dev': 'Stephen',
    'devops': ['Jenny', 'Rakeem', 'Stanley'],
    'design': 'Carlos'
}

# Create an instance of the class 
tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

print(tech.dev)
print(tech.devops)
print(tech.design)

This is because:

tech = Tech(**Tech_team)

Is same as:

tech = Tech(
    dev = tech_team["dev"],
   devops = tech_team["devops"],
  design = tech_team["design"]
)

Use with FastAPI Pydantic Classes

Pydantic is a Python library used for data validation, it is even touted as the most widely used data validation library for Python, by using Python3's type hinting system. This Pydantic employed in FastAPI helps us define data models which in simple terms are classes.

In our classes, we can specify types for our attributes or fields e.g str, int, float, List. When data is provided, Pydantic checks to make sure it matches.

In addition to this Pydantic helps with parsing and serialization. Serialization is the process of transmiting data objects into an easily transmissible format; for instance an object or array into JSON format for its simplicity and ease of parsing.

Pydantic has a BaseModel class which classes defined inherit from. Below is an example of a Pydantic model:

from pydantic import BaseModel, EmailStr
# We import the BaseModel and Emailstr type from Pydantic

class UserInDB(BaseModel):
    username: str
    hashed_password: str
    email: EmailStr
    full_name: Union[str, None] = None

Suppose we have:

class Item(BaseModel):
   name:str
   price:float

app = FastAPI()
@app.post("/items/")
async def create_item(item:Item):
   return item

In the code above, item which is the request body parameter, is an instance of the Item model. It is used to validate and serialize the incoming JSON request body to ensure it matches the structure defined in th Item model.

Pydantic's `.dict()` Method

Pydantic models have a .dict() method which returns a dictionary with the model's data.

If we create a pydantic model instance:

item = Item(name="sample item", price=5.99)

Then we call dict() with it:

itemDict = item.dict()
print(itemDict)

We now have a dictionary and our output will be:

{
"name": "sample item",
"price":5.99
}

Note that:

Item(name="sample item", price=5.99)

Is equivalent to


# Using the unpacking operator
Item(**itemDict)

# Or 

Item(
  name=itemDict["name"], price=itemDict["price" 
)

Benefits of Use

We will now look at some situations where using the unpacking operator is beneficial.

Creating new dictionaries from a pre-existing dictionary by adding or modifying entries.

original_dict = {"name": "Stephen", "age": 30, "profession": "Software Developer"}

# Creating a new dictionary with additional or modified entries
new_dict = {**original_dict, "age": 31, "location": "New York"}
print(new_dict)

Joining dictionaries into one. With the unpacking operator we can merge multiple dictionaries.

default_config = {"theme": "light", "notifications": True}
user_config = {"theme": "dark"}

# Merging dictionaries using unpacking
final_config = {**default_config, **user_config}
print(final_config)

Handling of arguments in functions in a dynamic manner. This can be seen in our early examples.

Conclusion

The dictionary unpacking operator ** is one to consider using because of its dynamic nature of handling arguments in functions and classes, and in merging and creation of new dictionaries. All these put together leads to lesser code and better maintenance of code.

Routing in Computer Networking

Stephen Odogwu — Tue, 23 Apr 2024 15:53:25 +0000

The basis of the Internet is the transfer of information among networks. So even if you are a web developer or network engineer, it is very crucial to understand how routers aid this process. This article will be looking at the methods and tools that are used to make this happen.

Prerequisites

The knowledge of the following is required to flow with this article.

A basic understanding of what computer networking is.
knowing what IP addresses are.
Understand what subnetting is.

What is Routing?

This is the choosing of a communication path between two or more devices for the sake of sending data from source to destination. To achieve this, a tool known as router is used.

Router

A router facilitates communication between devices on different networks. This enables the sending and reception of data packets between networks based on their IP addresses.

The router is basically a data package distributor for the internet. It operates at the network layer(layer 3) of the OSI(Open System for Interconnection). You might also find the router being referred to as a network gateway at times. A router can be likened to a logistics/delivery driver who delivers items bought from an online store to the consumer.

A router is connected to at least two networks at a time. The networks could be:

Two local area networks(LANs).
Two wide area networks(WANs).
A LAN and its internet service provider(ISP).

Below is an illustration of a router connecting a LAN to the internet.

Switch

This article will not be complete without talking about switches and their relationship with routers and LANs.

Switches are used to connect devices on the same LAN. Switches are the intermediaries between devices in the same LAN and the router. Devices on the LAN connect to the switch via what is called ethernet switch ports.

Switches typically operate at layer 2(Data-Link layer) of the OSI model, primarily using MAC addresses to forward frames within a LAN. Switches maintain a MAC address table also known as a MAC address forwarding table which maps MAC addresses to the ports on the switch. There are also layer 3 switches that also have routing tables, however that is not our focus here.

Question arising
A newbie might be wondering how does a router know where to send a packet of data?. We will take a look at how the router
performs its function before we take a look at a router's structure.

Routing Table

From our question above; how does a router know where to send a packet of data? By using a routing table.

Also known as Routing Information Base(RIB). A routing table is information stored in a router containing the routes to various destinations. It is stored in the router's RAM and is maintained by the router's operating system. It is a data structure used by routers to determine the best path for forwarding packets towards their destinations. It contains information about destinations and metrics.

Recall we earlier likened the router to a driver of a delivery/logistics company. This topic brings back to my memory when I worked for an Ecommerce company; we used to give the delivery details of the consumers in an app to the drivers to use to locate them. In this scenario, we can liken the routing table to the app with the delivery details of consumers.

In the case of a router, we will say how does it acquire its routes? It does so statically or dynamically. By statically the routes are added manually to the routing table at the beginning and dont change except modified manually. For dynamic routing, the routes change according to network topology and conditions, the routing table is adjusted based on network changes.

Now going to take a look at what a routing table might look like.

Destination	Subnet Mask	Next Hop	Interface	Metric
192.168.1.0	255.255.255.0	192.168.1.1	eth0	1
10.0.0.0	255.0.0.0	10.0.0.1	eth1	2
172.16.0.0	255.255.0.0	172.16.0.1	eth2	3
0.0.0.0	0.0.0.0	192.168.0.1	eth3	10

Explanation of the entries:

Destination: This column represents the network destination. For example, 192.168.1.0 represents the destination network address.
Subnet Mask:This column specifies the subnet mask associated with the destination network. It determines which portion of the IP address is the network portion and which portion is the host portion. For example, 255.255.255.0 means that the first 24 bits of the IP address are the network portion, leaving 8 bits for the host portion.
Next Hop: This column indicates the next router or gateway IP address to which the packet should be forwarded in order to reach the destination network. For directly connected networks, this may be the IP address of the interface on the local router. For example, 192.168.1.1 is the next-hop router for the destination network 192.168.1.0.
Interface: This column specifies the network through which the packet should be forwarded to reach the next hop router or destination router. For example, eth0 indicates that packets should be sent out through the Ethernet interface 0.
Metric: This column represents the cost associated with each route. It's used by the router to determine the best path to reach a destination when multiple routes are available. Lower metric values indicate preferred routes. In this example, the route with the lowest metric value (1) for the destination 192.168.1.0/24 through eth0 would be chosen as the preferred route to reach that network. Similarly, for other destinations, the route with the lowest metric value would be preferred. The metric value can be based on factors such as hop count, bandwidth, delay, or administrative preference.

Let us now see a breakdown of each row of the above table:

Row 1: Packets destined for the network 192.168.1.0/24 should be forwarded to the next hop 192.168.1.1 via the interface eth0 with a metric of 1.
Row 2: Packets destined for the network 10.0.0.0/8 should be forwarded to the next hop 10.0.0.1 via the interface eth1 with a metric of 2.
Row 3: Packets destined for the network 172.16.0.0/16 should be forwarded to the next hop 172.16.0.1 via the interface eth2 with a metric of 3.
Row 4: The default route 0.0.0.0/0 indicates that packets with destinations not matching any specific routes should be forwarded to the next hop 192.168.0.1 via the interface eth3 with a higher metric of 10.

Talking more about row 4:
Why does a router need a default gateway?
This makes it find a way to other networks it doesn't know about. This makes it handle traffic destined for networks outside of its directly connected networks or subnets. The default route serves as an all routes for traffic that does not match any other route entry in the routing table. It serves as a fallback mechanism in case specific routes fail or are unavailable. If a router cannot find a more specific route for a packet, it uses the default route to prevent traffic from being dropped. One major use of this is routing traffic to the internet as we can't expect the router to know every address on the internet.

Physical Components of Routers

The components of a router typically include:

CPU(Central Processing Unit): Responsible for executing instructions and managing tasks within the router.
RAM: The routing table ARP(Address Resolution Protocol) cache and buffered packets are stored here. It is called the running configuration, providing memory for running processes. It is volatile in nature, meaning it doesn't retain data when the router is turned off.
ROM: Contains the bootcode and firmware necessary for starting up the router. It performs the Power On Self Test(POST) operation.
NVRAM: Means non-volatile RAM. This means it retains data after the router has been turned off. If we want any configurations permanent we save them here.
Flash Memory: This serves as the router's secondary memory. It stores the router's operating system configuration files and other software components.
Interfaces/Ports: Physical connectors where network cables are plugged in. Examples are ethernet ports, serial ports, and WAN interfaces.
Switching Fabric: Handles the forwarding of data packets from the router's input port to the output port that has been specified by the LPM (Longest Prefix Match). It is basically a combination of hardware and software; some of which are high-speed interconnection network, switching ASICs(Application-specific integrated circuits), buffers.

Longest Prefix Match

I mentioned the "Longest Prefix Match" while talking about the switching fabric in the last section. In order to understand it, we will take a look at some terms namely:

IP prefix.
prefix Length.
Number of Possible Subnets Within a Network.
Route via Longest Prefix Match.

IP Prefix

An IP prefix also known as network prefix combines an IP address and a subnet mask to specify a range of IP addresses. The prefix indicates the network portion of the IP address which helps in routing and subnetting.

Prefix Length

This helps us to obtain the IP prefix.
For example: 192.168.1.0/24,
the /24 represents the prefix length. The prefix length represents the number of bits in the network portion and the rest refers to the host. As we know an IPv4 address is 32bits. In the above scenario, the last 8 bits refer to the new host.
So we have: 192.168.1.255
where:
192.168.1 is the network portion.
.255 is the host portion.
The range of IP addresses in this scenario will be:
192.168.1.0-192.168.1.255

Likewise if we have 192.168.1.0/16, we will have:
192.168.255.255
The range of IP addresses in this scenario will be: 192.168.1.0-192.168.255.255

Number of Possible Subnets Within a Network

We can also use the prefix length to determine the possible number of subnets within a network. We can use the formula 2^(32-L).
Where L = prefix length

Suppose L = 24
2^(32-24)= 2^8
2^8 = 256
So there are 256 possible subnets in 192.168.1.0/24

Route via Longest Prefix Match

Suppose we have 192.168.1.0/24 and 192.168.1.0/16 and we want to forward a packet to 192.168.1.20
and we thinking of which to use.

Recall that prefix indicates the network portion.

There is a saying that the "Longest Prefix Match" always wins. In the above, 192.168.1.0/24 will be used.

Conclusion

We have looked at what routing is, what routers are, and what they do. All the above are just enough to get beginners started with what routing is. The following links were instrumental in my understanding of routing and routers. You can refer to them for more studies to gain more perspectives into all we discussed.

Network Performance

Stephen Odogwu — Mon, 08 Apr 2024 14:15:10 +0000

I have been exploring computer networking for a while now, all in a bid to make me a more rounded programmer. One topic that has fascinated me is Network Performance.

When we talk about performance in software, it's basically always about looking for ways to monitor, measure and optimize this performance.

What is Network Performance?

Network performance is the quality of transmission of a network. This takes into account the speed and efficiency of data transfer.

There are some measures which we take into account when measuring network performance in order to enable us maximize network performance.

Measures of Network Performance

There are 3 fundamental methods for measuring network performance namely:

Bandwidth
Throughput
Latency We will now take a look at the meaning of each of these metrics which we listed.

Bandwidth

Bandwidth can be likened to the frequency of something occuring; as we know frequency is usually a measure of an occurence per unit time. In the case of networking the bandwitdth is the number of bits transmitted per second. The bandwidth of a device is the ability or capacity of a device to transmit data per unit time.

Some of the measurements used to quantity bandwidth are as follows:

Description	Unit	Unit Abbreviation
Bits transfer per second	Bits per second	Bps
Thousand bits transfer per second	Kilobits	Kbps
Million bits transfer per second	Megabits	Mbps
Billion bits transfer per second	Gigabits	Gbps
Trillion bits transfer per second	Terabits	Tbps

Throughput

This is the amount of data sent and received over a connection, including any delays that occur over a period of time.

Throughput is very important for measuring network performance as it makes us see the reality by taking into consideration different factors that occur during transmission.

Let us now see an analogy:

Suppose there is a factory that has the capacity to produce 5000 bowls of ice-cream per day without the machine turned off. Suppose from time to time the machine breaks down, or power goes out or the machine is switched off for cooling. Due to this, the machine only produces 2000 bowls per day.

The breakdown:
The bandwidth = 5000bowls/day
The throughput = 2000bowls/day

So we see that the capacity is 5000 bowls per day but in reality it is 2000 bowls per day.

Throughput can be measured in bits per second(bps), data packets per second(pps) or data packets per time slot. Will now take another example to illustrate throughput.

Example:
A network with a bandwidth of 15Mbps can pass an average of 6000frames per minute, with each frame carrying an average of 5000bits. What is the throughput of this network?

From the above question we can deduce that:
1 frame carries an average of 5000bits
Now number of bits for 6000frames will be:
6000 * 5000=30000000bits
So we have 30000000bits passing through the network in 1 minute
As we know:
1min = 60secs
Throughput=30000000/60
Throughput = 500000bps

Causes
Throughput has several causes which we can take a look at.

Bandwidth: Higher bandwidth allows for greater throughput, because more data can be transmitted over a period of time.
Latency: The time taken for data to get to its destination. Higher Latency reduces throughput.
Congestion: Congestion can lead to increased throughput because it causes delays.
Equipment Performance: The performance of network equipments, such as routers, switches and network interface cards can affect throughput. Higher performance equipment can generally handle larger volumes of traffic more efficiently, leading to higher throughput.

Latency

This is the time taken for a packet of data to travel from source to destination and back again.

Though the above definition has some ambiguity, as latency can be broken down into two types, namely; One-way latency and Round-trip latency.

One-way latency: This is the time it takes a packet of data to travel from source to destination. That is server to client.
Round-trip latency: Round-trip latency is the time required for the packet of data to travel across the network server to client to server.

Conclusion

Performance monitoring is very crucial when dealing with software and hardware. Paying attention to performance can help maximize the output of our services by providing signals on how to optimize them.

How I Built Web App To Evaluate Polynomials Using Horner's Algorithm

Stephen Odogwu — Fri, 15 Sep 2023 15:54:57 +0000

Horner's algorithm is a method used to evaluate a polynomial at a certain value x by separating the polynomial into monomials (A monomial is a polynomial with only one term. It can have multiple variables and a higher degree e.g. 2x^3wv).

We usually start evaluating from the monomial with the highest degree. The result obtained is added to the monomial of the next degree and so on till the lowest degree at x^0 which evaluates to 1. Horner's algorithm is recursive by nature, as we apply the result of the previous monomial to the current one.

A polynomial is expressed as

f(x) = a0 + a1x + a2 x^2 + ... + a n x^n
a is co-efficient of x
n is highest degree of x
k is dynamic degree of x from 0 to the nth degree.

See the algorithm below:

Make k = n
set bk=ak
bk-1=ak-1 + bkx0
K=k-1
If k ≥ 0, go back to step 3 else end. Where x0=x, b=result of monomial.

Step 3 of the algorithm is the recursive case.
The else part of step 5 is our base case.

A polynomial of the 3rd degree will be
f(x) = a0 + a1x + a2 x^2 + a3x^3

Let us see an example below

Example
Evaluate the polynomial
f(x)=2x^3 + 4x^2 + 3
where x = 3
following the algorithm
step 1: k=3

step 2:
b3=a3
a3=2
b3=2

step 3:
b2=a2 + b3x0
b2=4 + (2*3)
b2=10

step 4:
k=2-1
k=1

Back to step 3:
b1=a1 + b2x0
b1 = 0 + (10*3)
b1 = 30

step 4:
k=1-1
k=0

Back to step 3:
b0=a0 + b1x0
b0 = 3 + (30*3)
b0 = 93

step 4:
K=0-1
k=-1
end
Therefore the sum of our polynomial is 93

Read more on Horner's algorithm here Horner's algorithm

Now unto the web application that was built following Horner's algorithm.

Building The Frontend Logic

To achieve user interaction, we will be taking user input. So we need the following.

Input field to take the value of x.
Input field to enter co-efficients of x.
A button to submit each entry.
We need a display where users can read from, we will use an HTML paragraph element for this.
We are also going to display instructions on how to use the app following Horner's algorithm principles.

You can go ahead to view the source code here source code,
otherwise keep reading to get a full explanation.

Since Horner's method is iterative as well as recursive, we aim to gather the co-efficients of x in an array, let us call that array polynomial.

let polynomial=[]

Some HTML code:

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <link rel="stylesheet" href="style.css">
    <title>polynomial calculator</title>
</head>

<body>
    <header><hr>CALCULATOR FOR POLYNOMIAL EVALUATION<hr></header>

    <p id="instruct">Enter co-efficients of x from largest degree(power)to lowest degree(power of zero) in first box<hr> </p>
    <p id="note">   Note:enter 0 as coefficient for degrees not present.<br /> ..<span>Example:2x^4+x^2+1</span></p>
        <h2>METHOD<hr></h2>
    <p id="entertwo"> Enter 2 as coefficient of x^4,enter 0 as coeffiecient of x^3 since it is not present and 1 as coefficient of x^2,<br/>
        then the last 1 as it is a coeffiecent of x to power 0.<span><br/>2x^4 + 0*(x^3)+1*(x^2)+0*(x^1)+1*(x^0)</span>
      <br>click on enter coefficient after each entry and enter value of x in next box,then click on sum polynomial when all is done.
      <br>click on display to view coefficients</p>
    <div class="forarray">
    <label for="topush">Enter coefficients of x </label>
    <input id="topush" type="number">
    <label for="tosub" id="sub">Enter value of x</label>
    <input id="tosub" type="number"> 

    </div>
    <p id="toread"></p>

    <div class="choices">
    <button id="but1">enter coefficient</button>
    <button id="but2">display</button>
    <button id="but3">sum polynomial </button>
       </div> 
    </body>
    <script src="script.js"></script>
</html>

Some JavaScript code:

let polynomial=[]
let y=polynomial.length
Let tosub=document.getElementById("tosub")
let topushA=document.getElementById("topush")
let choices=document.querySelector(".choices")
let coefficients=topushA.value
let button=document.querySelector("button")
let toread=document.getElementById("toread")

We declared our elements from the DOM in the code above.

We entered the co-efficients of x in the input field with the id topush and named the variable topushA.
We enter the value of x in the input field with id tosub. We declared a variable and named it coefficients, which is any value entered in the topush input field.
y is the length of our array which is polynomial.length. We have 3 buttons wrapped in a div class called choiceswhich we will be adding eventListeners to.
The p tag with the id of toread is where user input will be displayed.

We will use the event delegation method to add an event listener to the buttons
and use switch case for each button click condition. We will be having three case conditions in our switch, since we have 3 buttons. Each click will trigger some block of code.

/*event delegation*/
choices.addEventListener("click",clicked)
function clicked(e){
if(e.target.matches("button")){
var button=e.target
switch(button){

  /*enter x coefficients*/
case but1:
 coefficients=topushA.value
toread.innerHTML=coefficients+ " " + "is added "
polynomial.push(+coefficients)
break;

/*display*/
case but2:
n=polynomial.length
coefficients =polynomial[i]
toread.innerHTML="coefficients of powers of x are:<br/>"
for(var i=0;i<n;i++){

toread.innerHTML+=polynomial[i] + " " 
}

break;
}
}
}

At the moment, we only have two cases.
Case 1 triggers the array push method. We click this button whenever we add a coefficient of x in our input box , this then adds the coefficient to our polynomial array.
case 2 triggers our for loop to display the coefficients of x which are the values of the array. We click this button to make sure we entered the correct values.

Now we need to trigger a button that will sum up the polynomial. Under this scenario we will utilize Horner's principle.

let polynomial=[]

var y=polynomial.length
var tosub=document.getElementById("tosub")
let topushA=document.getElementById("topush")
let choices=document.querySelector(".choices")
let coefficients=topushA.value
var button=document.querySelector("button")
let toread=document.getElementById("toread")

/*event delegation*/
choices.addEventListener("click",clicked)
function clicked(e){
if(e.target.matches("button")){
var button=e.target
switch(button){

  /*enter x coefficients*/
case but1:
 coefficients=topushA.value
toread.innerHTML=coefficients+ " " + "is added "
polynomial.push(+coefficients)
break;

/*display*/
case but2:
n=polynomial.length
coefficients =polynomial[i]
toread.innerHTML="coefficients of powers of x are:<br/>"
for(var i=0;i<n;i++){   
toread.innerHTML+=polynomial[i] + " " 
}

break;

/*sum polynomial*/
//applying principle of Horner's algorithm  
case but3: 
  function Horner(polynomial){
    var  y= polynomial.length
     if( i==y) return;
result = polynomial[i]+(unknown* result)
 i++
 Horner(polynomial)
   }
let unknown=tosub.value 
var i = 1
let result= polynomial[0]
Horner(polynomial )
toread.innerHTML="The sum of the polynomial is:" + result
break;
}
}
}

Our third case triggers the sum of our polynomial.
We declared a variable which we called unknown

var unknown=tosub.value

Where unknown is x, since the input field with id of tosub is where we enter the value of x. We initialized var i as 1, since we will use it to iterate the array, in this case polynomial.

We also defined a function with polynomial as parameter. We declared a variable
var result and initialized it with polynomial[0]. This is equivalent to step 2 of Horner's algorithm where we set bk = ak. This is initializing b with the coefficient of the highest degree of x. b is result,
polynomial[0] is coefficient of highest degree of x. We then increment i until it reaches base condition of i==y where y=polynomial.length.
We then have the recursive call which continues as long as our base condition is not reached.

Conclusion

We have learnt about Horner's algorithm, used in discrete maths, and how it can be applied in programming, by building a polynomial evaluator.

To test it out, you can check out the links below.

view source code

https://github.com/Stevepurpose/polynomial-Evaluate

view live app

https://stevepurpose.github.io/polynomial-Evaluate/

The JavaScript Slice Method

Stephen Odogwu — Sat, 09 Sep 2023 19:30:46 +0000

This article is for anyone who has consistently struggled to understand the JavaScript slice method, or who confuses the slice with the splice. If you feel you are that person, jump in as I break it down to you and you gain more clarity. We will be exploring the way it works, step by step.

What Does The Word Slice Mean?

Now what does the word slice mean in English language? slice is a word that is used as a noun and as a verb depending on the context. It usually refers to the cutting of something into thin flat pieces or the appearance of a part of something.

As a noun : It is a portion of something. A thin part or portion.

As a verb : To cut into thin flat pieces.

Slice In Programming

Slice is a method usually attached to arrays and strings in JavaScript (other programming languages have methods for achieving their slice). The slice method is a method used to extract, preserve and return index values in JavaScript.

Since JavaScript is a high-level programming language which is close to the human language, the writers must have had no problem integrating the slice word into it. The slice is usually used to extract part of an array or string to form new ones respectively.

The slice is commonly used in JavaScript string and array data types. The word slice has been knocking programmers heads together since time immemorial considering its spelling similarity with the splice (another JavaScript method). Don't worry by the end of this text your knowledge would improve.

With Strings

As we know, when dealing with strings in JavaScript, characters like commas, full-stops and spaces are treated as indexes. This index count usually starts from zero (as is done in programming), but when I talk, think and explain positions I like to start my count from one. So for the purpose of this article
index 0 == position 1.
Note this as it will be very vital to your general understanding of the slice. Below let us see some code.

const str = "My name is Steve"

In the above, M is our index 0 otherwise written as str[0] and is our first position. Now the space between My and name is index 2 otherwise known as str[2], position 3 and y str[1] position 2.

Now let us go to the main issue at hand, using the slice method with strings.

Slice with Single Positive Index

Here our slice method takes a single positive index.

Counting From 1

In this scenario, we start our count from 1 and not 0.

Syntax

str.slice(chopOffPositions)

The Breakdown
chopOffPositions is what I like to call my first parameter and I'll show you why

const str = "My name is Steve"
const txt = str.slice(8)
console.log(txt)
//'is Steve'

The length of str is 16.

const str = "My name is Steve"
console.log(str.length)

Value	position
m	1
y	2
space	3
n	4
a	5
m	6
e	7
space	8
i	9
s	10
space	11
s	12
t	13
e	14
v	15
e	16

So we chop off the first 8 positions which are str[0] to str[7] and return "is Steve".

Output

Value	Position
i	9
s	10
space	11
s	12
t	13
e	14
v	15
e	16

Slice with Two Positive Indexes

Occasionally the slice takes a second parameter which I like to call the chopOffAfter.

Syntax

str.slice(chopOffPositions, chopOffAfter)

The Breakdown
So what happens is that, it first chops off the number of positions specified in the first parameter then returns the values from the immediate position after, up to the position specified in the second parameter and chops off the rest positions after the second parameter.

const str = "My name is Steve"
const txt = str.slice(8,12)
console.log(txt)
//'is S'

We chopped of the first 8 positions str[0] to str[7] and chop off everything after the 12th position str[11].

Value	Position
m	1
y	2
space	3
n	4
a	5
m	6
e	7
space	8
i	9
s	10
space	11
s	12
t	13
e	14
v	15
e	16

Output

Value	Position
i	9
s	10
space	11
s	12

Now this above examples are when we count from 1. Next, I will show you how to interpret it with the Count from 0.

Counting From 0

For this examples, we will count from 0.

Syntax

slice(ignoreIndexBefore)

The Breakdown
ignoreIndexBefore is what I like to call my first parameter, and I'll show you why.

const str = "Hello world"
const text=str.slice(6)
// 'world'

Value	Index
H	0
e	1
l	2
l	3
o	4
space	5
w	6
o	7
r	8
l	9
d	10

What we do is that we ignore every index that comes before the index specified as our argument while it extracts, preserves and returns the values from the index specified.

Output

Value	Index
w	6
O	7
r	8
l	9
d	10

With Second Parameter
Let us see what happens when our slice takes a second parameter.

Syntax

slice(ignoreIndexBefore,ignoreIndexFrom)

The Breakdown
ignoreIndexFrom is what I like to call my second parameter and I'll show you why.

const str = "Hello world"
const text=str.slice(6,8)
//'wo'

Value	Index
H	0
e	1
l	2
l	3
o	4
space	5
w	6
o	7
r	8
l	9
d	10

What happens is that we chop off from the index specified as our second argument, after we have chopped off those in our first argument. So we only extract preserve and return our index 6 and index 7.

Output

Value	Index
w	6
o	7

Slice with Single Negative Index

When dealing with slice and negative indexes, there is some difference in the way the index values are extracted.

When dealing with a single negative index,it extracts, preserves and returns the number of indexes attached to the negative sign with the count starting from behind (right to left).

Counting From 1
Now we see what happens when we start our count from 1.

Syntax

str.slice(keepPositions)

The Breakdown
keepPositions is what I like to call my first parameter and I'll show you why.

const str = "Steve has started cooking."
const text = str.slice(-8)
console.log(text)
//'cooking.'

Value	Position
s	26
t	25
e	24
v	23
e	22
space	21
h	20
a	19
s	18
space	17
s	16
t	15
a	14
r	13
t	12
e	11
d	10
space	9
c	8
o	7
o	6
k	5
i	4
n	3
g	2
.	1

We count backwards starting from .(full-stop) up until c, but rather than chopping them off, in this scenario it returns them.

Output

Value	Position
c	8
o	7
o	6
k	5
i	4
n	3
g	2
.	1

Slice with Two Negative Indexes

The slice method with two negative indexes has the same extract philosophy with our slice with positive index arguments. Except that we count from behind, thereby flipping our two parameters, with the first becoming the second and vice versa.

Counting From 1
Let us see what happens when we count from 1.

Syntax

str.slice(chopOffAfter,chopOffPositions)

The Breakdown
We will be counting from behind(right to left), but in this case we will be following the extract, preserve and return philosophy of the slice with positive indexes.

let str = "Call me dev Steve"
let text=str.slice(-9,-5)
//'dev'

The above code returns dev and space,even though we can't see the space.

Value	Position
c	17
a	16
l	15
l	14
space	13
m	12
e	11
space	10
d	9
e	8
v	7
space	6
S	5
t	4
e	3
v	2
e	1

Counting from behind, it chops off the first five positions and starts to return from the 6th position up until the 9th position which is our first argument, and chops off everything after the 9th position. Remember we are counting from behind.

Output

Value	Position
d	9
e	8
v	7
space	6

Now this above examples are when we count from behind using 1 as start, next I will show you how to interpret it with the count from 0.

counting from 0

starting our count from index 0.

Syntax

slice(showIndexBefore)

The Breakdown
As specified earlier with our count from 1, when we have a single negative index as our argument, it actually returns those number of positions rather than chopping them off.
When we count behind(right to left) from 0, we show the indexes before the specified index parameter. Take for instance we have -6 as our argument, it returns str[0] to str[5] rather than chop them off, let us see some code.

const str=" I heard PHP devs love lambos"
const text = str.slice(-6)
console.log(text)
//'lambos'

The above code returns lambos which are the values from index 0 to index 5 before index 6 which was specified as our negative index argument.

Value	Index
I	27
space	26
h	25
e	24
a	23
r	22
d	21
space	20
P	19
H	18
P	17
space	16
d	15
e	14
v	13
s	12
space	11
l	10
O	9
v	8
e	7
space	6
l	5
a	4
m	3
b	2
o	1
s	0

Output

Value	Index
l	5
a	4
m	3
b	2
o	1
s	0

With Two Negative Indexes
The slice method with two negative indexes has the same extract philosophy with our slice with positive index arguments except that we count from behind, thereby flipping our two parameters. The first becoming the second and vice versa. In this instance we will start our count from 0.

Syntax
slice(ignoreIndexFrom,ignoreIndexBefore)

The Breakdown
So we count from behind (left to right), performing our operations on the second parameter first, we chop off indexes before it, we return the index which is our argument up to the index before the first argument. We chop off the index from the first argument and all those in front of it(will be back of it in this case since we counting from behind).

const str = "When men were boys,they played"
const text=str.slice(-3,-1)
console.log(text)
//ye

Value	Index
w	30
h	29
e	28
n	27
space	26
m	25
e	24
n	23
Space	22
w	21
e	20
r	19
e	18
space	17
b	16
o	15
y	14
s	13
,	12
Space	11
t	10
h	9
e	8
y	7
space	6
p	5
l	4
a	3
y	2
e	1
d	0

Output

Value	Index
y	2
e	1

Slice with a Combination of Positive and Negative Indexes.

Occasionally we might see that our slice has one negative and one positive index as arguments. I'll be using the count from 0 for my examples, but you can apply the count from 1 philosophy if you like.

Positive First, Negative Second

In this scenario our count takes a kind of convergent pattern, technically we count from left to right for the first argument and right to left(behind) for the second argument.More like ignore indexes for the first argument while counting from left to right and ignore indexes before the second argument while counting from right to left.

syntax

slice (ignoreIndexBefore, ignoreIndexBefore)

const str = "Tech is the future"
const text = str.slice(5,-7)
console.log(text)
// 'is the'

Value	Index
T	0
e	1
c	2
h	3
space	4
i	5*
s
space
t
h
e	7*
space	6
f	5
u	4
t	3
u	2
r	1
e	0

Output

Value	Index
i	5
s
space
t
h
e	7

So we basically count from both sides and stop where we find our indexes, we chop off whatever came before them from both sides.

Negative First,Positive Second

In this scenario our first argument is negative and our second is positive, we will count backwards (left to right) in reference to our first argument and forward in reference to our second argument.

Syntax

slice(ignoreIndexFrom, ignoreIndexFrom)

Let us now see an example.

const str = "Tech is the future"
const text = str.slice(-13,7)
console.log(text)
// 'is'

Count back:

Value	Index
T	17
e	16
c	15
h	14
space	13 *
i	12
s	11
space	10
t	9
h	8
e	7
space	6
f	5
u	4
t	3
u	2
r	1
e	0

Count front:

Value	index
T	0
e	1
c	2
h	3
space	4
i	5
s	6
space	7
t	8
h	9
e	10
space	11
f	12
u	13
t	14
u	15
r	16
e	17

So we ignore from 13 upwards when counting from behind, and ignore from 7 downwards when counting normally.

Output

Value	Index
i	5
s	6

With Arrays

At this point you should have a good understanding of the slice, so I won't be going in depth like I did with the string slice because the concepts are all the same as long as you know that array indexes are separated by commas. You should be able to apply all you've learnt so far. You only need to know that slice returns a new array by creating a shallow copy of the old array and returning as a new array.

So I'll just post some code below, each showing the different negative index slice scenarios. The positive index is quite straightforward to understand. You can use any of the count methods(from 0 or 1) to practice.

const array=["Steve","kim","Ben","Joe","Dave"]

//one positive one negative index
const newArray=array.slice(2,-1)
console.log(newArray)


//two negative indexes
const anotherArray=array.slice(-2,-1)
console.log(anotherArray)

//one negative,one positive
const newArray2=array.slice(-4,2)
console.log(newArray2)

//one negative
const newArray3=array.slice(-4)
console.log(newArray3)

The Splice Method

The splice is a JavaScript array method, it is not a string method. The splice basically works as a value substitution method on arrays, it could also be used to delete a value outright.

Syntax

array splice(index, howMany)
array.splice(index, howMany, item1, ....., itemN)

The Breakdown
Whenever we have just two arguments index and howMany, it means it will be deleting a value.
index∆ represents the starting point for the index which we intend to change the value, while howMany specifies the number of indexes which their value will be changed or removed. item1 is the value that will be substituting the value whose index is specified as first argument. Whenever howMany is greater than 1, it means we will be changing or deleting more than one value. We maintain our index count from 0.

//delete a value
const array=["rice","meat","fish","shrimps"]
array.splice(1,1)
console.log(array)
//["rice","fish","shrimps"]

The above code starting from index 1 deletes meat alone and doesn't replace it.

//delete 2 values
const array=["rice","meat","fish","shrimps"]
array.splice(1,2)
console.log(array)
//["rice","shrimps"]

The above code starting from index 1 deletes two values meat and fish but doesn't replace them.

const array=["rice","meat","fish","shrimps"]
array.splice(1,1,"gravy")
console.log(array)
//["rice","gravy","fish","shrimps"]

The above code replaces meat with gravy.

Differences Between Slice and Splice

Slice is used on arrays and strings, while splice is only used on arrays.
Slice returns a new array by creating a shallow copy of the old array and returning as a new array while splice does not return a new array.
Slice does not modify the array, while splice modifies the array.

References

To know more about the splice, follow any of the links below.

Learn to Protect Passwords with Bcrypt Hash in a Few Minutes

Stephen Odogwu — Wed, 09 Aug 2023 08:32:14 +0000

Whenever we put in our details to register on any website, attackers are always on the lookout to steal our details. We hear terms like encoding and encryption, but they can never be like the Bcrypt hash format, where we hash passwords with bcrypt. Lately I have been working on the backend and one password protection tool I always see and have come to really love and understand is bcrypt.

In this article we specify the differences between encryption, encoding and hashing, we also go to the bone of contention which is how to create a bcrypt password hash.

Differences Between Encryption, Encoding and Hashing

We now take a look at the three data protection practices commonly used, this helps us to know the differences between them.

Encryption

This is basically a method of securing data to make it unreadable by using an algorithm and a key. The drawback with Encryption is that it is reversible.The original data can be retrieved with the right decryption key.

Encoding

Encoding is mainly done for system compatibility and not for protection, even though it converts data to a different format so that it can be stored on certain systems but definitely not for protection against hackers.

Hashing

The main difference between a hashed password and an encrypted one is that hashing only works one way and cannot be reversed, so you can hash a password but cannot un-hash it, unlike encryption that can be decrypted through brute force attacks and rainbow table attacks. So to minimize these, we add salt to the password before it is hashed. The salt is randomly generated data that is added to your password to make sure it is unique.

What is Bcrypt

Bcrypt is a short form for "Blowfish-crypt ". It is a cryptographic algorithm designed for password hashing. Not all hash algorithms are the same, and there are many options available. It was developed by Niels Provos and David Mazières, to address vulnerabilities and weaknesses found in other hash functions.

Bcrypt is widely recognized as a secure and reliable choice for password hashing. It is a password hashing function.

How does Bcrypt Work?

The salt is a major ingredient in this process. The salt helps mitigate against brute force attacks and rainbow table attacks. Bcrypt uses the blowfish cypher which is slow enough and mitigates the limitations of the SHA functions which are designed to be computationally fast.

If a hash password is calculated or generated with too much speed, the faster brute force attacks can get through, so we use the bcrypt hash format to protect against this. Bcrypt is used across various programming languages, but in this article I will be concentrating on Node.js because that is what I use.

Password Hashing in Node.js With Bcrypt

We know that to use Bcrypt we first need to install the library.

npm install bcrypt

We then include the bcrypt module in our code.

const bcrypt = require("bcrypt")

Now bcrypt has several methods, and we can choose to perform our hash synchronously or asynchronously. You can find documentation for npm bcrypt.
However as a personal preference I like to use the asynchronous method, async await precisely.

Example of Password Hashing With Bcrypt in Node.js

Suppose we are making an online registration form where users are required to input their emails and passwords.

async function register(email, password){
/*We know salt is needed to hash our passwords,let's create it*/

const saltRounds = 10
const salt = await bcrypt.genSalt(saltRounds)

/*we now have our salt, we use it to hash our password with the hash method*/
const hashedPassword= await bcrypt.hash(password,salt) 
}

Now we have our hashed password as hashedPassword. Suppose we have a User model made with mongoose for a Mongodb database, which we want to create documents from, where document properties are email and password which will be taken from client input. We can now pass the hashedPassword as value of password, like below.

async function register(email, password){
const saltRounds = 10
const salt = await bcrypt.genSalt(saltRounds)
const hashedPassword=await bcrypt.hash(password,salt) 
//create user 
const user = await User.create({email, password: hashedPassword})
return user
}

It is a very easy to understand package, so straightforward.
Now let's assume the above to be a sign-up function.

We could also utilize it for a login function. Assume we have the same User model which we used above. We could use the bcrypt.compare method.

async function login(email,password){
if(!email||!password){
    throw Error("All fields must be filled")
}
// check if user exists via email
const user=await this.findOne({email})
if(!user){
    throw Error('incorrect login details')
}
//via password
let match=await bcrypt.compare(password,user.password) //where user.password is hashed password

if(!match){
    throw Error('incorrect login details')
}
return user
}

In the above code, we compared the initial password that must have been input from client side with user.password, as we saw above, user.password is now hashedPassword from the first register function where we passed hashedPassword as value of password in our user document. If there is a match as a result of bcrypt.compare, only then can the user login, otherwise it is assumed that they haven't previously signed up because signing up automatically hashes the password.

Takeaways

For security purposes,it is necessary to hash passwords before storing them in a secure database

Before hashing a password we apply salt. A salt is a random string that makes the hash unpredictable.

saltRounds: The number of times the hashing function is added to the password and salt combination. An increase in the number makes the time and resources that will be required to crack the password more. So a saltRound of 11 for instance will take longer to crack than a 10.

Optional Chaining in JavaScript(?.)

Stephen Odogwu — Wed, 10 May 2023 04:07:27 +0000

The Optional Chaining Operator denoted with a question mark and a dot (?.) is a feature introduced in JavaScript ES2020.

Decided to write about this operator because for a very long time I used to be very confused when I was going through code and saw it. Looks like the Ternary Operator but I could not just grasp its use until I started writing more advanced React.js code.

The Optional Chaining Operator is generally used to avoid the TypeError which occurs when we try to access the property of a non existent field in nested objects. The nested object could be data from an API. Anyone who has ever worked with a Rest API for instance, can attest to the nesting of data that goes on there. This Optional Chaining Operator creates more user-friendly errors.

A non existent field is undefined and as we know data types like undefined and null are primitive data types and one thing about primitives is that they don't have properties. Let us illustrate with code below.

const person={
name:'Steve',
address:{
city:'Abuja',
street:'5 garki lamido'
}

If we try to access person.name in the above code we get Steve as output.

console.log(person.name)

But if we try to access person.country:

console.log(person.country)

We get undefined above because we don't have a country field.

Now if we try to access person.country.name

console.log(person.country.name)

Recall from 2 we got undefined, then we tried to access undefined.name and we got a TypeError:cannot read properties of undefined. Primitives cannot have properties never forget that.

Bring in Mr Optional Chaining to mitigate against the TypeError which we are getting. So if we were to try

console.log(person.country?.name)

we get undefined as output.

Use With Methods

Suppose we try to access a method with the above code, as we can see there is no method in our person object so if we have a method called methodMan()

console.log(person.methodMan())

we would get an error message telling us it is not a function.

But if we were to do:

console.log(person.methodMan?.())

we would get undefined.

Note

We can use optional chaining multiple times in nested objects.

const building={
name:"better days ahead",
place:"school",
details:{
location:"mayfield way",
education:"basic"
}
}

let us try to access
building.founded.age.education

console.log(building.found.age.education)

we get a TypeError: cannot read properties of undefined.
Notice that we don't have found and age in our object
So let us do some Optional Chaining.

console.log(building.found ?.age?.education)

we get undefined

Conclusion

So we can see that the ?. operator is a very good error handling operator that can help generate user friendly errors when we are working on our applications.

I can help with 'this' Confusion

Stephen Odogwu — Sun, 26 Feb 2023 10:23:29 +0000

First, let us go back to the roots, the English meaning of the word 'this'. According to the Oxford dictionary, this can be used to identify a specific person or thing close at hand, it can also be used to identify something. For example "this is Stephen talking". The word can also be used to compare the distance between two things, the nearer one referred to as this and the farther one referred to as that.

Prerequisites

Know the difference between methods and functions.
Know what an Object literal is.

Use in JavaScript

Now over the past 14months since I have been using and writing JavaScript, I realized it is used in 4 areas. Below is a list of the areas.

Global scope in a browser environment
Object Oriented Programming (OOP)
Data structures and algorithms(DSA) e.g. Implementation of stacks ,Queues,Binary search Trees.
Document Object Model (DOM) manipulation

The Rundown

Below we throw more light on the four listed areas above.

Global Scope

When used in the global Scope, one with a web environment, not a Node.js environment, this points to the global object which is window.

Meaning when we run JavaScript as an HTML attachment, like below.

<html> 

<body>

</body>

<script src="script.js">
</script>
</html>

Such that this points to the window Object.

console.log(this) //window object

console.log(this==window) //true

Let us take a look at the behaviour Outside the web environment: Node js*

Such that this points to an empty Object.

console.log(this) //{ }
console.log(this==window) //reference error

Before you get scared!!.
Before we dive into use in code, I am going to list the use cases and places of this in OOP, so that you can know what is obtainable as soon as you see them.

this is not used on properties of Object literals. It is only used within the methods of object literals pointing to the properties.
it is also not used on the properties of factory functions. It is only used optionally within the methods of factory functions.
It is used on properties and methods of constructor functions except when making prototypes.
it is used on properties and methods of classes except when making prototypes.

Object Oriented Programming (OOP)

To get a picture of things I just enumerated, let us touch briefly on the methods of creating Objects in OOP JavaScript to visualize it.

Object literal: The this keyword is not used on the properties here. It is only used within the method to point to a property. in this example the greet method, it points to name.

const person = {
  name: 'steve',
  age: 30,
  greet: function () {
    console.log(`Hello, say goodmorning to ${this.name}.`)
  }
}
person.greet(); // logs "Hello,say goodmorning to steve."

Factory Functions: The this keyword is only used within the method definition in factory functions. In this case getFrom() to refer to the from property. But it is not used on the properties, from and to.

function way(from,to){
return{
from:from,
to:to,
getFrom:function(){
console.log(this.from)
}
}
}
//Instantiate
const route=way("Lagos","Toronto")
route.getFrom()

Mind you, you can also rewrite the above as 👇

function way(from,to){
return{
from,
to,
getFrom:function(){
console.log(this.from)
}
}
}
//Instantiate
const route=way("Lagos","Toronto")
route.getFrom()

Or no need to add this within the method getFrom().

function way(from,to){
return{
from:from,
to:to,
getFrom:function(){
console.log(from)
}
}
}
//Instantiate
const route=way("Lagos","Toronto")
route.getFrom()

Constructor Functions: One of the confusions people face, is not knowing the difference between constructor and factory functions, and that is a major confusion as far as this keyword goes. By convention, constructor function names start with uppercase letters (capital letters), and we use the this keyword to enumerate their properties. We also instantiate with the new keyword which we don't do in factory functions. Note that the constructor is a template which we use to build our objects.

function Way(from,to){
    this.from=from
     this.to=to
    this.get=function(){
        return this.from
    }
}
//instantiate
const route=new Way("Lagos","London")
console.log(route.from)
console.log(route.to)
console.log(route.get())

Class and Class Constructor: Follows the same principle as the constructor function, except some syntax modification which some call syntactic coating. We use the new keyword to instantiate too. Notice the difference that a class is used to encapsulate constructor.

class Lecturer{
    constructor(name,degree){
        this.name=name
        this.degree=degree    
}
}

//instances of class
let person1=new Lecturer("Jim","PhD")
let person2=new Lecturer("Kennedy","phD")
console.log(person1)
console.log(person2)

DSA

The use in DSA follows the class and class constructor syntax talked about above. Below is the blueprint to implement a stack with an array using the class syntax.

class Stack {
        constructor() {
            this.items = [];
            this.top = -1;
        }
    }

DOM manipulation

I have also seen some DOM manipulation with OOP using the DOM. It also employs the class syntax in this scenario.Below is an example I saw.

 class Button {
  constructor(text,color,clickr) {
    this.element = document.createElement("button");
    this.element.innerText = text;
    this.element.style.color=color
    this.element.addEventListener("click",clickr);
  }
  //prototype zone

  appendTo=function (parent) {
    parent.appendChild(this.element);
  }
}

//  instantiate Button class
var myButton = new Button("Click me!","red", function() {
  alert("Button was clicked!");
});
// Append the button to the DOM myButton.appendTo(document.body);

Behaviour Within Regular Functions

Regular functions are functions not attached to any object. It will always take the value of the owner of the function in which it is used. Within functions it usually points to the window object, if in strict mode it reads undefined.

function greet(){
console.log('Good Morning')
console.log(this)
}
greet()
//outputs Good Morning and window

In strict mode

'use strict'

function greet(){
console.log('Good Morning')
console.log(this)
}
greet()
//outputs Good Morning and undefined

Arrow functions

When used within Arrow functions, this points to the parent scope of the function they are used in.

let x=()=>{

console.log(this)

}

x()

//outputs window since the parent of the function is the global scope

Recommendation

To gain more clarity on all I touched on, to brush up your OOP knowledge. Check the Procademy YouTube channel, he has a series on object oriented programming in JavaScript. Follow it chronologically, he breaks every concept down. Even a toddler would understand. Don't be scared to drop a question, correction or comment.

High Level And Low Level Programming Languages

Stephen Odogwu — Fri, 10 Feb 2023 01:56:31 +0000

I recall when I first started to code. Started with HTML, CSS and then I moved on to JavaScript. One day while studying, I came across a topic named 'Memory management in JavaScript'.

Now the text talked about garbage collectors in high-level languages, and also talked about manual memory management in low-level languages (this was before I started learning the C language). It didn't make sense to me at the time.

My curiosity was sparked, so I read about the levels of programming languages. A few months later while studying the C language, a video tutorial on data structures and algorithms(implementation of the Linked List precisely), it all came flooding back.

Now we deleted a node from the Linked list and then we used the free() an in-built C function to delete a pointer temp, which was pointing to the address of that node(recall manual memory management,the free() did that). With this I decided to write something about my little experience and I hope every beginner can take something from it.

High-level Programming Languages

They are programming languages very close to the human language (not just English Language, I have seen programs written in Arabic). If we were to liken a high-level programming language to a structure, the human language would form part of the concrete used for construction.

Due to the fact that high- level programming languages are closer to the human languages, they will need to be converted by an interpreter to a machine code 1 & 0. In a way, this reduces speed in comparison to low level languages.

Just like Craig Bruce said, “it’s hardware that makes a machine fast, it’s software that makes a fast machine slow”.

On the other hand, it is portable and can run on any platform, errors can be easily debugged, it has automatic memory management like garbage collection.

Overall, these programming languages, employ the use of abstraction as one of their major pillars. In layman’s terms, abstraction means placing functions which have sub actions hidden from the user, i.e. showing essential things while hiding implementation to provide a very good user experience. Examples are JavaScript, Python and Ruby.

Low-level Programming languages

If programming were to be juxtaposed with the family tree, the low-level programming languages would be at the top. These languages are very close to the machine language, infact most modern high-level languages were written in these lower level languages. Machines only understand bytes which are mostly written in 1s and 0s which is binary and can be very tedious to write. The programmer must remember numerous technical details which make it error prone.

Due to the fact that low-level programming languages are closer to the machine, they need no compiler or interpreter and are directly executed on the computer hardware, so this doesn’t slow it down. Low-level languages are used in places where performance, speed and efficiency are critical elements to the success of a program. If there’s a part of the program where speed is required, one may only write that part in machine code and the rest in a high-level language of his choosing. We also have to free up memory manually.

One major point to note is the fact that these programming languages, provide little to no abstraction from the computer’s instruction set architecture. It’s also relatively hard to debug. The two examples of low-level languages are Assembly and Machine Code. We also know that Assembly language for instance is hardware dependent, because assembler instructions have to reflect the hardware instructions of the Computer they are running on. So only an assembler built for that hardware can produce a valid program from that source code. Several Assembly variations exist, examples are x86 assembly, ARM assembly e.t.c. The two examples of low-level languages are Assembly and Machine Code. C is also sometimes referred to as a low-level programming language in some circles, because it has no automatic memory management (recall I said we had to free up memory after deleting a node) and provides a direct control over hardware.

Medium-level Programming Languages

They are also known as intermediate or pseudo programming languages.

Now a language like C++ on the other hand is referred to as a mid-level programming language likewise C sometimes. C++ combines features of both high-level and low-level languages. Features like classes, objects and abstraction are high level qualities of C++, however it still allows low-level control and is used in systems and game engines. But you also find out that the lines are blurred. We find out that even some so called high level programming languages like Ruby, Python, C# and Java are sometimes referred to as medium-level.

Now let’s talk about Java. The Java compiler was created in C and Java has many features of C, but lacks some things like working directly with pointers. Even though Java is referred to as high-level in some circles.

Now there's something else I would like to touch on. Even though we use them interchangeably, the compiler is different from an interpreter.

Compiler Vs Interpreter

The interpreter is actually used in the more high-level languages like JavaScript and Python. It converts statement by statement, line by line of code and runs it while the program is running. This makes it produce errors line by line, thus making it slower. Although makes debugging easier.

The compiler on the other hand converts the complete code before execution, thus making it faster, even though debugging might not be as easy as the interpreter. Languages like C and C++ use this.

Worthy Mention

The Assembler:This converts programs written in Assembly code into Machine code.

How I Solved My async await vs .then Syntax Confusion.

Stephen Odogwu — Fri, 13 Jan 2023 16:47:33 +0000

When I first started studying promises in asynchronous JavaScript, I used to be confused about the .then syntax and the async await, I was like "NOT AGAIN!!!", how am I supposed to memorize all that syntax!!??.

But then, coding shouldn't be about memorizing, it should be about understanding concepts where they apply.

So now I want to break it all down for the layman so that he doesn't get discouraged by all that syntax.

Assume You Have Two Functions, A and B

async function getData(){

let respObj=await fetch(URL)

let jsonData=await respObj.json()

console.log(jsonData)

}

getData()

function getData(){

fetch(URL)

.then((respObj)=>{respObj.json()})

.then((jsonData)=>{console.log(jsonData)})

}

getData()

The above are the same function written in different ways. What we have is an asynchronous function using the fetch method to get JSON data from an API endpoint. If there is one thing we know about the fetch API, it is that, it returns a promise and one thing about promises is that they cause expectations, which if not fulfilled come with disappointments.

A promise arrives as a response object, imagine the car you were promised for xmas.Only when and if you get your car can you be sure of driving it into the new year or if you'll be disappointed in whoever didn't fulfill their promise to you.

Now let us analyse the "then" keyword used in the "B" function above. According to the dictionary definition from Oxford languages,"then" could mean any of the following : after that, next, afterwards or therefore. Looking back at the above definition we can see that the word "then" is a reaction or consequence of an occurrence. Analysing the "A" function, the word "await" means to wait for, anticipate or expect.

Now Let Us Juxtapose A and B

1A. When using async await:

async function getData()

Makes a function return a promise.

1B. When using .then:

function getData ()

Now at this point in both functions, we are ready to use our fetch(URL) which brings our promise in the form of a response object. As we know gifts come in wrappers and ribbons,same way our response object with many properties is the API wrapper for jsonData.

2A. When using async await:

const respObj=await fetch(URL)

This means wait for the fetch to bring our promise which comes as a response object which we save in a variable respObj. Only with the response can we proceed to our next action.

2B. When using .then:

fetch(URL).then((respObj)=>respObj.json())

This means until our promise comes as a response object, then only can we do something with the json data.

Object has arrived in form of json data.lets log it on to view.

A. When using await:

let jsonData=await respObj.json()

Console.log(jsonData)

B. When using .then:

.then((jsonData)=>console.log(jsonData))

Subsequently we can include a try catch for errors in async await and a catch for errors in .then. As you know when promises are not fulfilled, you just might need someone to catch your broken heart.

So for the two functions re-written with space for disappointments.

function getData(){

fetch(URL)

.then((respObj)=>{respObj.json()})

.then((jsonData)=>{console.log(jsonData)})

//catch incase it's not fulfilled

.catch((error)=>{console.log(error)})

}

getData()

async function getData(){

try{

let respObj=await fetch(URL)

let jsonData=await respObj.json()

console.log(jsonData)

}

catch(error){

console.log(error)

}

}

getData()

DEV Community: Stephen Odogwu

Typer: Observations, Dos and Don'ts of the Python Command Line Application Builder

One Function Module and Extra Argument Error

typer.run() Too

Subcommands to The Rescue

Multiple Functions

Don't Use Snake Case Functions on the Command Line Unless....

Boolean Flags

But What If....??

CLI Arguments With Help

Conclusion

Mimicking a List of Dictionaries with a Linked List in Python

Thought Process and Visualization

Introduction

Creating Our Linked List

The Algorithm

Comparison with a List of Dictionaries

Technically Not Dictionaries

Conclusion

The Use of the ** Operator with Python and FastAPI Pydantic Classes

Prerequisites

Use with Python Functions

Use with Python Classes

Use with FastAPI Pydantic Classes

Pydantic's .dict() Method

Benefits of Use

Conclusion

Routing in Computer Networking

Prerequisites

What is Routing?

Router

Switch

Routing Table

Physical Components of Routers

Longest Prefix Match

IP Prefix

Prefix Length

Number of Possible Subnets Within a Network

Route via Longest Prefix Match

Conclusion

Network Performance

What is Network Performance?

Measures of Network Performance

Bandwidth

Throughput

Latency

Conclusion

How I Built Web App To Evaluate Polynomials Using Horner's Algorithm

Building The Frontend Logic

Conclusion

The JavaScript Slice Method

What Does The Word Slice Mean?

Slice In Programming

With Strings

Slice with Single Positive Index

Counting From 1

Slice with Two Positive Indexes

Counting From 0

Slice with Single Negative Index

Slice with Two Negative Indexes

counting from 0

Slice with a Combination of Positive and Negative Indexes.

Positive First, Negative Second

Negative First,Positive Second

With Arrays

The Splice Method

Differences Between Slice and Splice

References

Learn to Protect Passwords with Bcrypt Hash in a Few Minutes

Differences Between Encryption, Encoding and Hashing

Encryption

Encoding

Hashing

What is Bcrypt

How does Bcrypt Work?

Password Hashing in Node.js With Bcrypt

Example of Password Hashing With Bcrypt in Node.js

Takeaways

Optional Chaining in JavaScript(?.)

Use With Methods

`typer.run()` Too

Pydantic's `.dict()` Method