<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Emmanuel Paimo (Paims) on Medium]]></title>
        <description><![CDATA[Stories by Emmanuel Paimo (Paims) on Medium]]></description>
        <link>https://medium.com/@paimoemmanuel2016?source=rss-cd145caafde5------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*jl8Gyl-GKIKBXN2h.jpg</url>
            <title>Stories by Emmanuel Paimo (Paims) on Medium</title>
            <link>https://medium.com/@paimoemmanuel2016?source=rss-cd145caafde5------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 11:50:55 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@paimoemmanuel2016/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[Pivot. You can always pivot.]]></title>
            <link>https://medium.com/@paimoemmanuel2016/pivot-you-can-always-pivot-e8d09b1d17fd?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/e8d09b1d17fd</guid>
            <category><![CDATA[career-change]]></category>
            <category><![CDATA[reflections]]></category>
            <category><![CDATA[inspiration]]></category>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Sun, 02 Nov 2025 20:51:36 GMT</pubDate>
            <atom:updated>2025-11-02T20:51:36.840Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*Em5lNjwjYXTSDFkZ" /></figure><p>Yep, that’s me. You’re probably wondering how I ended up here. The year was 2019, and I had just defended my final-year project in the Department of Marine Science, University of Lagos. I was officially a Fisheries graduate — a title that sounded so funny to me that I still don’t remember what my project topic was. That probably tells you how disconnected I was from the field.</p><p>Rewind a bit. Like many Nigerian students, my story is not unfamiliar. It started with <em>JAMB dreams</em> that weren’t mine. Studying Medicine and Surgery was my parents&#39; choice, though I had always had a secret <em>crush</em> on Engineering. UNILAG, however, handed me Fisheries, which, at the time, I thought was the worst course in the school. I was wrong. There’s no such thing as the “worst course,” just different starting points.</p><p>My first semester? A disaster. 1.94 GPA. I had been a high flyer in secondary school, so that was a slap from reality. My dad, who’d always warned me that “the university will show you your real level” was right. He was right <em>men</em>. Thankfully, he didn’t scold me — he encouraged me. That was enough fuel to turn things around. From my second year until my final year, my lowest semester results were ones where I had only two Bs. I became an A student. I didn’t graduate with a first class, but I finished with a <strong>Strong</strong> <em>(allow me)</em> second class upper.</p><p>By my third year, life began to pivot. I met two roommates — Festus and Tomiwa — who reignited my childhood curiosity for engineering. They were learning C++ for a coursework, and I joined them out of interest. Festus, who’s now at Meta, would lend me his laptop so I could practice. I borrowed their laptops, watched tutorials, and wrote my first program: a simple GPA calculator. It wasn’t much, but it felt like discovering a superpower.</p><p>Everything accelerated after I won the MTN Foundation Scholarship in my fourth year. ₦200,000! It was such a big deal for me. I bought my first laptop and phone, and gave my parents a chunk of it. That laptop became my classroom. During my IT semester and the following ASUU strike, I dedicated my time to learning programming, joining the Developer Student Club, and building projects. By the time I was defending my final-year project, I already knew I wanted to build a career in software.</p><p>My dad often said, “Be rich in the currency of people.” When it was time to find my first job, he spent that currency for me — connecting me to someone who offered me an unpaid internship. In three months, it became paid. I’d go on to spend six years at Studio 14, rising through the ranks to become a Senior Software Engineer.</p><p>Looking back, I’m grateful for how everything lined up. The failures, the pivots, and the unexpected wins. They humbled me, redirected me, and taught me grit. From dissecting fish to debugging code, from GPA to APIs, I’ve learned that growth doesn’t always have to be linear, and nothing is ever truly impossible with God.</p><p>Lately, I’ve been thinking a lot about what’s next. I’m stepping into a new phase of my career, and maybe, just maybe, another pivot is coming. I wrote this as a personal reminder of where I started and how far persistence and faith can take me.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e8d09b1d17fd" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Introduction to Data Structures (II)]]></title>
            <link>https://medium.com/@paimoemmanuel2016/an-introduction-to-data-structures-ii-f8756abe2bce?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/f8756abe2bce</guid>
            <category><![CDATA[algorithms]]></category>
            <category><![CDATA[data-structures]]></category>
            <category><![CDATA[progamming]]></category>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Fri, 12 Nov 2021 20:45:35 GMT</pubDate>
            <atom:updated>2021-11-12T20:45:35.205Z</atom:updated>
            <content:encoded><![CDATA[<p>If you don’t have background knowledge on time complexities, it was explained in the first part of this post <a href="https://medium.com/@paimoemmanuel2016/an-introduction-to-data-structures-1cb4092b24ef">here</a>. If you have an understanding of time complexities or you read the first post, fire on!</p><h3>Some Types of Data Structures</h3><p>Let’s dive into the interesting part. By measuring the T(n) of <strong>accessing</strong>, <strong>searching</strong>, <strong>inserting,</strong> and <strong>deleting</strong> elements in a data structure, can help in determining what a data structure is suitable for. While the choice of data structure isn’t always entirely based on this, it gives a good understanding of what the data structure is good at and what it is bad at. Some of the types of data structures we have are;</p><ol><li><strong>Arrays and Array Lists</strong></li></ol><figure><img alt="A pictorial representation of an array of age" src="https://cdn-images-1.medium.com/max/466/1*IP4Kt-XNH06V5JWXTUYduA.jpeg" /><figcaption>A pictorial representation of an array of age</figcaption></figure><p>Arrays are one of the most common types of data structures. It is essentially a list of similar elements stored in a central location. An array usually has a <strong>name</strong> used to reference it and <strong>a fixed size</strong> or length. The elements in an array hold the same type of information and are stored in sequential order on the computer memory. Each element is referenced by a numerical index which represents its position in the array. The first element has an index of 0, the second element index of 1, and goes on like that.</p><p>An ArrayList is similar to an array but with dynamic size. In some programming languages, Arrays and ArrayList are merged together into a single data structure e.g., Lists in python and arrays in JavaScript. ArrayLists usually have built-in methods at disposal to do things like accessing, searching, deleting, and inserting elements. Arrays are used where the size of the dataset is known and fixed e.g a list containing data for each state in the country will always have a fixed size, while ArrayLists are used where the size is dynamic e.g., a list of followers of an Instagram account.</p><ul><li><strong>Accessing an element has a T(n) of O(1)</strong>. Elements can be accessed instantaneously by calling their index location. The size does not matter.</li><li><strong>Searching for an element has a T(n) of O(n)</strong>. Arrays are mostly unsorted i.e., the elements are not in a numerical or some sort of order. This means taking into consideration the worst-case scenario, if the element to be found is the last one in the array, you may have to search through all the elements to find it.</li><li><strong>Inserting an element has a T(n) of O(n)</strong>. Considering the worst-case scenario, if an element is to be inserted at index 0, every other element will have to be <em>shifted </em>to the right by one index. This gives a linear time complexity.</li><li><strong>Deleting an element has a T(n) of O(n)</strong>. Deleting an element follows the same idea as inserting in arrays and ArrayLists. For the worst-case scenario, deleting the last element will cause every other element to be <em>unshifted</em> by one index.</li></ul><p><strong>2. Stacks</strong></p><figure><img alt="A pictorial representation of stacks" src="https://cdn-images-1.medium.com/max/500/1*k1lPem8ubXVyCdEERAvDsw.jpeg" /><figcaption>A pictorial representation of stacks</figcaption></figure><p>A stack is a sequential access data structure in which elements are added or removed based on the ‘<em>Last In, First Out</em>’, (LIFO) principle. This means the last element to be added will be the first to be retrieved or accessed. You can think of it as a stack <em>(as the name implies)</em> of plates. You can’t access a plate in the middle without possibly destroying the stack. There is only one way in and the same way out of the dataset. Stacks usually come with two methods built-in, which are the push and pop methods, used to push an object to the top of the stack and remove an object from the top of the stack respectively. Examples of scenarios stacks are most suitable for are undo/redo features of text editors, the back button on your browser, etc.</p><ul><li><strong>Accessing an element has a T(n) of O(n)</strong>. This is because to access an element in the stack, you would have to pop off every element above it.</li><li><strong>Searching for an element has a T(n) of O(n)</strong>. This is for a similar reason to accessing an element. To search for an element in the middle or end of the stack, you have to move through every element before it.</li><li><strong>Inserting an element has a T(n) of O(1)</strong>. This is because the data flows in from a single point so adding an element can be done immediately.</li><li><strong>Deleting an element has a T(n) of O(1)</strong>. This is also because the data flows in from a single point so deleting an element can be done immediately from the top.</li></ul><p><strong>3. Queues</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/818/1*wEGI46EoSOJJu6Fk1F7Cqw.png" /><figcaption>A representation of a queue</figcaption></figure><p>A Queue is also a sequential access data structure in which elements are added or removed based on the ‘<em>First In, First Out</em>’, (FIFO) principle. This means the first element to be added will be the first to be retrieved or accessed. You can think of it as a line to use an ATM. The first person to arrive is the first person to use the machine. The later you arrive, the longer you wait. This means elements are added from the rear, known as the <em>tail,</em> and removed from the front, known as the <em>head</em>. Queues usually come with two methods built-in, which are the <em>enqueue</em> and <em>dequeue</em> methods, used to add an element to the tail of the queue and remove an element from the head of the queue respectively. Examples of scenarios stacks are most suitable for are job scheduling (the process in which the computer determines which task to complete for the user and when), by printers, when multiple documents are sent to know which to print next, etc.</p><ul><li><strong>Accessing an element has a T(n) of O(n)</strong>. This is because to access an element in the queue, you would have to dequeue every element above it.</li><li><strong>Searching for an element has a T(n) of O(n)</strong>. This is for a similar reason to accessing an element. To search for an element in the middle or tail of the queue, you have to move through every element before it.</li><li><strong>Inserting an element has a T(n) of O(1)</strong>. This is because we are only ever adding at a single point i.e., the tail.</li><li><strong>Deleting an element has a T(n) of O(1)</strong>. This is also because we are only ever dequeuing at a single point which is the head.</li></ul><p><strong>4. LinkedList</strong></p><figure><img alt="A representation of LinkedLists" src="https://cdn-images-1.medium.com/max/759/1*6ReSYwX-z-n4jWPCRSxqBw.png" /><figcaption>A representation of a LinkedList</figcaption></figure><p>A LinkedList is a sequential access linear data structure where each element is an object called a <strong>node</strong> that contains two parts; <strong>the data, and the reference</strong> which points to the next node in the list. The data is where the actual content of the data structure is kept. The reference or pointer points to where the next node is stored in memory. A LinkedList starts with a node called the h<strong>ead node</strong> of the list and points to the second node and continues in that pattern. The last node called the <strong>tail node</strong> points to a null value. Application of LinkedLists includes being used as a backing of other data structures i.e., it can be used to make stacks, queues, etc. It is also used in the ‘up next’ feature of your music or movie player or a photo viewing software. <strong>It is important to note that the pointer of a node in a LinkedList can only point in one direction which is forward.</strong></p><ul><li><strong>Accessing an element has a T(n) of O(n)</strong>. This is because a queue is a sequential access linear data structure. This means they can only be accessed in a particular way. If we want to access an element, we would have to cycle through every node before it.</li><li><strong>Searching for an element has a T(n) of O(n)</strong>. Searching is O(n) for the same reason. We will have to cycle through all the preceding nodes to find a node.</li><li><strong>Inserting an element has a T(n) of O(n) or O(1)</strong>. To add an element to the end of a LinkedList, all you need to do is to point the reference of the last node to the new node and point the reference of the new node to null. To add an element at the beginning, the reference of the new node will be pointed to the head node of the list. To add an element to the middle of a LinkedList, you will have to point the node before the location to the new node and point the new node to the next node after the location. Inserting an element at the beginning or end of a LinkedList has an O(1) but inserting in the middle means we would have to traverse through the preceding nodes before inserting. This means sometimes inserting is O(1) and other times, O(n).</li><li><strong>Deleting an element has a T(n) of O(n) or O(1)</strong>. To delete an element at the beginning, the reference of the head node will be pointed to null and that’s it. The node will be cut off from the rest of the list. To delete at the end of a LinkedList, set the pointer of the previous node to null instead of the current tail. To delete an element from the middle of a LinkedList, the node before the one to be removed is pointed to the node after the one to be removed. Deleting an element works like inserting. Deleting at the beginning or ending will have a time complexity of O(1) while deleting an element in the middle will have a time complexity of O(n).</li></ul><p><strong>5. Doubly-LinkedList</strong></p><figure><img alt="A representation of a Doubly LinkedList" src="https://cdn-images-1.medium.com/max/907/1*M8OI5w8cS4idbtYyr-iNag.png" /><figcaption>A representation of a Doubly LinkedList</figcaption></figure><p>The Doubly LinkedList are like linkedlists but with a two-directional flow. A node has two pointers that point forward and backward. We can term the pointer that points forward the ‘next’ pointer and the one that points backward the ‘previous’ pointer. For the head node of a doubly LinkedList, the previous pointer points to a value of null while the next pointer points to the next node. For the last node, the previous pointer points to the previous node, and the next pointer points to null. The adaptability of the structure makes it a great way to store information. Application of doubly LinkedList includes undo/redo features, browser caches, etc.</p><p>The Time complexity of <strong>accessing, searching, inserting, and deleting</strong> elements from doubly linkedlists is the same as LinkedList.</p><p>Some other complex data structures not treated in this article are dictionaries, trees, tries, heaps, and graphs.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f8756abe2bce" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Understanding Hoisting, Scope, and Closure in JavaScript]]></title>
            <link>https://medium.com/@paimoemmanuel2016/understanding-scope-closure-and-hoisting-in-javascript-55478f3bea2d?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/55478f3bea2d</guid>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Sat, 30 Oct 2021 04:43:41 GMT</pubDate>
            <atom:updated>2021-11-16T14:06:49.510Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/484/1*vDcsVkpIcN-pbZQliw5ahQ.jpeg" /><figcaption>Hoisting, Scope, and Closures</figcaption></figure><p>Hoisting, Scope, and Closures are JavaScript concepts that are easily considered technical. They are closely related and questions on these concepts are frequently asked in coding interviews. Many JavaScript programmers already use them but might not know or understand what exactly they mean. However, they are not difficult to grasp and in this article, we will be walking through these concepts with examples to get a clear understanding.</p><h3>Hoisting</h3><p>In JavaScript, hoisting is a phenomenon where all the variables declared with the <strong>var</strong> keyword and named functions are moved to the top of the scope during compile time. This means a variable can be assigned and used before it is defined in a file without causing any error. Below is an example;</p><pre>var name = firstName + &quot; &quot; + lastName;<br>var firstName = &#39;Emmanuel&#39;;<br>var lastName = &#39;Paimo&#39;;<br>console.log(name)</pre><pre>/* Below is how JavaScript interprets it */</pre><pre>var name;<br>var firstName;<br>var lastName;<br>name = firstName + &quot; &quot; + lastName;<br>console.log(name);<br>// Emmanuel Paimo</pre><p>Only the variable declaration is hoisted. If the variable is used in an executable statement before being initialized, it will be undefined.</p><pre>console.log(name);<br>var name = &#39;Emmanuel&#39;;</pre><pre>/* Below is how JavaScript interprets it */</pre><pre>var name;<br>console.log(name);<br>name = &#39;Emmanuel&#39;;<br>// Undefined</pre><h3><strong>Scopes</strong></h3><p>A Scope in JavaScript is simply a set of rules that determines where you can access items (usually variables and named functions) within a program. Scope in JavaScript is determined lexically, meaning it is determined by where the variable is declared in the code. The different types of scopes are;</p><ul><li><strong>Global Scope: </strong>This is the root scope of the program. Variables in the global scope are declared in the root of the file, outside any function or block. They are accessible anywhere in the program. An example is:</li></ul><pre>const name = &#39;Emmanuel&#39;; // Declared in the global scope</pre><pre>const printName = () =&gt; {<br>  console.log(name);<br>}</pre><pre>console.log(name);<br>// Emmanuel</pre><pre>printName();<br>// Emmanuel</pre><ul><li><strong>Function Scope: </strong>This is the scope within the opening and closing curly braces of a function. Variables defined in a function scope can only be accessed within the function. An example is:</li></ul><pre>const printName = () =&gt; {<br> const name = &#39;Emmanuel&#39;;<br> console.log(name);<br>}</pre><pre>console.log(name);<br>// ReferenceError: name is not defined.</pre><pre>printName();<br>// Emmanuel</pre><ul><li><strong>Block Scope: </strong>They are local scopes bounded by curly braces. Examples of block scopes are in if/else statements, for-loops, while loops, and switch statements. It is good to note that variables defined with the <strong>var</strong> keyword in block scopes can be accessed outside the scope but variables declared with <strong>let</strong> or <strong>const</strong> can only be accessed inside the block scope in which it was declared.</li></ul><pre>const printName = () =&gt; {<br> if(true) {<br>  const name = &#39;Emmanuel&#39;;<br>  console.log(name); // First console.log<br> }<br> console.log(name); // Second console.log<br>}</pre><pre>printName();<br>// Emmanuel<br>// ReferenceError: name is not defined.</pre><p>In the first console.log , name is accessed inside the block scope in which it was declared. In the second console.log, name is referenced outside the block scope it was created in. This will throw a ReferenceError.</p><p><strong><em>Var vs Let vs Const</em></strong></p><p>JavaScript has three keywords that can be used to declare a variable, which are <strong>var</strong>, <strong>let</strong> and <strong>const</strong>. Before ES2015, <strong>var</strong> was what was used. However, there were some problems that arose with the way variables behaved. Two major issues were;</p><p>i.) Variables declared with <strong>var</strong> are not bound by a block scope, causing possible pollution in the namespace. <strong>let</strong> and <strong>const</strong> were introduced to solve this problem. The behavior of <strong>var</strong> could have been outrightly changed but at that time, millions of sites on the web were already built. It would have been ridiculous to change the behavior as this will cause a large percentage of the existing web apps to crash.</p><p>Variables created with <strong>var</strong> in a block scope can be accessed outside the scope. The snippet below shows the behavior;</p><pre>if(true){<br> var varName = &quot;Emmanuel var&quot;;<br>}<br>console.log(varName);<br>// Emmanuel var</pre><pre>if(true){<br> const constName = &quot;Emmanuel const&quot;;<br>}<br>console.log(constName);<br>// ReferenceError: constName is not defined.</pre><p>Variables declare with <strong>let</strong> or <strong>const</strong> cannot be accessed outside their scope, whether it is a function scope or a block scope. The difference between <strong>let</strong> and <strong>const</strong> is that <strong>const</strong> is used to declare variables that would remain constant, while <strong>let</strong> is used to declare variables that can be changed.</p><p>ii.) Another problem with <strong>var</strong> was that variables declared with it can be redeclared. This could lead to accidentally overwriting a variable that has been already declared.</p><pre>var name = &#39;Emmanuel&#39;;<br>var name= &#39;Paimo&#39;;<br>console.log(name)<br>// Paimo</pre><pre>let age = 20;<br>let age = 25;<br>console.log(age)<br>// SyntaxError: &#39;age&#39; has already been declared</pre><p><strong>Note: </strong>Scopes can also be layered in a hierarchy, so that child scopes have access to parent scopes, but not vice versa. A scope can be created inside an existing scope, creating a parent-child relationship. This is phenomenon is called <strong>Scope Chain.</strong></p><p>Variables in the local scope take precedence over variables in the parent or global scope. Conventionally, creating variables in the global scope is considered bad practice. This is because they can be modified from anywhere and could lead to potential bugs and problems in a program.</p><h3>Closures</h3><p>In JavaScript, it is possible for a function to make use of a variable outside the function scope, as earlier explained. A function that uses variables available outside its scope is called an <strong>impure function</strong>. Closure can simply be explained as a function bound together with the variables its lexical scope. When an impure function is created, the variables in its lexical scope are bound to the function. When functions are returned from another function, they still retain their lexical scope. Take a look at the code snippet below;</p><pre>const outer= () =&gt; {<br> const a = 7;<br> const inner = () =&gt; {<br>  console.log(a);<br> }<br> return inner;<br>}</pre><pre>const result = outer();<br>result()<br>// 7</pre><p>In the snippet above, result is able to reference a, which is not in its lexical scope because the inner function that is returned retains the variables in its scope. The inner function which is an impure function has the variables in its scope bound to it by Closure.</p><h3>Conclusion</h3><p>Managing variables well and keeping the namespace unpolluted is a great skill to have as a programmer, especially when working with a large team. It is advisable to keep variables private as much as possible to prevent bugs. A good understanding of hoisting, scope, and closure will help programmers achieve this and write clean code.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=55478f3bea2d" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[An Introduction to Data Structures]]></title>
            <link>https://medium.com/@paimoemmanuel2016/an-introduction-to-data-structures-1cb4092b24ef?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/1cb4092b24ef</guid>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Fri, 01 Oct 2021 16:59:25 GMT</pubDate>
            <atom:updated>2021-10-02T09:34:52.638Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6w37SSNUnFN6TXoQL6oooA.jpeg" /><figcaption>Data Structures</figcaption></figure><p>For many beginner programmers, the concept of Data structures is dreaded and altogether avoided. However, it is an important concept to understand to be able to solve a wide scope of problems. This is why it is a usual requirement for at least senior roles in most FAANG companies.</p><p>A good understanding of Data structures helps you give the best possible solutions to problems in detail and gives you an insight into how efficient it is to use each one of them. This makes it important to learn. Programmers often need to store a set of related information to be later referenced or modified. A simple definition of a Data Structure is a way to store, organize and manage related data in a way that is easy to access and modify.</p><p>Data structures are mostly universal across programming languages. They have similar structures but different syntax across languages. There are different types of data structures in programming and in this article, we’ll be going through a number of data structures and how to determine their efficiency.</p><p>In reality, data structures are used vastly in software engineering. Examples are features such as your Facebook friend lists, the undo-redo feature of a text editor, the Document-Object Model of your browser, the text auto-complete feature, etc.</p><h3><strong><em>The Big O Notation</em></strong></h3><figure><img alt="The Big O Notation" src="https://cdn-images-1.medium.com/max/498/1*BcYPJzMvuXaxX0d3urjtIw.png" /><figcaption>The Big O Notation</figcaption></figure><p>To know the most suitable data structure to use, there is a need to measure the speed and efficiency of the data structure. The common criteria considered in measuring this is the efficiency in <strong>accessing</strong>, <strong>searching</strong>, <strong>inserting,</strong> and <strong>deleting</strong> elements in the data structure. The Big O Notation is the conventional way to measure the efficiency of data structures. Big O notations are recorded using <strong><em>Time Complexity Equations</em></strong>. Contrary to what the name suggests, the time complexity is not a measure of the actual time it takes the computer to carry out the function because this will be biased, depending on the strength of the hardware and other factors. It is rather a measure of the number of operations it takes to complete a function.</p><p>The Time complexity equation of a function can be written as;</p><p>T(n) = O(<em>x</em>),</p><p>Where <strong><em>T(n)</em></strong> is the time complexity, <strong><em>n</em></strong> is an integer representing the size or number of elements in the data structure and <strong><em>x</em></strong> is the number of operations it takes to completely execute the function on a data structure with respect to size <strong><em>n</em></strong>. This equation is read as ‘a time complexity <strong><em>O</em> of</strong> <strong><em>x </em></strong>’. Mostly, the number of elements in the data structure has a negative effect on the number of operations that need to be performed for the computer to carry out a function like searching through the data set. The worst-case scenarios are used when measuring the time complexity of a data structure i.e. the highest possible number of <strong><em>n</em></strong><em> </em>is considered.</p><p>Don’t get confused, this will get clearer when we consider examples with different types as we do below.</p><p>Here are some types of time complexities;</p><p><strong>i. Constant Time Complexity</strong></p><figure><img alt="A graphical representaation of a constant time complexity" src="https://cdn-images-1.medium.com/max/416/1*jGBb7LnXrxqAZ058IKSUdA.jpeg" /><figcaption>A graphical representation of a constant time complexity, where n is the size of the data</figcaption></figure><p>This means the number of operations carried out to execute the function is constant, irrespective of the size of the data structure. One element data set, and a quadrillion elements data set, no problem — the same number of operations. This is the best and most efficient Time Complexity Equation and is represented as <strong><em>T(n) = O(1)</em></strong>.</p><p><strong>ii. Logarithmic Time Complexity</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*rHG2S3BhNc_EG9ODnaI41A.png" /><figcaption>A graphical representation of a logaritmic time complexity</figcaption></figure><p>This means the number of operations carried out to execute the function increases logarithmically, with the size of the data structure. It is slower than constant time complexity but still considered a fast time complexity. It is represented as <strong><em>T(n) = O(log n)</em></strong>.</p><p><strong>iii. Linear Time Complexity</strong></p><figure><img alt="" src="https://cdn-images-1.medium.com/max/600/1*_JGMMcaJEvhD9rbFNqS8RQ.png" /><figcaption>A graphical representation of a linear time complexity</figcaption></figure><p>This means as the size of the data structure increases, the number of operations carried out to execute the function increases at the same pace. This is considered a decent Time Complexity Equation and is represented as <strong><em>T(n) = O(n)</em></strong>.</p><p><strong>iv. Quadratic Time complexity</strong></p><figure><img alt="A graphical representation of a quadratic time complexity, where n is the size of the data" src="https://cdn-images-1.medium.com/max/640/1*3APdVW2M3rFO2eKApQkjgg.png" /><figcaption>A graphical representation of a constant time complexity, where n is the size of the data</figcaption></figure><p>This means the number of operations carried out to execute the function is squared, with an increase in the size of the data structure. This is considered an inefficient Time Complexity Equation and is represented as <strong><em>T(n) = O(n²)</em></strong>.</p><p>Some other time complexities include;</p><p><strong>v.</strong> Log-Linear Time Complexity: <strong><em>T(n) = O(n log n)</em></strong>.</p><p><strong>vi.</strong> Exponential time: <strong><em>T(n) = O(c^n), where c is some constant</em></strong>.</p><p><strong>vii</strong>. Factorial time: <strong><em>T(n) =O(n!).</em></strong></p><p>These are types of time complexities. They can help us tell the efficiency of accessing, searching, inserting, and deleting elements from a data structure.</p><p>This post continues in a second part that explains types of data structures and their time complexities. You can continue reading <a href="https://medium.com/@paimoemmanuel2016/an-introduction-to-data-structures-ii-5923631819e5">here</a>.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1cb4092b24ef" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[HNG Internship (Bug in Timbu.com)]]></title>
            <link>https://medium.com/@paimoemmanuel2016/hng-internship-bug-in-timbu-com-493fcf98b9ff?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/493fcf98b9ff</guid>
            <category><![CDATA[slack]]></category>
            <category><![CDATA[bugs]]></category>
            <category><![CDATA[hnginternship]]></category>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Tue, 02 Apr 2019 04:12:27 GMT</pubDate>
            <atom:updated>2019-04-02T04:20:11.256Z</atom:updated>
            <content:encoded><![CDATA[<p>“Paimo how far? Have you found a bug?” That was a statement made by my friend as I returned to the hostel in the evening oblivious of the latest task for the HNG Internship.</p><p>After he explained that it was for the HNG Internship, I went straight to the slack channel to get the details of the latest task. I saw that we have to find a bug in the website (timbu.com) and write a blog post about it.</p><p>After scanning through the website for a while, a found one faster than I expected. I figured that the page that explores hotels in a country has the official language of that country. However, this is not the case for China, as the page that explores Hotels in the country remains in English.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*hGb-ledY2JeuKUWMfPULNg.png" /><figcaption>Brazil page is in Portugese</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*CIA0OMOiSNvnOcLhDvUZwg.png" /><figcaption>China page does not change language.</figcaption></figure><p>That is the pretty little bug I found in the website!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=493fcf98b9ff" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Hashcode 2019 in DSC Unilag]]></title>
            <link>https://medium.com/@paimoemmanuel2016/hashcode-2019-in-dsc-unilag-8e88e81606ab?source=rss-cd145caafde5------2</link>
            <guid isPermaLink="false">https://medium.com/p/8e88e81606ab</guid>
            <category><![CDATA[hashcode]]></category>
            <category><![CDATA[developer-student-club]]></category>
            <category><![CDATA[google]]></category>
            <category><![CDATA[unilag]]></category>
            <category><![CDATA[computer-programming]]></category>
            <dc:creator><![CDATA[Emmanuel Paimo (Paims)]]></dc:creator>
            <pubDate>Fri, 01 Mar 2019 18:59:51 GMT</pubDate>
            <atom:updated>2019-03-01T19:36:21.556Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/387/1*kqFHN7MCmCT2eii31ADNig.png" /><figcaption>2019 Hashcode in Unilag</figcaption></figure><p>Hashcode is a yearly team programming competition organized by Google, for students and professionals around the world. You pick a team and a programming language and google picks an engineering problem, for you to solve.</p><p>Participants in the DSC Unilag hub started gathering at the venue by 6.00pm and the action started at exactly 6:30pm. The air-conditioned venue and free internet access made the venue a conducive one. The teammates sat in rows, to make the collaboration faster and easier. Every team looked confident, with Alienwares, MacBooks, and high-specs laptops flying everywhere. Then there was a notable team, the <em>JavaScripters</em> — a group of strong, enthusiastic all female engineers.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*EstIcy4CBvbHA9VpkovqbA.jpeg" /><figcaption>The JavaScripters</figcaption></figure><p>After taking a little while to understand the 7 pages challenge, the different teams got into serious business as the sound of smacking keyboards could almost be heard echoing.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vhymYRC7kndZUKIoGKPnrw.jpeg" /><figcaption><em>Bakman and other members of the PhantomSquad, trying to understand the challenge.</em></figcaption></figure><p>Geektutor was constantly encouraging the teams to submit their work, before the scoreboard was frozen so progress could be measured.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*rQRMRBatdfLg7v_LXkWgOQ.jpeg" /><figcaption>A tutor and a student. PS: The tutor is the one on glasses</figcaption></figure><p>After about two hours, only two teams had a score, with team BlacSquad at 12 points and Team Titan on 2 points. After about 3 hours the team BlacSquad was on 285,311 points, third in Nigeria and team Slash also joined the party with the same number of points. Felt like the chilled drinks that was served worked a trick.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*yto9gnSPA2mt9ytDWtA-4Q.jpeg" /><figcaption><em>The BlacSquad</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*-3B5xO_h5IphVRbHonUisg.jpeg" /><figcaption>Team Slash</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*TxrTLrLQJWnYazTeR9RdsQ.jpeg" /><figcaption>Something chilled was needed. Gracias Geektutor.</figcaption></figure><p>At the end of the competition, the Titans emerged the highest ranked team in the University of Lagos developers’ student club and fourth in Nigeria, with 482,348 points other teams ranked not far way too in the country rating, doing us proud.</p><p>In what I’d like to call extra time, the Titans rose to be the highest in Nigeria and Africa and among the top 80 globally. Now that is something. Big ups to Ofili, Yahaya, Abass and Caleb.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/540/1*agefZIsOeRR2TgHdhyI33w.jpeg" /><figcaption>Spot the Titans!</figcaption></figure><p>The atmosphere was electric and inspiring.</p><p>Four big lessons to be taken away;</p><p>1. Don’t overthink. Start once you have a picture in mind. Overthinking will slow you down, and you might not have anything to show for it at the end of the day.</p><p>2. Don’t wait until you have a perfect code before submitting. Submit at intervals. You start reeking points, and this can help your confidence and final score.</p><p>3. Don’t be intimidated by the score of other guys, just keep doing your thing.</p><p>4. Do some work before hand, like creating a git repo, to make collaboration easier and faster. Someone almost spent the whole day loooking for a flasdrive!</p><p>After the competition, swags were given out to top teams.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jxFG7C1yDyP1BBzLhYS3xw.jpeg" /><figcaption>The bad guys</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eErfwpQVd9H0rC__G1sJOg.jpeg" /><figcaption>These guys were basically ‘<em>paraing’. Standing up and gesticulating, they were a bit intimidating too.</em></figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*bDXd724coaizqMYh1O3uOg.jpeg" /><figcaption>Myself and Geektutor</figcaption></figure><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jCQlltMK9HBjtNtJeORKTA.jpeg" /><figcaption><em>Hashcode 2019, DSC Unilag hub, Smart guys everywhere!</em></figcaption></figure><p>Check out all the pictures here. <a href="https://photos.app.goo.gl/7BGGUrBa871pZoHg7">https://photos.app.goo.gl/7BGGUrBa871pZoHg7</a></p><p>Thanks to DSC Unilag organizers for hosting us, and thanks to google for organizing the competition.</p><p>Watch out for us next year!</p><p>We move!</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8e88e81606ab" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>