Forem: Chibuzor Ojukwu

Understanding Variables in Dart

Chibuzor Ojukwu — Mon, 26 May 2025 18:55:06 +0000

In this article, you are going to get a very simplified and clear knowledge of what a variable is in Dart programming language. I promise, you will love it.

What is a variable?

In its simplest form, a variable is a container that holds or stores a certain type of value. E.g string, integer, boolean etc.

It does not literally store a value, but stores a reference to that value.

String firstName = 'john';

From the above code snippet, the variable name called ‘firstName’ contains a reference to a String object that holds a value of ‘john’. In dart, everything is an object.

Dart can also infer the type of the value if the type isn’t specified. for example;

var firstName = 'john';

From the above snippet, dart is able to detect the variable type of the value as String even though not specified, this is called Type Inference. Dart can infer a variable type only if it is initialized.

If a variable object isn’t restricted to a single type, you can specify the type as Object or dynamic if necessary.

Object firstName = 'john';
dynamic age = 23;

Null Safety

Since Dart 2.12, null safety was introduced to help prevent an error that results from unknowingly accessing variables set to null. The error is known as null dereference error. It occurs when you access the property or call a method on an expression that evaluates to null.

You can control whether a variable should be nullable by adding ‘?’ to the end of its type declaration.

String? firstName; // This can either be null or of type String
String firstName; // Non-nullable, cannot be null but can be of type String

Null safety flags a non-null variable;

when it has not been initialized with a non-null value
when it is assigned a null value

A nullable variable has an initial value of null by default, but for a non-nullable variable, you will need to assign it a non-null value.

Note: You don’t need to initialize a local variable even if it’s non-null, but you need to assign it a value before it is used.

Late Variables

If you are sure a variable will be initialized after its declaration and before usage, you can add the late modifier before the type declaration.

late String name;

void main(){
  name = 'Chibuzor';
  print(name);
}

From the above code, since the initState() method is the first method that runs when a widget starts, it is advisable to do all initial configurations needed by the widget. It is the best place to initialize the late variable before it is used.

Final and Const

Declare a variable either ‘final’ or ‘const’ if you don’t intend for it to change. Final should be used when you are not sure of what the value will be at the start of your application. For example, when you want set a class constructor’s properties, setting them as final is suitable because you don’t know the exact value that will be received when the code is ran.

class User{
  final String name;

  User({required this.name});

  void setName(){
   print(name); 
   name = 'Kennedy'; // error: final variable can only be set once
  }
}

Const should be used when the value of the variable is constant, meaning the exact value is known and will not change at anytime within the program. Const variable cannot be assigned a value after initialization.

const String name = 'Chibuzor'; 

name = 'Kennedy'; // error: constant variables can't be assigned a value after initialization

The value of a ‘final’ variable is known at runtime while that of a ‘const’ at compile time.

If you intend for a variable to change, you can use the ‘var’ keyword before the variable name. Note, you can’t specify ‘var’ alongside a type.

var String name = 'Chibuzor'; // This won't work
var name = 'Chibuzor'; // This will work
name = 'Kennedy'; // This will work

Kindly note — for a data type like List, if marked as final, it can be modified but not reassigned. But if marked as const, it can neither be modified nor reassigned.

final myList = [2, 4];
myList.add(6); // This will work
myList = [1, 7, 8]; // This won't work

const myList = [2, 4];
myList.add(6); // This won't work
myList = [1, 7, 8]; // This won't work

Conclusion

Variable is a core component of a program. Understanding its dynamics is very important. I hope I’ve been able to demystify any conundrum hinged on the subject of variables.

Happy Coding </>

The Concept of Expansion in the Linux Command Line

Chibuzor Ojukwu — Fri, 19 Apr 2024 20:48:44 +0000

In this short article, we will be exploring an important concept in linux shell called expansion.

When you type a command and press the Enter key, bash performs several processes upon the argument text before it executes the command. This process is called “expansion”.

Let’s see the different types of expansion within the shell.

1) Pathname expansion: The shell first expands the path (current directory) to get all the files that end with .js (see image below) after which the ls command is performed on the result.

2) Tilde expansion: From the example below, the shell expands the tilde (~) sign to get the home directory of the user before executing the echo command on its result.

3) Arithmetic expansion: From the screenshot below, the shell performs the computation (expansion) before the echo command is executed on its result.

4) Brace expansion: This is the most fascinating expansion. It simplifies complex tasks with just a single command. After expansion, dir-{1..5} becomes dir-1 dir-2 dir-3 dir-4 dir-5, before the mkdir is performed on them, creating 5 directories.

5) Parameter expansion: This is more useful in shell scripts than directly on the command line. It is also known as variables. From the image below, the shell expands $USER to get its value and passes it to the echo command. Use the printenv command to see all variables.

6) Command substitution: This allows you to use the output of a regular shell command as an expansion. See example below

Lastly for this session, we will discuss a concept called “quoting” used to control expansion performed in shell. It is used to suppress unwanted expansions. There are 2 types of quoting, double and single quotes.

Double quotes: This will suppress any kind of special characters usually meant for expansion and treat them as ordinary characters except for $ (dollar), \ (backslash), and ` (back tick) signs.

Single quotes: With this, you can suppress all expansions.

I hope you learnt about a few of the superpowers that the Linux Shell embodies.

Thanks for your time. Your feedback will be much appreciated.

Concept of Virtualization

Chibuzor Ojukwu — Thu, 11 Apr 2024 16:45:13 +0000

What is Virtualization?

Virtualization is a technology you can use to create a virtual representation of servers, networks, storage and other physical machines.

It uses a software known as hypervisor to mimic the functions of physical hardware to run multiple virtual machines concomitantly on a single physical machine.

Businesses take advantage of virtualization to use their hardware resources efficiently and to get greater returns from their investments. It also powers cloud computing services that helps organizations manage their infrastructures more efficiently.

Why is virtualization important?

It gives you the ability to interact with hardware resources with greater flexibility
Physical servers consume electricity, take up storage space, and need maintenance. Virtualization eliminates the aforementioned challenges by abstracting the physical systems into a software
If you want to access physical systems, you are often limited by proximity and network design. With Virtualization, you can access your servers from anywhere using your host machine. You can manage, maintain, and use your hardware infrastructure like an app on the web.

Virtual Machines and Hypervisors are 2 important concepts in Virtualization.

Virtual Machine aka VM: A virtual machine is a software-defined computer that runs on a physical computer with a separate operating system and computing resources. In virtualization, the physical machine is known as the host machine, while the virtual machines are called the guest machines. You can run multiple VMs on a single physical machine. Virtual machines are abstracted from the computer hardware by a hypervisor.

Hypervisor: A hypervisor is software application for managing multiple VMs. It ensures that each VM gets its allocated resources and does not interfere with the operations of the other VMs. It is the software layer that acts as an intermediary between the VMs and the underlying hardware or the host operating system.

There are two types of hypervisors:

Type 1 hypervisor: This is also known as bare-metal hypervisor. It is a hypervisor program installed directly on the computer's hardware instead of the operating system. It is said to have better performance and commonly used by enterprise applications. KVM uses the type 1 hypervisor to host multiple VMs on the Linux operating system.
Type 2 hypervisor: It is also known as hosted hypervisor. This is installed on the operating system. It is suitable for end-user computing.

Benefits of Virtualization

Automated IT Management - Since the physical machines are now virtual, you can configure and manage them using software tools.
Efficient Resource Use - Instead of having one server on a computer system, you can create a virtual server pool on that computer system by using and returning servers to the pool as required.
Faster Disaster Recovery - When the physical server is affected by natural disaster or cyberattacks, regaining access to IT infrastructure and replacing or fixing the physical server can take a long time. But with virtualization, this process takes few minutes which improves efficiency and facilitates business continuity so that operations can continue as scheduled.

Types of Virtualization

Server Virtualization - This is the process of partitioning a physical server into multiple virtual servers. It is efficient and cost-effective.
Storage Virtualization - This consolidates all your physical data storage into a single large unit of virtual storage that you can assign and control using management software tools. IT admins can now decide on how to streamline the storage activities, such as archiving, backup and recovery, because they have the liberty to consolidate multiple network storage devices virtually into a single storage device.
Network Virtualization - Any computer network has hardware elements such as switches, routers, and firewalls. An organization that has offices in multiple geographic locations can have several different network technologies that makes up its enterprise network. Network virtualization is the process of consolidating all these network resources to centralize administrative tasks. Admins can adjust and control these elements virtually without touching the physical devices, which greatly simplifies network management. There are 2 approaches to network virtualization; they are Software-defined networking and Network function virtualization.
Data Virtualization - Modern organizations collect data from several sources and store them in different formats. They might also store data in different places such as a cloud infrastructure or an on-premise data center. Data virtualization provides a software later between this data and the applications that needs it. Data virtualization tools processes an application data request and returns results in a suitable format.
Application Virtualization - This type of virtualization pulls out the functions of applications to run on operating systems other than the operating systems for which they were designed. For example, you can run a Microsoft window application on a Linux machine without changing the machine configuration. This is the technology behind containerization.
Desktop Virtualization - You run different desktop operating systems using this type of virtualization. E.g you could have windows 10 for your customer service team, and window vista for your sales team. There are 2 type of desktop virtualization; they are Virtual Desktop Infrastructure and Local Desktop Virtualization.

This is just a succinct explanation of what virtualization is all about.
I hope you learnt a thing or two.

Linked List Data Structure Simplified

Chibuzor Ojukwu — Tue, 18 Jul 2023 03:02:11 +0000

Many developers run away from data structures and algorithms because of how difficult it is perceived to be. In this article, I will try my best to make you understand one of the data structures called Linked List.

Linked List is a non-contiguous data structure, and a collection of nodes in which each node consists of a data and a reference or pointer to the next node. The first node is called Head while the last node is called Tail with its next node pointing to None.

There are not too many places where you can utilize a linked list, but as a good developer, it is important to get a good grasp of it to enable you understand how data structures are created along with the different operations that are performed on them.

In this article, we will be using the python programming language to create a Linked List with various operations that can be performed on it such as reading, modification, and deletion.

You need to create a Node class with a data and next_node properties.

# A Node class.
class Node:
    data = None
    next_node = None

    # Initializes this class with a data argument whenever an object is created
    def __init__(self, data):
        self.data = data

    # Provides a more readable string representation of the class object
    def __repr__(self):
        return "<Node Data: %s>" %self.data

The init method is python's built-in method called anytime an instance of the Node class is created.
The repr method is a python built-in method that gives the liberty to produce a more readable representation of the Node class. You can test your code using the python interpreter.
To access the interpreter, you need to have python installed on your PC. You download it from here
Open your terminal, and type in the below code and click enter.

python -i <the name of your file>

Make sure you are on the directory where your code file is located.
The interpreter will open, and you can go ahead to test your code, like the example below.

$ python -i linked_list.py 
>>> N1 = Node(20)
>>> N1
<Node Data: 20>
>>>

Create a LinkedList class and set head to None

# A Linked list class 
class LinkedList:
    # Initializes class whenever an instance is created
    def __init__(self):
        self.head = None

We will start creating the different operations that can be carried out on a Linked List. After the init method, let's start by creating an add method that will add a node to the beginning of the List.

    # Adds a node to the start of a list
    def add(self, data):
        new = Node(data)
        new.next_node = self.head
        self.head = new


    # Adds a node to the end of a list and returns its new size
    def addToEnd(self, data):
        current = self.head
        new = Node(data)
        count = 0
        added = False
        if current is None:
            self.head = new
        else:
            while current and not added:
                count += 1
                if current.next_node is None:
                    current.next_node = new
                    added = True
                else:
                    current = current.next_node
        return count + 1

implementation on python's interpreter

$ python -i linked_list.py
>>> l = LinkedList()
>>> l.add(2)
>>> l.add(5)
>>> l.add(3)
>>> l
[HEAD: 3]-->[5]-->[TAIL: 2]
>>>

From the above example, you will notice a chain-like representation of the class instance. Like the Node class, it is created using the python's built-in repr method. see code below

    # Provides a more readable string representation of the class instance
    def __repr__(self):
        nodes = []
        current = self.head

        while current:
            if current is self.head:
                nodes.append("[HEAD: %s]" %current.data)
            elif current.next_node is None:
                nodes.append("[TAIL: %s]" %current.data)
            else:
                nodes.append("[%s]" %current.data)
            current = current.next_node
        return "-->".join(nodes)

Next, is an insert method which creates and inserts a node at a specified index argument.

    # Adds a node at a specified index in the list.
    def insert(self, data, index):
        current = self.head

        if index == 0:
            self.add(data)
        else:
            new = Node(data)
            while index > 1:
                index -= 1
                current = current.next_node
            prev = current
            next_node = current.next_node
            prev.next_node = new
            new.next_node = next_node

Testing with interpreter.

$ python -i linked_list.py
>>> l = LinkedList()
>>> l.add(2) 
>>> l.add(5)
>>> l.add(12)
>>> l.add(6)
>>> l
[HEAD: 6]-->[12]-->[5]-->[TAIL: 2]
>>> l.insert(88, 1)
>>> l
[HEAD: 6]-->[88]-->[12]-->[5]-->[TAIL: 2]
>>>

Now, let's add a method that will return the length of the list

# Counts and returns the total number of nodes in a list by traversing through it 
    def size(self):
        count = 0
        current = self.head

        while current:
            count += 1
            current = current.next_node

        return count

You can test it using the interpreter following the way we did earlier.
Next, let's add a method that deletes a node from the list

    # Traverses through the list and removes the first node which data corresponds to a given or specified argument.
    # It returns the removed node.
    def remove(self, key):
        current = self.head
        prev = None
        found = False

        while current and not found:
            if current.data == key and current is self.head:
                found =True
                self.head = current.next_node
            elif current.data == key:
                found = True
                prev.next_node = current.next_node
            else:
                prev = current
                current = current.next_node
        return current

    # Removes a node at a specified index from the list. It returns the removed node.
    def removeAtIndex(self, index):
        current = self.head
        prev = None

        if index == 0:
            self.head = current.next_node
        else:
            while index > 0:
                index -= 1
                prev = current
                current = current.next_node
            prev.next_node = current.next_node
        return current

Go back, study and practice the code as many times as you can so as to enable you get a good grasp of Linked List and its common operations.

Congratulations for adding the knowledge of Linked List to your skillset.

Happy coding...

React useEffect hook

Chibuzor Ojukwu — Sun, 08 Jan 2023 15:27:55 +0000

React is a Javascript library for building user interfaces. It is the most popular Javascript library. This is not an article for learning react from scratch. If you intend to start from scratch, I recommend this youtube video. We will be discussing of one of the React hooks -> useEffect. In version 16.8 of React, hooks were added to react.

What to learn

What are react hooks?
Importance of react hook
Rules of hooks
Some other popular hooks
The Role of the useEffect hook
Conclusion

→ What are React hooks?

React hooks are functions that provides function components with access to states and other React features. They don’t work inside classes. Before the advent of React hooks, states can only be managed within class components and with some external libraries. But, since react hooks was introduced, class components have almost become unnecessary.

→ Importance of React hooks

Hooks allows you to reuse stateful logic without changing your component hierarchy. This means that with hooks you can remove stateful logic from a component so that it can be reused. This makes sharing Hooks among components easy.
Hooks makes our code organised, neat, readable and maintainable even when it scales. With the class component lifecycle, complex components become hard to understand. For example, the componentDidMount method mostly have a mix of unrelated logic, some data fetching might be performed in it and also in componentDidUpdate. Also, componentDidMount _method may contain mix of unrelated logic that sets up event listeners with clean up done in _componentWillUnmount method, having related code that changes together being split apart but completely unrelated code being put together in a single method. This can easily introduce bugs and inconsistencies.
Hooks makes testing stateful logic easy.
Hooks let you use more of React features without classes

→ Rules of hooks

Only call hooks at the top level of your code. Don’t call hooks inside a loop, conditional, or nested function.
Only call hooks from a React function component. Don’t call hooks inside a regular javascript function. You can call hooks in your custom hooks.

→ Some other popular hooks

There are quite a number of React hooks, but I will do my best to list the most commonly used ones. We won’t be discussing them in-depth because this article is about the useEffect hook.

useState→ It is used for managing states in a function component and to preserve it between renders. It returns a pair; the current state value and a function that updates it.
useEffect→ This is used for handling side effects (eg. Data fetching, event handling, changing DOM manually from React components etc) in function components. It serves the same purpose as componentDidMount, componentDidUpdate, and componentWillUnmount in React classes combined together.
useReducer → Just like the _useState _hook, this is used for managing state but for more complex ones. It takes in a reducer function as its first parameter and an initial state value as its second parameter. It returns an array that holds its current state and a dispatch function to which you can pass an action and later invoke it.
useRef → This allows to directly create a reference to the DOM element in a functional component. It return a mutable ref object with a property of .current. It persists state between renders without causing a re-render.
useContext → To return the current value for a context
useCallback → It return a memorized version of a callback to prevent an unnecessary re-render of a child component.

→ The Role of the useEffect hook

Now, let’s have an in-depth understanding of the useEffect hook.

It provides the ability to perform side effects in function components. Side effects are anything that affect something outside the scope of the function being executed. for example, making an API call, subscribing to a listener, manually changing DOM from a function component, timers etc.

In a class component, side effects are handled inside of it lifecycle methods such as componentDidMount, componentDidUpdate, and componentWillUnmount. For instance, if you decide to set up a subscription, you will do that in componentDidMount method and cancel it in componentWillUnmount method. On the other hand, the useEffect hook can handle both setting up of the subscription, its update, and its cancellation.

Effects are declared inside the component, so they have access to its props and state. By default, React runs the effect after every render.

Let’s look at a use case

import React, {useState, useEffect} from "react"

const FriendStatusWithCounter = (props) => {
  const [count, setCount] = useState(0);
  useEffect(() => {
    document.title = `You clicked ${count} times`;
  }, [count]);

  const [isOnline, setIsOnline] = useState(null);
  useEffect(() => {
    ChatAPI.subscribeToFriendStatus(props.friend.id, handleStatusChange);
    return () => {
      ChatAPI.unsubscribeFromFriendStatus(props.friend.id, handleStatusChange);
    };
  }, []);

  const handleStatusChange = (status) => {
    setIsOnline(status.isOnline);
  }

    return (
        <button onClick={() => setCount(prevCount => prevCount + 1)}>Click</button>
    )
}

From the above sample code, we have a FriendStatusWithCounter component with a count state initialized to 0, it is for keeping track of how many times we click the button. Noticed we introduced another hook called useState which I have briefly explained.

As you can see, we are accessing the document’s title which is outside the component to be executed, that’s why we are using the useEffect hook. For the second useEffect hook, we set up the chatApi subscription inside the hook’s function body (in componentDidMount method for a class component) and then cancel subscription inside the body of its return function (in componentWillUnmount method for a class component). The second parameter of the useEffect hook is an array that will contain the dependencies (e.g the count state) that should trigger the useEffect _any time it changes (in _componentDidUpdate method for a class component).
So, in summary;

useEffect(() => {
//componentDIdMount 
//componentDidUpdate
return () => {
                //componentWillUnmount
            }
}, [//dependencies)

→ Conclusion

We have come to the end of this article. We were able to understand the basics of hooks and what you need to know about the _useEffect _hook. I hope you find this article helpful.

🙂 Happy coding </>