DEV Community: Mohammed Shaikh

Tree Traversals Explained: DFS, BFS, and When to Use Each

Mohammed Shaikh — Sun, 04 Jan 2026 14:09:25 +0000

Data Structures 1.2 — Tree Traversals (DFS & BFS)

In Part 1.1, we introduced trees and built our first binary tree. Now it’s time to answer an important question:

How do we actually move through a tree?

Tree traversals define the order in which nodes are visited. Mastering them is essential for understanding algorithms, solving interview questions, and working with real-world systems like the DOM, file systems, and search problems.

This post focuses on the two big families of traversals:

Depth-First Search (DFS): Think of DFS like walking down one hallway until it ends, then backtracking.
Breadth-First Search (BFS): Think of BFS like checking every room on the current floor before going upstairs.

Depth-First Search (DFS)

Depth-First Search explores a tree by going as deep as possible before backtracking.

DFS has three common variants:

Inorder
Preorder
Postorder

All three follow the same recursive structure — the difference is when the current node is processed.

Inorder Traversal (Left → Root → Right)

Inorder traversal first visits the left subtree, then the current node, and finally the right subtree.

This traversal is especially important for Binary Search Trees, because it returns values in sorted order.

function inorderTraversal(node) {
  if (node === null) return;

  inorderTraversal(node.left);
  console.log(node.val);
  inorderTraversal(node.right);
}

When to use inorder:

Retrieving sorted data from a BST
Validating BST structure

Preorder Traversal (Root → Left → Right)

Preorder traversal processes the current node before its children.

function preorderTraversal(node) {
  if (node === null) return;

  console.log(node.val);
  preorderTraversal(node.left);
  preorderTraversal(node.right);
}

When to use preorder:

Serializing trees
Copying tree structures
Building expression trees

Postorder Traversal (Left → Right → Root)

Postorder traversal processes the current node after both children.

function postorderTraversal(node) {
  if (node === null) return;

  postorderTraversal(node.left);
  postorderTraversal(node.right);
  console.log(node.val);
}

When to use postorder:

Deleting trees
Evaluating expressions
Bottom-up computations

Breadth-First Search (BFS)

Breadth-First Search traverses the tree level by level, from left to right.

Unlike DFS, BFS uses a queue instead of recursion.

function breadthFirstTraversal(root) {
  if (root === null) return;

  const queue = [root];

  while (queue.length > 0) {
    const current = queue.shift();
    console.log(current.val);

    if (current.left) queue.push(current.left);
    if (current.right) queue.push(current.right);
  }
}

When to use BFS:

Finding the shortest path in unweighted trees
Level-order processing
Problems involving "nearest" or "minimum distance"

Both DFS and BFS visit every node once — O(n) time.

The key difference is space:

DFS uses space proportional to the tree height (call stack)
BFS uses space proportional to the widest level (queue)

DFS vs BFS — How to Choose?

Here’s a simple mental model:

Use DFS when:
- You want to explore deep paths
- You’re working recursively
- The tree depth is manageable
Use BFS when:
- You need the shortest path
- You care about levels
- You want the closest node

In practice, the choice often comes down to memory — deep but narrow trees favor DFS, while shallow but wide trees favor BFS.

In interviews, keywords like "closest", "minimum depth", or "level order" often hint at BFS.

Common Mistakes

Forgetting base cases in recursion
Mixing traversal orders
Using DFS where BFS is required (and vice versa)
Modifying the tree unintentionally during traversal

Interview Tip

If you can:

Write all three DFS traversals from memory
Explain when to use BFS

You already have an advantage in tree-based interview questions.

Continue the Data Structures Series

This post is part of an ongoing Data Structures Series focused on clarity, real-world intuition, and JavaScript implementations.

Prev: Part 1.1 — Tree Fundamentals

View the full roadmap: Data Structures Series — Overview

Data Structures Series: A Structured Roadmap with JavaScript

Mohammed Shaikh — Sat, 20 Dec 2025 02:35:25 +0000

Welcome to the Data Structures Series, a structured, JavaScript-powered breakdown of the core data structures every developer should know.

Whether you're preparing for interviews, brushing up fundamentals, or leveling up as a software engineer, this series is designed to be:

Clear — no fluff, just clean explanations.
Practical — real-world relevance, not just theory.
Code-driven — every concept backed by JavaScript examples.
Structured — each part builds on the previous one.
Consistent — two posts per week (Monday & Thursday).

This overview acts as your hub, your table of contents, and your roadmap. Bookmark it — every future post will link back here.

What You Can Expect from This Series

This series is broken into six major parts, each covering a core data structure family.

You’ll learn:

How each structure works
Where it’s used in real software
How to implement it in JavaScript
Common patterns and mistakes
Interview-style applications

Published incrementally as each part is completed.

PART 1 — TREES

Trees are foundational to many systems — the DOM, file systems, compilers, databases, and more.

1.1 Trees Fundamentals
1.2 Tree Traversals (DFS/BFS)
1.3 Binary Search Trees (BST Intro)
1.4 BST Operations — Insert, Search, Delete
1.5 AVL Trees (Balancing Logic)
1.6 Red-Black Trees (Color & Rotation Rules)
1.7 N-Ary Trees
1.8 Tries (Prefix Trees)
1.9 Heap / Priority Queue (as Trees)
1.10 Interview-style Tree Patterns & Templates

PART 2 — HASHING & MAPS

One of the most important foundations in all of programming.

2.1 Hash Tables — Intro
2.2 Hash Functions — Good vs Bad
2.3 Collision Strategies
2.4 Implementing a HashMap in JS
2.5 Map vs Object vs Dictionary
2.6 Interview-style Hashing Patterns

PART 3 — LINKED LISTS

A staple in interviews, pointer problems, and memory-based structures.

3.1 Singly Linked List — Intro
3.2 Doubly & Circular Linked Lists
3.3 Fast/Slow Pointer Technique
3.4 Linked List Implementation in JS
3.5 Interview-style LL Patterns

PART 4 — STACKS & QUEUES

Core structures behind algorithms, parsing, UI rendering, and more.

4.1 Stacks — LIFO Explained
4.2 Queues — FIFO, Priority Queue
4.3 Implementing Stacks & Queues in JS
4.4 Monotonic Stack (Interview Applications)
4.5 Interview-style Patterns

PART 5 — GRAPHS

One of the most powerful and flexible data structures in computer science.

5.1 Graph Basics
5.2 Representations (Adjacency List / Matrix)
5.3 BFS Deep Dive
5.4 DFS Deep Dive
5.5 Directed vs Undirected Graphs
5.6 Weighted Graphs
5.7 Dijkstra
5.8 A* Pathfinding
5.9 Topological Sort
5.10 Interview-style Graph Patterns

PART 6 — ARRAYS & STRINGS

The category where most interview questions live.

6.1 Sliding Window
6.2 Two Pointers
6.3 Prefix Sums
6.4 Difference Arrays
6.5 Searching Techniques
6.6 Sorting Algorithms Overview
6.7 String Algorithms
6.8 Subarray Patterns
6.9 Kadane’s Algorithm
6.10 Interview-style Best Array/String Problems

How to Follow the Series

Posts drop Monday and Thursday.
All code examples use JavaScript.
Each part can be read independently.
Following in order builds the strongest understanding.

You can:

Bookmark this overview
Comment questions you want answered
Suggest topics for deeper dives

Why This Series Exists

I’ve learned these concepts through:

Courses
Senior engineers
Papers & articles
Real-world debugging
Interview preparation

This series is my attempt to make the path clearer for the next person.

Clean explanations. Practical code. Developer-focused learning.

Stay Tuned — First Posts Dropping Soon

Follow me to get each part as it releases.

Next post: Part 1.1 — Tree Fundamentals

Let's master data structures together.

Trees Fundamentals: Structure, Terminology, and Use Cases

Mohammed Shaikh — Sat, 20 Dec 2025 02:32:17 +0000

This post introduces Trees, one of the most common and important data structures in computer science. Trees show up everywhere — in file systems, the DOM, compilers, databases, operating systems, pathfinding, and tons of interview questions.

This is Part 1.1 of the Data Structures Series.

What Is a Tree?

A Tree is a hierarchical, non-linear data structure made of nodes.

Each node:

Stores a value
Has zero or more children
Has exactly one parent (except the root)

Common real-world analogies:

Folder structures
Company org charts
Website DOM

Trees are ideal when the data naturally forms a hierarchy.

Common Types of Trees

There are many variations of trees, but these are the ones most used in software and interviews:

Binary Tree
Binary Search Tree (BST)
AVL Tree
Red-Black Tree
N-ary Tree
Trie (Prefix Tree)

This post focuses on the Binary Tree, since most traversal logic starts here.

What Is a Binary Tree?

A Binary Tree is a tree where each node has at most two children.

Let's create one in JavaScript:

class Node {
  constructor(key, left = null, right = null) {
    this.left = left;
    this.right = right;
    this.val = key;
  }
}

const root = new Node(1);
root.left = new Node(2);
root.right = new Node(3);
root.left.left = new Node(4);
root.left.right = new Node(5);

// The tree structure:
//        1
//       / \
//      2   3
//     / \
//    4   5

You can also build the tree with nested constructor calls, but this form is more readable for beginners.

Tree Traversals

Traversals describe how we "walk" through a tree. There are four fundamental traversal patterns:

Inorder
Preorder
Postorder
Breadth-First Search (Level Order)

We'll go deeper into each in Part 1.2, but here is a quick preview.

Inorder (Left → Root → Right)

Useful in Binary Search Trees because it returns nodes in sorted order.

function inorderTraversal(node) {
  if (node !== null) {
    inorderTraversal(node.left);
    console.log(node.val);
    inorderTraversal(node.right);
  }
}

Preorder (Root → Left → Right)

Good for serializing or copying trees.

function preorderTraversal(node) {
  if (node !== null) {
    console.log(node.val);
    preorderTraversal(node.left);
    preorderTraversal(node.right);
  }
}

Postorder (Left → Right → Root)

Commonly used when deleting or evaluating trees.

function postorderTraversal(node) {
  if (node !== null) {
    postorderTraversal(node.left);
    postorderTraversal(node.right);
    console.log(node.val);
  }
}

Breadth-First Search (Level Order)

Visits each level of the tree from left to right.

function breadthFirstTraversal(root) {
  const queue = [root];

  while (queue.length > 0) {
    const currentNode = queue.shift();
    console.log(currentNode.val);

    if (currentNode.left) queue.push(currentNode.left);
    if (currentNode.right) queue.push(currentNode.right);
  }
}

Why Traversals Matter

Different problems require different traversal strategies:

Inorder → sorted output in BSTs
Preorder → reconstructing or serializing trees
Postorder → evaluating expressions, deleting structures
BFS → shortest path, level-by-level processing

You'll see these patterns repeatedly in interviews.

Continue the Data Structures Series

This post is part of an ongoing Data Structures Series focused on clarity, real-world intuition, and JavaScript implementations.

View the full roadmap:

👉 Data Structures Series — Overview

987. Vertical Order Traversal of a Binary Tree (HARD)

Mohammed Shaikh — Mon, 19 Feb 2024 12:34:58 +0000

Intro

This is a hard problem on Leetcode. This is an interesting twist to the usual traversal problems with an acceptance rating of 47%

Problem Statement

Given the root of a binary tree, we have to calculate the vertical order traversal of the binary tree.

For each node at position (row, col), its left and right children will be at positions (row + 1, col - 1) and (row + 1, col + 1) respectively. The root of the tree is at (0, 0).

What is vertical order traversal

The vertical order traversal of a binary tree is a list of top-to-bottom orderings for each column index starting from the leftmost column and ending on the rightmost column. There may be multiple nodes in the same row and same column. In such a case, sort these nodes by their values.

So given a binary tree that looks like

The left most node is 9 and the right most node is 7. The top most node(aka root) is 3 and there are two nodes that would be considered bottom most, 15 and 7.

Since in vertical order traversal, we do top to bottom and left to right. The return value will look like [[9],[3,15],[20],[7]].

Solution

A good way to solve this would be to do a DFS(depth first search). I chose to do this recursively. We can also do this iteratively, which we will cover later.

In order to solve this, we have to divide the problem in two parts.

Figuring out which node goes into what column and rows
Putting all the nodes together in the vertical traversal order

The first part can be done by going through the binary tree and the second part is putting it together in the right order.

The first part:

var verticalTraversal = function(root) {
    const columnMap = new Map();

    const dfs = (node, row, col) => {
        if (!node) {
            return;
        }

        if (!columnMap.has(col)) {
            columnMap.set(col, []);
        }
        columnMap.get(col).push({ val: node.val, row });

        dfs(node.left, row + 1, col - 1);
        dfs(node.right, row + 1, col + 1);
    };
    dfs(root, 0, 0);

This is a standard recursive function and it goes through and captures all the nodes by column and also stores its row. You can use a plain object for this as well. The column map will look something like

[
  [ 0, [ [Object], [Object] ] ],
  [ -1, [ [Object] ] ],
  [ 1, [ [Object] ] ],
  [ 2, [ [Object] ] ]
]

Now we know all the nodes and their respective columns and rows. We have to just turn that information into an ordered array of arrays.

    return [...columnMap.entries()].sort((a, b) => a[0] - b[0])
        .map((nodes) => {
            nodes[1].sort((a, b) => a.row !== b.row ? a.row - b.row : a.val - b.val);

            const result = nodes[1].map(node => node.val);
            return result;
        });

There is a lot of things happening here so let's break it down.

First we have the sort function [...columnMap.entries()].sort((a, b) => a[0] - b[0]). It takes all the keyValue pairs, puts them in an array and sorts them by their columns(keys).

Then we have the massive map function. There are three parts to this.

1) The main map: We have to mmap through the large key + array of objects and turn it into a simple array of arrays. We are working through each value pair and running the the sort and the map on the values.

2) The sort function makes sure that the nodes are in the vertical traversal order. Sort the nodes by rows and values

3) the map gets rid of all values about the node except the nodeValue. puts it in an array and returns it to the bigger arr.

at the end of this, you will have all the information need for this problem

There are other solutions like doing BFS iteratively and many other variations. This was my favorite because I feel like it is as efficient as most of them, but it is very simple and straight forward

Thanks for reading. Hope it helps!

Iterators in JAVA

Mohammed Shaikh — Wed, 14 Feb 2024 16:25:00 +0000

Intro

When I was going through and learning Java. I wished there was a collection of docs that was written that explains Java topics simply.

Iterating through arrays

For Loop:

This is the standard for-loop. This is in a lot of different languages as well

int[] myArray = {1, 2, 3, 4, 5};
for (int i = 0; i < myArray.length; i++) {
    System.out.println(myArray[i]); // logic to log element
}

Enhanced For Loop (for-each):

A more concise way to iterate through an array, especially beneficial when you don't need the index.

int[] myArray = {1, 2, 3, 4, 5};
for (int element : myArray) {
    System.out.println(element);
}

Arrays.stream:

The Streams API introduced in Java 8 offers a functional approach to array iteration.

int[] myArray = {1, 2, 3, 4, 5};
Arrays.stream(myArray).forEach(System.out::println);

ListIterator:

Ideal for iterating backward through a List, providing more control over traversal.

List<Integer> myList = Arrays.asList(1, 2, 3, 4, 5);
ListIterator<Integer> iterator = myList.listIterator(myList.size());
while (iterator.hasPrevious()) {
    System.out.println(iterator.previous());
}

Iterating through objects

Using Map.Entry:

For iterating through key-value pairs in a Map, Map.Entry allows access to both the key and the value.

Map<String, Integer> myMap = new HashMap<>();
myMap.put("a", 1);
myMap.put("b", 2);
myMap.put("c", 3);

for (Map.Entry<String, Integer> entry : myMap.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}

Using Java Streams API:

Leveraging the powerful Streams API for concise and functional iteration through Map entries.

Map<String, Integer> myMap = new HashMap<>();
myMap.put("a", 1);
myMap.put("b", 2);
myMap.put("c", 3);

myMap.entrySet().stream().forEach(entry -> {
    System.out.println(entry.getKey() + ": " + entry.getValue());
});

Things to look out for

Immutable vs Mutable List

Understanding the distinction between immutable and mutable lists is crucial. An immutable list cannot be modified after creation, while a mutable list allows changes. Consider your use case and requirements when choosing between them.

Thank you for reading! I hope this information proves helpful.

1679. Max Number of K-Sum Pairs

Mohammed Shaikh — Mon, 12 Feb 2024 17:52:27 +0000

Intro

In this article, we will explore a problem and walk through various solutions. If you are looking for the solutions directly, feel free to scroll down to the respective sections.

Problem Statement

Summary

First thing we do is summarise the problem statement and remove all the fluff.

Find out how many combinations add up to `k`
The combinations have to be unique
The array is always going to be more than 1 in length and made up of positive integers
`k` will always be more than 1

With this summary, we can get started crafting our brute force solution for this problem. A lot of people start trying to find the most optimized solution. In the beginning(of your ds&A journey), it is better to first craft brute force and then optimize

Brute Force Solution

An easy way I have found that helps people come up with a solution is imagining how you would do it in real life. If you see the input and you were asked the question.

If someone had to do this in real life, these are the things we do:

pick element A (starting at the first) and check against all elements.
If there is a match(equals to K), we mentally add 1 to the count of operations
We can then set element A to the next variable
We will have to delete the elements at those index

Now we can start coding!!

First we have to build the logic for adding and checking each elements of the arr with others

const maxOperations =(nums, k) => {
    for(let i = 0; i < nums.length; i++){
        for(let j = i; j < nums.length; j++){
            if(nums[i] + nums[j] === k){
                console.log(nums[i], i, 'maxOperations', nums[j], j)
            }
        }
    }
}
maxOperations([3,1,3,4,3], 6)

We are comparing all elements with other elements and check if it equals k. When you run this code, you will notice it console.log 6 times even though the expected answer is 1.

That is because we did not handle the removal of elements from the array, so we basically are double/triple counting. Lets fix that.

What we have to do is remove the two elements from the logic. The simplest way to do that is making both the elements equal to something else. I will make those elements as NaN.

   nums[i] = NaN;
   nums[j] = NaN;

Lets put it all together with the counter logic.

const maxOperations = (nums, k) => {
    let counter = 0
    for (let i = 0; i < nums.length; i++) {
        for (let j = i + 1; j < nums.length; j++) {
            if (nums[i] + nums[j] === k) {
                counter += 1

                nums[i] = NaN;
                nums[j] = NaN;
            }
        }
    }
    return counter
};

The time complexity is O(N^2)

Alternative Solutions

There are different solutions that we can do that are more optimized.

Approach 1: Hash Table - Time: O(N)

function maxOperationsHashMap(nums, k) {
    const frequencyMap = new Map();
    let operationsCount = 0;

    for (const num of nums) {
        const complement = k - num;
        if (frequencyMap.has(complement) && frequencyMap.get(complement) > 0) {
            operationsCount++;
            frequencyMap.set(complement, frequencyMap.get(complement) - 1);
        } else {
            frequencyMap.set(num, (frequencyMap.get(num) || 0) + 1);
        }
    }

    return operationsCount;
}

Approach 2: Two Pointers - Time: O(N)

function maxOperationsTwoPointers(nums, k) {
    nums.sort((a, b) => a - b);

    let left = 0;
    let right = nums.length - 1;
    let operationsCount = 0;

    while (left < right) {
        const sum = nums[left] + nums[right];

        if (sum === k) {
            operationsCount++;
            left++;
            right--;
        } else if (sum < k) {
            left++;
        } else {
            right--;
        }
    }

    return operationsCount;
}

Approach 3: Count Frequencies with a Hash Table - Time: O(N)

function maxOperationsCountFrequencies(nums, k) {
    const frequencyMap = new Map();
    let operationsCount = 0;

    for (const num of nums) {
        frequencyMap.set(num, (frequencyMap.get(num) || 0) + 1);
    }

    for (const num of nums) {
        const complement = k - num;

        if (frequencyMap.has(complement) && frequencyMap.get(complement) > 0 && frequencyMap.get(num) > 0) {
            operationsCount++;
            frequencyMap.set(num, frequencyMap.get(num) - 1);
            frequencyMap.set(complement, frequencyMap.get(complement) - 1);
        }
    }
    return operationsCount;
}

Summary

All of the three solutions we talked about here are O(N). I just wanted to show the different ways to solve. It helps to know that in case there are variations to the problem.

Thank you for reading! I hope this information proves helpful.

Algorithms: Common Years Problem

Mohammed Shaikh — Tue, 23 Jun 2020 22:09:54 +0000

I wanted to write about an interesting question I faced in a technical interview:

Given an array of arrays containing birth years and death year of people find out the most common years amongst them.

 [[1901,1950],[1930,1960],[1973,2022]]

The steps I use to solve any algorithm problem:

Find out how I would do it manually.
Write them down as steps.
Translate into code.

1. Find out how I would do it manually.

The manual way would be to go through each set and remember the range.for ex, the first set is from 1901 to 1950. At the back of our mind, we can remember those years as occurring once, then we go on to the next set. We remember the next set so we can already see the overlap. The first two have been alive together from 1930 to 1950. Then, we move on to the third and last set and we can see that it does not overlap with the other two.

Few things to note. Firstly, we need to connect occurrences to years. Secondly, the years with the most occurrences are the maximum occurences.

2. Write them down as steps.

To solve this problem, we need to connect each year with the amount of occurences. Afterwards, we need to find the max occurence and find out all the years that have that.

I decided to use hash to connect{1901 => 1}.

3. Translate into code.

This is code version of the steps:

def findCommonYear(arr)
    years = {}
    arr.each do |year_set|
        start_year = year_set[0]
        end_year = year_set[1]
        while start_year <= end_year do
            puts start_year
            if years[start_year]
                years[start_year] += 1
            else
                years[start_year] = 1
            end
            start_year += 1
        end
    end
    if years.values.max != 1 
        max_common_count = years.values.max
    else
        return 0
    end
    max_common_years = []
    years.each do |key,value|
        if value == max_common_count
            max_common_years << key
        end
    end
    return max_common_years
end

puts findCommonYear([[1910, 1950], [1900, 1951], [1945, 2000]])

Animation with vanilla css

Mohammed Shaikh — Sun, 15 Mar 2020 02:55:21 +0000

Animation makes our app look a little exciting and it is very easy to do it with plain css. The first thing we need is the @keyframes css keyword. what that keyword does is that it lets us control an element on the dom. We can tell the dom to do a certain action in exact intervals. We measure intervals in percentages.

  @keyframes shake {
    0% { transform: translate(1px, 1px) rotate(0deg); }
    10% { transform: translate(-1px, -2px) rotate(-1deg); }
    20% { transform: translate(-3px, 0px) rotate(1deg); }
    30% { transform: translate(3px, 2px) rotate(0deg); }
    40% { transform: translate(1px, -1px) rotate(1deg); }
    50% { transform: translate(-1px, 2px) rotate(-1deg); }
    60% { transform: translate(-3px, 1px) rotate(0deg); }
    70% { transform: translate(3px, 1px) rotate(-1deg); }
    80% { transform: translate(-1px, -1px) rotate(1deg); }
    90% { transform: translate(1px, 2px) rotate(0deg); }
    100% { transform: translate(1px, -2px) rotate(-1deg); }
  }

The whole animation is considered 100%.If the change we want should happen in the beginning we put it at 0%. If we want it to be halfway through the animation, we put it at 50% and at 100%, if that is the last thing we want done. We started from the beginning(0%) and told the element to move 1px on the x-axis and 1px on y-axis and rotate 0 deg and so on and so forth.

The next thing we have to do is bind the function to an element.

#map:hover {
    /* Start the shake animation and make the animation last for 0.5 seconds */
    animation: shake 0.5s;

    /* When the animation is finished, start again */
    animation-iteration-count: infinite;
  }

I put an event listener on the map, so when someone hovers over it this css blocks get triggered. animation: shake 0.5s; There are three arguments on this line, first is the animation keyword, then it is the name of the function we wrote above and the length of how long it should run.A thing to note, the percentages are of the time we mention in this command. 50% in keyframes is 50% of 0.5s in our example.

There are many things possible with @keyframes. We could even change the colors programmatically

@keyframes colorChange {
  0%   {background-color: red;}
  25%  {background-color: yellow;}
  50%  {background-color: blue;}
  100% {background-color: green;}
}

We can use negative numbers to make it look like the animation was already playing and if leave out 0% and 100% it will automatically make those two points equal to the beginning state of the element and it will start and end the animation at the same state

Yay!! Now you know how to add animation using css. Hopefully it will bring as much joy to your projects as it did to mine

Scopes in Javascript

Mohammed Shaikh — Thu, 16 Jan 2020 13:51:20 +0000

There are 4 types of scopes in JavaScript. The global, function, block, and lexical scopes.

Variables in the global scopes can be accessed anywhere in the code. They are declared by not adding the variable declaration term (var, let, const) before the identifier.

function funcWithGlobalVariable(){
  globalVariable = “I am declared without the identifier”
}

function test2(){
  console.log(`${globalVariable} is the best`)
}
funcWithGlobalVariable()
test2()

We are declaring the variable in function test and access in test2. However, if we declare it as:

function funcWithGlobalVariable(){
  globalVariable = “I am declared without the identifier”
}

function test2(){
  console.log(`${globalVariable} is the best`)
}
funcWithGlobalVariable()
test2()

This would error out because the declaration and the invocation of the variable are in different scopes.

ReferenceError: bestMod is not defined

Variables in function scope exist inside the function. All variables that are declared inside the curly brackets, stay in the curly brackets. Continuing from the example above:

function test(){
  let bestMod = "mod3"
}

function test2(){
  console.log(`${bestMod} is the best`)
}
test()
test2()

let,const and var make the variable function scoped. The above code will give the same error as above.

Variables in block scope exists inside a block of code.

for(let i=0;i<10;i++){
   ...
}
console.log(i)//this will give an error

The "i" does not exist outside of the for loop, so the console.log line will return an error.

Last but not least, lexical scope. Lexical scope means that in the hierarchy of code, everything under the level of where it was declared can access the variable.

function test(){
  let bestMod = "mod3"
   test2()


    function test2(){
      console.log(`${bestMod} is the best`)
    }
}


test()

The above code will work because "bestMod" used in "test2" is declared in the function that is wrapping it. This scope was the hardest for me to remember coming from ruby where I would have to pass it in to the function for me to be able to access it.

In all of the four scopes, it is better to go from the lowest to the highest. It is always a good practice to keep the variables in block scope or function scope. Global scope, no matter how enticing it may be, is always to be avoided.

Pseudo coding

Mohammed Shaikh — Sun, 05 Jan 2020 18:15:44 +0000

What is pseudo coding?

Pseudo coding is writing down what you are about to code in plain english. It is an important part of programming, especially for those that are starting out and for programmers that are encountering hard problems. It is also a great way to deal with imposter syndrome.

A lot of problems seem overwhelming as a whole. When I had to make a fake facebook(https://kazam-inc.herokuapp.com/) for my mod 2 project. I was very nervous and I did not know if I could do it. When I broke everything down to small pieces, Alhamdulillah, It looked very easy.

I am going to start learning javascript in my bootcamp next week, so in anticipation of that. I first pseudo coded a simple app then I coded in javascript.

//Ask user some question
//save the user answer
//add the answer as a part of a sentence
//print the formatted sentence

It is important, when pseudo coding, to make each step very simple. A good test to see if the pseudo code is simple enough is that a child 8-11 yrs old can follow the steps and do the action in real life. Another thing to keep in mind is the fact that there should be no code in the pseudo code. After pseudo coding, now we can go step by step and google and write everything.

The first step is to ask the user for input.

prompt("Please enter your name", "");

The above line will prompt the user for their name. Now, we can move on to the next step in our pseudo code. We have to save the input to a variable.

const name = prompt("Please enter your name", "");
const age = prompt("Please enter your age", "");
const language = prompt("Please enter your programming language", "");

We are prompting the user for three different input and saving the input in three seperate variable. Now we can cross off the first two steps.

const formattedString = (`Hello ! my name is ${name} and I am ${age} year(s) old, the programming language I like is ${language}`);

The above code will format the string.

console.log(formattedString);

Last but not least the above code will print it to the user.

Many times people get overwhelmed by an issue they are tackling, especially when encountering a new language. However, if the problem is broken down into small steps and written down, It can helps us understand and solve any problems that we might encounter in a very efficient manner.

Python Calculator CLI App

Mohammed Shaikh — Sun, 29 Dec 2019 22:26:49 +0000

Before we start our calculator, It is always good practice to breakdown the steps that we would require to build it.

    -[]Welcome the user
    -[]Ask him to select an operation
    -[]Save that input
    -[]Ask him for the two numbers
    -[]Save those two numbers
    -[]make arithmetic operation functions
    -[]send the appropriate functions the number
    -[]Display the number back to the user

First on that list would be to welcome the user. Let's print a nice welcoming message

print('Hello! User. Welcome to The Calculator')

When we run our program, it will print our welcoming message. The next step is to ask the user to select an operation.

print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")

That 2/8 of the deliverables done. The next step is for us to receive input and save it to a variable.

print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")
operation = input("Enter choice(1/2/3/4): ")

The reason we did not just ask the user to input the operation name directly rather than the number is to avoid edge cases. If we tell the user to input the operation name, the possible inputs could be "add" or "aDD" or "Add" or "ADD". The more input, the more chance of an accidental typo that can break our program. For simple applications, it is better to restrict inputs to the bare minimum so we do not spend a large time formatting the input.
The next step on the list is to ask for the two numbers that we are going to work with.

print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")
operation = input("Enter choice(1/2/3/4): ")
num1 = input("Enter first number: ")
num2 = input("Enter second number: ")

We are asking for the numbers and saving it to two variables. One of the benefits of pseudo coding properly is that it becomes a good measurement of progress. Now we know we are more than halfway done because we have finished 5 out of the 8 steps

    -[x]Welcome the user
    -[x]Ask him to select an operation
    -[x]Save that input
    -[x]Ask him for the two numbers
    -[x]Save those two numbers
    -[]make arithmetic operation functions
    -[]send the appropriate functions the number
    -[]Display the number back to the user

The next step is to make the code able to do the operations.

def add(x, y):
  print(f'{x} + {y} = {x+y}')
# This function subtracts two numbers 
def subtract(x, y):
  print(f'{x} - {y} = {x-y}')
# This function multiplies two numbers
def multiply(x, y):
  print(f'{x} * {y} = {x*y}')
# This function divides two numbers
def divide(x, y):
  print(f'{x} / {y} = {x+y}')
print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")
operation = input("Enter choice(1/2/3/4): ")
num1 = input("Enter first number: ")
num2 = input("Enter second number: ")

We made 4 functions for each of the arithmetic operations. Whatever the user chooses we can send the numbers to that function and it will take care of it for us.The next step is to direct the numbers to the appropriate function.

def add(x, y):
  print(f'{x} + {y} = {x+y}')
# This function subtracts two numbers 
def subtract(x, y):
  print(f'{x} - {y} = {x-y}')
# This function multiplies two numbers
def multiply(x, y):
  print(f'{x} * {y} = {x*y}')
# This function divides two numbers
def divide(x, y):
  print(f'{x} / {y} = {x+y}')
print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")
operation = input("Enter choice(1/2/3/4): ")
num1 = input("Enter first number: ")
num2 = input("Enter second number: ")
if choice == '1':
   add(num1,num2)
elif choice == '2':
   subtract(num1,num2)
elif choice == '3':
   multiply(num1,num2)
elif choice == '4':
   divide(num1,num2)

The if statements would direct each of the 4 inputs to its appropriate function. If the user wants to add, they will input 1 and it would hit the first condition. The first condition would call and pass the number to the add function. The add function will display the added number in a formatted answer.

The above code will work , but it is messy. We need it to organize it better. Readability is very important for code. It is possible to add comments to organize and make it more readable, but good function and variable names and proper spacing does a better job.

def add(x, y):
  print(f'{x} + {y} = {x+y}')

def subtract(x, y):
  print(f'{x} - {y} = {x-y}')

def multiply(x, y):
  print(f'{x} * {y} = {x*y}')

def divide(x, y):
  print(f'{x} / {y} = {x+y}')

print('Hello! User. Welcome to The Calculator')
print("Pick an operation(1-Add)(2-Subtract)(3-Multiply)(4 - Divide)")

operation = input("Enter choice(1/2/3/4): ")
num1 = input("Enter first number: ")
num2 = input("Enter second number: ")

if choice == '1':
   add(num1,num2)
elif choice == '2':
   subtract(num1,num2)
elif choice == '3':
   multiply(num1,num2)
elif choice == '4':
   divide(num1,num2)

That is the end of the tutorial. Hopefully everyone that reads it enjoys it as much as i enjoyed writing it.

MVC

Mohammed Shaikh — Tue, 17 Dec 2019 15:59:22 +0000

MVC
What is M.V.C?
MVC (Model-View-Controller) is a way to structure a web-app folder where the model deals with the backend, the view deals with the front end, and the controller deals with connecting everything. A common example that is given for MVC is the restaurant example. The chef (Model) creates food (instances of a class) and manages the inventory (database). The waiter (Controller) will take the order (request) from the customer (View) and take it to the chef (Model) and then it will take the order (request) back to the customer (View). The customer (View) can make the order (request).

What is Model?
Model is the data management system of the program. Model also will contain the majority of the logic. The rails command to generate a model would be:

rails g model (Model name) (table column name):(column data type)

If we were to code the MVC example, we would do

rails g model Restaurant name:string address:string

.The above command would output

invoke  active_record
create    db/migrate/20191216200109_create_restaurants.rb
create    app/models/restaurant.rb

The models/restaurant.rb file is where your restaurant class will go and the db/migrate/20191216200109_create_restaurants.rb file is where your data table goes. Combined, they make the model in MVC. For more information on generators https://lmgtfy.com/?q=Rails+generators.

What is the view?
View is the frontend part of your code that will contain code that generates what your user will see. If we continue the example from above, we could put:

create  app/controllers/restaurants_controller.rb
route  get 'restaurants/new'
get 'restaurants/create'
get 'restaurants/edit'
get 'restaurants/update'
get 'restaurants/destroy'
get 'restaurants/index'
get 'restaurants/show'
      invoke  erb
      create    app/views/restaurants
      create    app/views/restaurants/new.html.erb
      create    app/views/restaurants/create.html.erb
      create    app/views/restaurants/edit.html.erb
      create    app/views/restaurants/update.html.erb
      create    app/views/restaurants/destroy.html.erb
      create    app/views/restaurants/index.html.erb
      create    app/views/restaurants/show.html.erb
      invoke  helper
      create    app/helpers/restaurants_helper.rb
      invoke  assets
      invoke    scss
      create      app/assets/stylesheets/restaurants.scss

The controller command creates the 7 RESTful routes for restaurant and creates a view file and a controller method for each route. It is a very useful tool. There is one drawback to it, though. It creates a view file for create, update, and destroy. As soon as the command creates those files, you may have to delete it.

What is the controller?
Controller is the code that connects both side, Model and View. When the request is made by browser, it first goes to the Controller, then it is sent to Model or View depending on what is needed for that request. The above command created the Controller for us already.

class RestaurantsController < ApplicationController
  def new
  end

  def create
  end

  def edit
  end

  def update
  end

  def destroy
  end

  def index
  end

  def show
  end
end

When the user searches a url on our website, it will come to one of these methods. For example, if the user searches the home page, it will go to the index method. The index method will take the request and do whatever logic we put in that method and then send it off to the Model if needed. if not, then it will send it off to the user the correct View file.

Model, View, and Controller is a way of applying the concept of separation of concerns, where every piece of code is just responsible for one thing. If there is a need to debug or update, we would know exactly where everything is, so it would make our lives easier for us. MVC also allows teams to work together on the same app without git conflicts