DEV Community: Valentine Samuel

Bubble Sort Simplified

Valentine Samuel — Fri, 31 Mar 2023 11:01:15 +0000

In computer science, sorting is a fundamental job that is essential to many different applications, including database administration and image processing. Sorting is the act of arranging a collection of objects in a certain order, such as alphabetical or numerical order, so that they may be conveniently searched or processed.

There are several methods for sorting data, each with its own set of advantages and disadvantages. Bubble sort is one of the most basic and well-known sorting algorithms. Bubble sort is a simple algorithm that beginners may readily understand and is frequently used as an introduction to sorting algorithms.

In this article, we'll look into bubble sort in further detail, including how it works, its advantages and disadvantages, as well as practice guidelines for using and improving it. Understanding bubble sort is a vital step in mastering sorting algorithms and increasing your coding abilities, whether you're a new programmer or an expert developer. Now let's get started and discover the world of bubble sorting!

How Bubble Sort Works

Bubble sort is a basic comparison-based sorting algorithm that operates by repeatedly exchanging nearby components that are in the wrong order. Larger items "bubble" to the top of the list with each run, giving rise to the algorithm's name. Below is a step-by-step walkthrough of bubble sort implementation.
Below are the steps to follow:

Use two for loops to iterate through the input array.
The outer loop runs from i = 0 to i = n - 1.
The inner loop runs from j = 0 to j = n - i - 1;
For every j, compare arr[j] and arr[j + 1]. If arr[j] > arr[j + 1], then swap them or else move forward.

Python Implementation

1. def bubbleSort(arr):
2.     for i in range(len(arr)):
3.         for j in range(len(arr)-i-1):
4.             if arr[j] > arr[j+1]:
5.                arr[j], arr[j+1] = arr[j+1], arr[j]
6.    return arr
7. 
8. bubbleSort([13, 4, 9, 5, 3, 16, 12]) # [3, 4, 5, 9, 12, 13, 16]

In the implementation above, we traverse through the array on different passes. On each pass, we compare the current element and the one immediately after it. If the current element is bigger than the one on the right, we swap them(line 5).

Time Complexity

Best - O(n)
Worst - O(n2)
Average - O(n2)
Space Complexity - O(1)
Stability - Yes

Pros and Cons of Bubble Sort

Pros:

Simple: Bubble sort is one of the simplest sorting algorithms to understand and implement.
In-place sorting: Bubble sort only requires a constant amount of additional memory space to sort a list, making it an "in-place" sorting algorithm.
Stable: Bubble sort is a "stable" sorting algorithm, meaning that it preserves the relative order of equal elements in the list.

Cons:

Inefficient for large lists: Bubble sort has a time complexity of O(n²), meaning that its performance becomes increasingly slow as the size of the list grows. For very large lists, bubble sort can become impractical.
Inefficient for partially sorted lists: Bubble sort still needs to compare every element to every other element, even if the list is already partially sorted. This can lead to unnecessary comparisons and swaps.
Not the most efficient sorting algorithm: There are other sorting algorithms, such as quicksort and mergesort, that have better time complexity than bubble sort and can be more efficient for large lists.

Conclusion

Bubble sort is a simple, easy-to-understand sorting algorithm that can be useful for small lists or as a learning exercise for understanding sorting algorithms. However, it is not the most efficient sorting algorithm for large lists or partially sorted lists. For those cases, it may be more efficient to use a different sorting algorithm that has better time complexity.

Don't forget to leave a like or comment.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

Scaling In System Design

Valentine Samuel — Thu, 30 Mar 2023 15:33:07 +0000

As a follow-up to our last post, we are going to be looking at a system design concept called scaling.

Introduction

Imagine that we are organizing a school event like a graduation ceremony and we need to provide seating for all the students, parents and dignitaries. When we started planning the event, we estimated that we will need a certain number of chairs and tables to accommodate everybody. However, as the data of the event draws closer, more and more dignitaries, parents and even ex-students have RSVP'd for the graduation ceremony and it becomes apparent that we would need to increase the number of chairs and tables. We have just succeeded in scaling because we are adding more resources(tables) and chairs to handle the increased seating demand. However, there are two main types of scaling that we will be looking at in this article - vertical and horizontal scaling.

Scaling

The scalability of a system refers to the ability of a system to increase or decrease its computing power depending on the situation. Scalability is important to provide accessibility, availability, reliability, great user experience, power, presence etc. There are two types of scaling- vertical and horizontal scaling.
Vertical Scaling
By adding more resources, like memory, CPU, or disc space, a single node or instance's capacity can be increased. Although this strategy has several drawbacks, it may be utilized to enhance a single node's performance. As the demand for a system continues to grow, it will ultimately reach a point where adding more resources to a single node is no longer practical, and horizontal scaling will be required.

Horizontal Scaling

This entails adding more resources to the system, such as nodes or instances(physical servers), to disperse the load and boost the system's total capacity. A cluster of servers or a cloud-based system's instances may often be expanded to do this. Horizontal scaling has the advantage of allowing the system to withstand substantial increases in demand without requiring significant modifications to the current infrastructure. And this works better than the vertical scaling approach when paired with a load balancer. However, it is important to note that both vertical and horizontal scaling can be combined to maximize performance.

Layers of Scaling

Scaling can occur in different layers of a system. These include

Application scaling
Database scaling
CDN scaling

Application Scaling:

Application scaling is the process of raising an application's capacity and performance in response to rising demand. Adding more computational resources, such as servers or containers, boosting network bandwidth, improving application design, and leveraging caching to increase speed are all examples of how this may be done. The program can handle additional requests by scaling up without getting too busy or going offline.

Database Scaling:

Database scaling involves increasing the capacity and performance of your database system to handle the demands of increasing data volumes or increasing workloads. It adds other database resources such as servers, storage, and memory, optimizes the database architecture, distributes data across multiple nodes and implements database caching to improve query performance. By scaling your database, you can handle more data and queries without being overloaded or experiencing performance issues.

CDN Scaling:

CDN scaling is expanding the capacity and performance of a content delivery network to improve content delivery to end consumers. This can be accomplished by deploying more network resources, such as edge servers or caching nodes, improving network design, establishing load balancing, and employing caching to minimize latency and enhance content delivery. The CDN can handle more requests and provide material faster by scaling it, especially during high usage periods or in geographically separated locations.

Choice of Scaling Technique

This is a subjective decision and there is no right way or wrong way, it depends on the scenario. However, we would go over generic factors:

Load Balancing: If you do not intend to add a load balancer, it could be better to scale vertically as there is not more than one server to spread the traffic across.
Point of Failure: In a situation where you are experiencing very high traffic requests, it could be more beneficial to scale horizontally so that the other server can pick up if one of the servers crashes for any reason.
Speed: The vertical scaling could result in faster operations since the server communicates within itself and does not need to reach out to another service or server
Data Consistency: It takes extra work to make sure that data is consistent among all servers at all times if you scale horizontally but in a vertical scaling technique, the data is consistent because there is only one instance of the server
Hardware: The vertical system poses a limitation where you cannot scale further than a particular stage because of limited space. For example, you might fill up all the RAM slots and not be able to add more. In this case, the alternative is to scale horizontally.

Conclusion

A good system must be reliable, and available and have high system throughput and low response time. These factors are some of the factors that influence the choice of scaling technique. However, it is important to also know the pros and cons of both scaling techniques as well as the current situation so that you do not end up wasting resources or putting excessive pressure on existing resources that might push them to a breaking point.

Don't forget to leave a like or comment.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

Introduction To System Design

Valentine Samuel — Wed, 29 Mar 2023 11:14:51 +0000

System design

System design is the process of creating components of a system, including its architecture, modules, and components, as well as its various interfaces and the data it processes. System design is the process of establishing a system's architecture, components, interfaces, and data to meet predetermined criteria. It is a multidisciplinary field that involves trade-off analysis, balancing competing needs, and making choices concerning design elements that will influence the system as a whole. In order words:

System Design === Architecture + Data + Components

Why is system design important

The goal of system design is to offer enough precise data and knowledge about the system and its system pieces to allow implementation compatible with architectural entities described in system architecture models and views. System designs have a few things in common:

Dependability: This refers to the level of reliability, robustness and impact rates of the smaller systems.
Availability: This refers to the amount of time in which a system can receive tasks, process tasks and output results without failure.
Scalability: This refers to the ability of the system to grow without causing technical debt.
Efficiency: This refers to the level of effectiveness, reusability and productivity of the systems.

Elements of a System

Architecture - This is the blueprint that shows the layout, and behavior of a system. This can be illustrated using flowcharts of other software like Excalidraw.
Modules - These are the smaller sub-systems or components that perform specific tasks.
Components - These can be referred to as clusters of modules that are linked to perform a group of functions.
Interfaces - These are the channels or pipelines which the components use to exchange information.
Data - This is the battery of a system. It is similar to the blood in the human body. It transforms as it moves from one component to another.

Important System Design Concepts

There are different concepts that we need to know to properly understand how to design systems and they include:

Load balancing
Latency
Sharding
APIs
Requirements Gathering
Security
Replication
Caching
Architecture
Estimation
Proxies
Databases
Servers

Conclusion

In this article, we have looked at what system design is all about, its importance and its elements. In the next post, we are going to dive deep into the concepts.

Don't forget to leave a like or comment. Till next time guys.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

Binary Search Tree - Insert, Lookup and Remove

Valentine Samuel — Mon, 13 Mar 2023 11:14:17 +0000

Binary search trees (BSTs) are a sort of data structure that is used to store and search for data effectively. A BST is a tree structure with no more than two children: a left child and a right child. The left child is always smaller than the parent node, whereas the right child is always greater than the parent node. The most significant feature of a BST is that it enables efficient searching. This is due to the BST's recursive nature, which enables binary search methods to be implemented. We shall look at the explanation of a BST and its insert, lookup and remove methods in Python

Basic Concepts

Binary Search Trees are made up of nodes and edges. The nodes are the various points in the memory that holds the data. In the diagram below, the colored circles are the nodes and the black lines connecting them are the edges.

Root Nodes

The root node of a BST is the first node. It is called root because all other nodes in the BST originate from this root node. In the example above, node 101 is the root node.

Leaf Nodes

In a BST, the leaf nodes are nodes that do not have either a left child or a right child. They are the last node in the tree and they are of great importance in a BST. From the example above, nodes 9, 37, 54 and node 144 are leaf nodes.

Parent Nodes

Parent nodes in a BST are nodes that have either a left child or right child or even both children. In the example above, node 33 is the parent node of nodes 9 and 7, and node 105 is the parent node of nodes 54 and 144. The root node is also a parent node and it is the parent node of nodes 33 and 105.

BST Methods

In a BST, there are three main methods which are insert, lookup and remove. These methods are used to insert, find and remove a node respectively. We will now look at how to implement these methods.

Node Class

Since a BST is made up of different nodes, we need to first define our node class

class Node:
    def __init__(self, value):
        self.left = None
        self.right = None
        self.value = value

    def __repr__(self):
        return str(self.__dict__)

In this code snippet above, the node has a left and right pointer as well as the value it will hold. It also has a 'repr' class that we are implementing to determine how we want to output our node. In this case, we are choosing it to be a python dictionary or an object.

Binary Search Tree Class

class BinarySearchTree():
    def __init__(self) -> None:
        self.root = None

    def __repr__(self) -> None:
        return str(self.__dict__)

Here we are just stating the constructor for the BST class and also implementing our choice of output. By default, the BST object we are creating is going to have a root node.

Insert Method

def insert(self, value):
        newNode = Node(value)
        if self.root == None:
            self.root = newNode
            return
        currentNode = self.root
        while True:
            if currentNode.value > newNode.value:
                if currentNode.left == None:
                    currentNode.left = newNode
                    return
                currentNode = currentNode.left
            if currentNode.value < newNode.value:
                if currentNode.right == None:
                    currentNode.right = newNode
                    return
                currentNode = currentNode.right

We first check if the tree is empty by evaluating the value of the root property. Since we do not know where we are going to end, if the currentnode's value is greater than the newnode's value, we also check if there is an already existing direct child node to the left of the currentnode. If there is no node, we insert the newnode there or we continue to traverse to the leftmost node of the currentnode. We also do the same thing for the right subtree of the node by checking if the currentnode's value is less than the newnode's value. Then we perform the same operation but this time, we will be traversing to the rightmost node.

Lookup Method

def lookup(self, value):
        if self.root == None:
            print("Empty Tree")
            return
        currentNode = self.root
        while currentNode:
            if currentNode.value > value:
                currentNode = currentNode.left
            elif currentNode.value < value:
                currentNode = currentNode.right
            elif currentNode.value == value:
                print("Found")
                return currentNode
        print("Not Found")
        return None

In this lookup method, we check if the tree is empty, else we continue to look for the node by comparing the value of the currentnode to the value we are looking for. If the currentnode is greater than the value we are looking for, then we going leftward and if the currentnode is smaller than the value, then we are going right.

Remove method

This is the trickiest and longest method, but we are going to discuss it together. When you want to delete a node from a BST. YOu would be faced with any of the following three scenarios:

If the node has no children - Just delete it.
If the node has a single child - Copy that child to the node.
If the node has two children - Determine the next highest element in the right subtree. Replace the node to be removed with the next highest node. Delete the next node. So we find the leftmost node of the right subtree of the current node. This leftmost node can be found by looping from the current node to the last node (until when there is no left node). This will reduce the problem to a scenario where the node has only one child or no child.

    def remove(self, value):
        if self.root == None:
            return "Empty List"
        currentNode = self.root
        parentNode = None
        while currentNode != None:
            if currentNode.value > value:
                parentNode = currentNode
                currentNode = currentNode.left
            elif currentNode.value < value:
                parentNode = currentNode
                currentNode = currentNode.right
            else: # A match has been found
                # Both left and right children
                if currentNode.left != None and currentNode.right != None:
                    badNode = currentNode.right
                    badNodeParent = currentNode.right
                    while badNode.left != None:
                        badNodeParent = badNode
                        badNode = badNode.left
                    currentNode.value = badNode.value
                    if badNode == badNodeParent:
                        currentNode.right = badNode.right
                    if badNode.right == None:
                        badNodeParent.left = None
                        return
                    else:
                        badNodeParent.left = badNode.right
                        return

                # No left or right children
                elif currentNode.left == None and currentNode.right == None:
                    if parentNode == None:
                        self.root = None
                        return
                    if parentNode.value > currentNode.value:
                        parentNode.left = None
                        return
                    else:
                        parentNode.right = None
                        return

                # Only left child
                elif currentNode.left != None and currentNode.right == None:
                    if parentNode == None:
                        self.root = None
                        return
                    if parentNode.value > currentNode.value:
                        parentNode.left = currentNode.left
                        return
                    else:
                        parentNode.right = currentNode.left
                        return

                # Only right child
                elif currentNode.left == None and currentNode.right != None:
                    if parentNode == None:
                        self.root = None
                    if parentNode.value > currentNode.value:
                        parentNode.left = currentNode.right
                        return
                    else:
                        parentNode.right = currentNode.right
                        return

The Time Complexity of BST operations is O(h). h is the height of the tree.

The source code for this tutorial can be found at https://github.com/valentinesamuel/EssentialOrigin/blob/main/test_ds/binary_search_tree.py

Conclusion

It is crucial to note, however, that the effectiveness of a BST is dependent on the structure of the tree. The efficiency of operations can be dramatically lowered if the tree is imbalanced (i.e., one subtree is significantly bigger than the other). There are numerous approaches for balancing BSTs, such as AVL trees and red-black trees, to address this issue. These strategies will be detailed in a subsequent post.

Don't forget to leave a like or comment. Till next time guys.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

A Quick Introduction To Types In TypeScript

Valentine Samuel — Sat, 11 Mar 2023 14:36:47 +0000

Typescript is a superset of JavaScript that provides more robust features and error checking at compile time. One of the primary features of Typescript is its strong typing system, which provides support for various types. Understanding the types available in Typescript is essential for any developer to write clean, reliable, and bug-free code. In this article, we will explore all the types in Typescript and categorize them into basic types and advanced types.

Basic Types:

Number: The Number type represents both integer and floating-point numbers. It supports all standard mathematical operations, such as addition, subtraction, multiplication, and division. Here is an example.

let num: number = 5;
console.log(num); // Output: 5

String: The String type represents a sequence of characters. It is enclosed in quotes, either single or double. Here is an example:

let str: string = 'Hello, World!';
console.log(str); // Output: Hello, World!

Boolean: The Boolean type represents a logical value, either true or false. Here is an example:

let isTrue: boolean = true;
console.log(isTrue); // Output: true

Null: The Null type represents an intentional absence of any object value. Here is an example:

let nullValue: null = null;
console.log(nullValue); // Output: null

Undefined: The Undefined type represents a variable that has been declared but has not been assigned a value. Here is an example:

let undefinedValue: undefined = undefined;
console.log(undefinedValue); // Output: undefined

Advanced Types:

These are types that are made up of one or more basic types.

Array: The Array type represents a collection of elements of the same type or different types, it is recommended to make arrays hold only a collection of one particular type. It can be declared using square brackets. Here is an example:

let arr: number[] = [1, 2, 3, 4, 5];
console.log(arr); // Output: [1, 2, 3, 4, 5]

Tuple: The Tuple type represents an array with a fixed number of elements, each with its type. For tuples, the order of appearance must match. A number cannot come in the position of a string. Here is an example:

let tuple1: [string, number] = ['John', 25];
// let tuple1: [string, number] = [25, 'John'];❌
console.log(tuple1); // Output: ['John', 25]

Enum: The Enum type is a way of giving more friendly names to sets of numeric values. Here is an example:

enum Color {Red, Green, Blue};
let c: Color = Color.Green;
console.log(c); // Output: 1

Any: The Any type represents any value, and it can be assigned to any variable without a type check. Any type is equivalent to writing plain javascript and its usage is very much discouraged. Here is an example:

let anyValue: any = 'Hello, World!';
console.log(anyValue); // Output: Hello, World!

Void: The Void type represents the absence of any type at all. It is commonly used as the return type of function that does not return a value. Here is an example:

function logMessage(): void {
  console.log('Hello, World!');
}
logMessage(); // Output: Hello, World!

In conclusion, Typescript provides a rich set of types that enable developers to write more reliable code. Basic types are the fundamental types that are commonly used in everyday programming, while advanced types are more specialized and provide more functionality. As a beginner, understanding these types is essential to mastering Typescript and writing better code.

Don't forget to leave a like or comment. Till next time guys.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

Networking: Definition, Importance and Types

Valentine Samuel — Thu, 09 Mar 2023 08:27:55 +0000

Why networking? - because sometimes it's not about who you know, but about what your device knows!

In all seriousness though, understanding networking's definition, significance, and forms are essential because it plays an essential role in our daily lives. Networking has advanced significantly since its early days of connecting computers in a small workplace to the current level of global interconnection. Don't worry, I won't bore you with a detailed explanation. Instead, let me give you a brief overview of networking.

What are Networks?

A network's definition might be somewhat broad. At its most basic, networking always includes two or more computers being physically connected through wires or via a Wi-Fi connection. By linking, these machines may share their resources, data, or internet connection without having to connect each time. On a bigger scale, networks may become considerably more complicated. A network in a family house, for example, may consist of two home PCs and a Wi-Fi connection (which the family uses for various additional devices such as a smart TV, smartphones, etc.). In an office building, there may be a large network that consists of thousands of computers that are physically connected through ethernet connections.

Types of Networks

Local Area Networks (LAN) and Wide Area Networks (WAN) are the most common types of networks. Metropolitan Area Networks (MAN) and Wireless LAN (WLAN) are the other two basic types of networks, with Wireless WAN (WWAN) being an extension of a similar idea. Here's a brief breakdown of each of the four main types of networks.

Local Area Network: Typically the most common type of network you'll encounter, a Local Area Network, involves connecting computers in a relatively small area. That area can be your home, office, or school, amongst other locations. The devices can connect either via an Ethernet cable or through Wi-Fi.
Wide Area Network: This type of network spans a large geographic area such as a city, state, or country. The internet itself is considered the largest Wide Area Network globally, with Wide Area Networks making it possible for smaller Local Area Networks to connect to it. Businesses may also have a Wide Area Network to link their many offices together.
Metropolitan Area Network: A Metropolitan Area Network is bigger than a LAN but smaller than a WAN. Large corporations or government bodies use it to link together different resources across a business.
Wireless LAN: A wireless LAN works much like a Local Area Network, but it does so through wireless connections such as Wi-Fi or Bluetooth rather than using Ethernet cables.

Do I even need a network?

Most likely, the only network you'll come across consciously daily is a home network, sometimes known as a Local Area Network (LAN). A home network is not required for everyone. There is no need for a network if you only have one computer and no additional devices to connect to the internet or share resources with.

Yet, most individuals now have their own LAN configuration at home, which is connected to various devices. It's critical to comprehend how to set up a home network and to decide whether wired, wireless, or a combination of both is appropriate for your household.

Importance of Networks

Let's face it: networks are all around us. Networks have become a crucial aspect of our everyday lives, from the internet that links us internationally to the Wi-Fi in your local coffee shop. But why are networks so important? Let's break it down:

Connectivity: Networks allow us to connect with people and devices worldwide, breaking down geographical barriers and creating a more connected world. So, whether you're video chatting with your friend in another country or accessing your company's server from home, networks make it all possible.
Efficiency: Networks help us work smarter, not harder. By sharing resources like printers and storage devices, we can collaborate more efficiently and get more done in less time. Plus, cloud-based services mean we can access our files from anywhere, making remote work more accessible than ever.
Innovation: Networks are at the forefront of innovation. From 5G to the Internet of Things (IoT), new technologies are constantly emerging, driving the development of new products and services that enhance our lives.

Networks keep us connected, efficient, and innovative. And let's not forget the most crucial aspect - networks provide us with endless opportunities to share memes and funny videos. Who doesn't love that?

Don't forget to leave a like or comment. Till next time guys.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

Fears of an Unemployed Software Engineer and Fresh Graduate 😔

Valentine Samuel — Wed, 08 Mar 2023 17:01:46 +0000

“Do the thing you fear to do and keep on doing it… that is the quickest and surest way ever yet discovered to conquer fear.” — Dale Carnegie

If anyone finds this article and they are having the same thoughts as me, maybe they could learn something new or possibly contribute to others to learn.

So,

Honestly, I lack the right adjectives to describe my feelings but I'm 100% sure that I have a lot on my mind... A lot of what ifs😔.

Around October 2016, I gained admission into the university to study urban and regional planning. I was very happy because I loved designing real estate structures like houses, layouts, cities, etc. It was a five-year course but I ended up doing it for almost 7 years because of the broken educational system😭. In 2017, which was my second year, I started gaining a lot of interest in programming but I didn't have anybody to hold my hand and teach me the basics, so it was a very tough path for me because I had to figure everything out myself.

I got started with HTML and CSS but after some weeks, I got demotivated and abandoned web development (because of CSS🤭). I tried to see if there are other areas I would like, then I found data science. It wasn't long before I dropped it due to all the mathematics and statistics that scared me (I never used to like calculations😂). I knew there had to be something in tech that suits me so I tried Native android development with Java. After some weeks, I also abandoned it because learning Java felt like a suicide mission, it felt like my brain was twisted in endless braids. I had more headaches than Java knowledge and Android studio gave me a very tough time during installation because I always tried to install it offline like a normal application software(such a noob😂). This period of picking and dropping technologies lasted for nearly 2 years and I didn't have so much time to practice them because of how time-consuming my university coursework was.

Well, I decided it was time to try something else. So I decided to completely abandon software programming and go for hardware programming. I loved Arduino because I could work on projects that I could touch and I also loved the fact that I was going to learn new stuff about electricity and some physics. (I never understood anything in science class back in secondary school 😂), but because I couldn't afford the Arduino kit at that time, I had to look into something else. At this point, I lost hope that I would ever do any programming in my life so I just abandoned programming and stuck with doing architectural and planning drawings.

Fast forward to February 2020, the COVID-19 outbreak hit Nigeria and the whole country was on lockdown so schools were closed. I thought this was a great time to try out this programming venture again(no pain, no gain was my slogan😂). After all the trial and error, I felt like it was time to focus on one thing. After assessing myself, I realized that I have not learned anything at all as a result of jumping from one area to another. I decided to stick with HTML and CSS again, this time I was ready to battle it out because I had a lot of spare time after doing my house chores. Finally, I was getting a hang of it and everything started making sense.

From May 2020, I was practicing and honing my skills from morning till night, Monday to Sunday and I was also passionate about mobile app development so I was learning the flutter framework on the side. I built a couple of projects but it later became difficult because the flutter course I was following suddenly became too fast-paced for me to understand anything. So that was the end of my flutter journey.

I got discouraged and thought I was too dumb to understand programming so I bailed out on it again (for the umpteenth time🤦🏾‍♂️). But I was having quite an unsettling feeling that I couldn't program. In August 2020, I continued from where I stopped and learned JavaScript then I proceeded to learn git and GitHub. Gradually, the little efforts I made during those sleepless nights began to add up and that's how I became comfortable writing HTML, CSS, JavaScript and using Git. In December 2020, I began learning Angular and it wasn't as difficult as people said. I knew it couldn't be so difficult because other people had learned it too. In February 2021, I went back to the university and I could say I was a Junior frontend developer. That is why 2020, which was a year of chaos for some people, was the best year of my life.

So, from 2020 till date, I have been building a lot of projects and I learned other tools and technologies like React.js, Nodejs, Mongodb, Typescript, Python, Linux operating systems and a lot of stuff. I even picked up technical writing and I feel it's a great way to express myself. I have tried applying for Jobs but I haven't been lucky enough to get one so I started freelancing by building web applications for small businesses.

Why the fear?

Now, it's February 2023, I just graduated from the university. I know what I want, I have a plan and several backup plans for this stage of my life. I am a bit prepared because I knew it was inevitable but I am a bit scared. To be honest, I am very scared. Because:

what if I don't get a software engineering role that I have always worked for?
what if it takes too long to get a software engineering role?
when will I get it?
am I not good enough to get it?
is there something wrong that I don't know about?
am I missing any important skill even for a front-end developer or full-stack software engineer?

These are the questions I keep asking myself. But I know that one day, I'll get a good software engineering position. I have now gone fullstack in a bid to learn more, build more projects and also be open to a wider range of opportunities. As my dad always tells me:

"Because you didn't get this opportunity doesn't mean a bigger one is not waiting for you."

For me, this quote means a lot to me because I have been looking for a frontend developer job for 2 years but I have not been able to get into any. Moving forward, I'm improving my skills in problem solving, Nodejs, Mongodb, Next.js, Data Structures and Algorithms (that's my current weakness😭), Typescript, SQL, testing, Cloud engineering, systems design(I really love it🥰), technical writing and other stuff. Maybe a senior software engineering position is waiting for me. Who knows?🤷🏾‍♂️. I would rather prepare my self for bigger opportunities than worry about not getting a smaller one because if the bigger one comes and I'm not prepared, it's going to be a problem. I think one of the key takeaways from this article is that "Going down is natural but staying down is a choice". I could have decided to forget about coding totally but the passion I had for it made me put in the extra effort. No matter how much life overwhelms you, you can still pick your self up and continue the journey.

Wow, my chest feels lighter just by sharing my thoughts here. It's 3:45am, I'm just lying on my bed as I clack away at keyboard. I don't even know if I should publish this article or not. I feel it's too personal and the article is quite disorganized but at the same time, I feel other people might be in a similar situation. I actually plan to write more often here on dev.to since I'm going to be doing a lot of learning..

Please, don't forget to leave a comment or like. Till next time guys.

❤️❤️❤️

Resume Portfolio Twitter GitHub LinkedIn

My Goals at Zuri Internship📌

Valentine Samuel — Sun, 15 Aug 2021 11:48:42 +0000

About Me😎

Hi, my name is Samuel Valentine, a frontend engineer with 2 years of experience. I am obsessed with developing and occasionally designing innovative products for the world wide web.

Zuri Internship😁

"Zuri to the world💪"..Zuri and Ingressive For Good is giving the opportunity to those with or without prior code and design experience, the platform to learn more and connect with like-minds. Find out more about them here .

Hey, Stick around to the end of this article to get quality and beginner friendly resources🤩.

Goals🎯

'Begin with the end in mind' - Stephen Covey.
At the end of this internship, i plan to achieve the following:

Connect with other developers and designers as well as DevOps engineers.
Improve my communication skills.
Improve my problem solving skills by helping others.

Useful Resources✍

I know how much i struggled to find quality resources when i started leaning how to code. Guess what?, you don't have to do that anymore.

Want to get started with web development?

Check out this video

Want to get started with mobile development?

Check out this video

Want to get started with design in Figma?

Check out this video

Want to get started with Version Control in Git?

Check out this video

This article is actually my first and i plan on dropping more web development content here regularly. So, make sure to drop your honest reviews so that i can write better content for you.