DEV Community: lusayo_ny

More Thoughts on My Mental Model for Understanding Data Structures and Algorithms

lusayo_ny — Sat, 09 Aug 2025 14:48:51 +0000

As the title states, this article is just about my personal thoughts and my mental model on learning and teaching data structures and algorithms. I've written a blog post that covers the same article here https://projectsayo.hashnode.dev/leap-before-you-look-a-slightly-more-refined-approach-to-algorithmic-techniques[https://projectsayo.hashnode.dev/leap-before-you-look-a-slightly-more-refined-approach-to-algorithmic-techniques](https://projectsayo.hashnode.dev/leap-before-you-look-a-slightly-more-refined-approach-to-algorithmic-techniques). Do feel free to visit the actual blog and maybe subscribe to my newsletter if you're interested in this kind of content, but it's not necessary for you to do so. Hope you enjoy the read.

Algorithmic Techniques In a NutShell

1. Fundamental Operations

These are the basic, atomic actions you perform on data. Think of them as the verbs of algorithms. hey fall into three major categories: Navigation, Querying, and Computation. Let's get into a bit more detail:

a. Navigation 🧭

The process of traversing a data structure to visit its elements. This is about movement and access.

i. Linear Navigation

Moving sequentially through elements.

1. Single-Pointer

Using a single index or reference to move one element at a time (e.g., for loop on an array).

2. Multi-Pointer

Using two or more indices or references to move through the data simultaneously. A classic example of this is the two-pointer technique used in arrays to examine them from opposite directions for a specific condition. Another example is the use of fast and slow pointers in a linked list to detect a cycle or find the middle element. Other examples include low and high indices in a binary search.

ii. Non-Linear Navigation.

Moving through hierarchical or networked structures.

1. Hierarchical Traversal

Moving between a parent and its children (e.g., traversing a tree). This is the underlying principle for algorithms like Depth-First Search (DFS) and Breadth-First Search (BFS), which use auxiliary data structures to manage the order of traversal.

2. Network Traversal

Moving between interconnected nodes in a graph. The key here is that a node can have multiple neighbors without a strict parent-child relationship.

Examples: Algorithms like Breadth-First Search (BFS) and Depth-First Search (DFS) are strategies that use a queue or stack (auxiliary data structures) to manage the exploration order, ensuring all nodes are visited even in the presence of cycles.

b. Querying 🔎

The act of asking a question about the data and getting an answer about the structure of the ADT itself, often a boolean or a specific value.

Examples: contains(element), isEmpty(), size(), min(), max(), elementAt(index), subset(start:finish). These are operations that inspect the data without changing it.

c. Computation ⚙️

The process of deriving a new value or a new data structure from the existing data. We can break this down based on how the computation's logic is determined.

i. Primitive Computation

This is the most foundational form of computation. It uses the computer's circuitry to perform basic mathematical operations and logical comparisons. All other forms of computation are built on these primitives. From the perspective of a programmer, it's things the computer just knows how to do, it's low level, and we don't question it.

Examples: Arithmetic operations (+, -, *, /), logical operations (AND, OR, NOT), and comparisons (=, <, >): i.e. 1 + 1 = 2, True AND False = False, etc.

ii. Algorithmic Computation

This is a computation technique where we as programmers define a fixed, predetermined set of steps to produce a result. The logic is straightforward and doesn't involve a complex decision-making process at each step.

Examples: sum(array), average(array), merge(list1, list2). The instructions are clear and the same every time.

iii. Heuristic Computation

This is a computation techniques that involves a navigating a data structure and executing some decision-making process at each step to determine whether or not to change the result of the computation. The algorithm doesn't just follow a fixed script and gives a deterministic answer; it makes a choice based on a specific rule or heuristic. General subcategories of this include:

1. Greedy algorithms.

This is a type of heuristic computation that, at each step, makes the choice that looks best at the moment, without considering the global outcome. A good example is Dijkstra's algorithm for finding the shortest path; at each step, the algorithm's heuristic is to choose the unvisited node with the smallest known distance from the starting node. This is a locally optimal choice that is assumed to lead to the overall shortest path. Another example is the sum of consecutive positive differences solution to determine the maximum possible profit in the buy-low sell-high problem.

2. Simulated Annealing 🌡️

This heuristic is inspired by the metallurgical process of annealing, where a metal is heated and slowly cooled to reduce defects.

How it Works: The algorithm starts with a random solution and iteratively makes small, random changes. It always accepts changes that improve the solution. However, it also accepts changes that worsen the solution with a certain probability, which decreases over time (like the cooling process). This "worse-case" acceptance allows the algorithm to escape local optima and explore a wider range of possible solutions.

3. Genetic Algorithms 🌱

This heuristic is inspired by the process of natural selection and evolution.

How it Works: The algorithm maintains a "population" of potential solutions. In each generation, it selects the best-performing solutions, which then "reproduce" (combine) and "mutate" (randomly change) to create new, diverse solutions for the next generation. This process continues until a satisfactory solution is found.

2. Implementation Strategies for Querying, Computation, and Navigation

These are the actual strategies that we use when writing implementations for algorithms. Think of them as high-level strategies, with some well-known techniques for performing queries, computing values, or navigating a data structure.

There are generally three techniques to implementing complex algorithms on data structures: Simple operations using stored properties of the data structure, using precomputation, and using iterative refinement. Let's get into a bit more detail about what we mean:

a. Stored properties

This strategy leverages the data structure's known pre-defined properties to perform a query or computation.

Example: The size of an array, the head of a linked list, the "next" pointer of a linked list node, etc. Also getting the pointer for a particular index of the array using pointer arithmetic could be an example (because we know the array's size, and we know the index of the element we want, and the size of each individual element slot, so we can calculate the pointer of the element we want to fetch).

b. Precomputation ✨

The strategy of navigating through your data structure in an initial pass to make a new, different, and optimized ADT that you will then use for further processing.

Example: Creating a hash table from a list of keys to enable near-constant-time queries. Another example is building a prefix sum array to allow for constant-time range sum queries. The act of creating the new data structure is the precomputation. Intervals also fall within this category. The intervals problem is a class of problems often solved by sorting the intervals (a form of precomputation) and then iterating through them to merge or find overlaps.

c. Iterative Refinement 🔬

This is a problem-solving strategy where you repeatedly apply computations on small portions of your dataset to narrow down a solution. It only operates on the ADT in question and uses some data structure to store intermediate results. It falls into two major implementation categories:

i. Iterative Method (Looping)

This is where you use a standard loop to repeatedly refine the solution. Intermediate results or the state of the algorithm are stored explicitly by you in standard variables or data structures like arrays, queues, or hash maps. This approach gives you full control over the state management.

Example: A Binary Search implemented with a while loop. The intermediate results are just the low and high variables, which you explicitly update in each iteration. Another example is a sliding window where the intermediate results are stored in a simple primitive variable.

ii. Recursive Method

This technique solves a problem by breaking it down into smaller, similar subproblems. Instead of using a loop, it relies on repeated function calls to manage the state. The intermediate results for each function call are automatically stored on the call stack, a stack-based data structure that is managed by the system.

Example: A recursive implementation of Binary Search or a Depth-First Search (DFS) traversal. Each function call pushes a new frame onto the call stack, effectively caching the state of that particular subproblem.

The 16 Common Interview Questions Explained Using This Mental Model

Now that we've gotten this far, we can try to apply this mental model to think about the 16 categories of common data structures and algorithms questions in interviews.

Arrays, Strings, and Linked Lists

These are your foundational data models. Their primary operations are Linear Navigation (single-pointer, multi-pointer) and Querying (e.g., elementAt(index), isEmpty()).

Stacks and Queues

These are abstract data types with specific constraints on access. Their operations (push, pop, enqueue, dequeue) are a form of limited Linear Navigation.

Hash Maps and Hash Sets

These use Precomputation (hashing) to enable extremely fast Querying (contains, get) and Computation (insert, remove).

Trees and Graphs

These are the ADTs that are the primary subject of Non-Linear Navigation (hierarchical and network traversal). Algorithms like DFS and BFS are the strategies that implement this navigation.

Sorting Algorithms (e.g., Merge Sort, Quick Sort)

These are examples of Computation. They take an unsorted data structure and produce a new, sorted one. The underlying process often uses Multi-Pointer Navigation and Precomputation (e.g., Merge Sort splits the list into halves, which is a form of precomputation).

Binary Search

This is a classic example of Iterative Refinement. It uses Multi-Pointer Navigation and Querying to repeatedly reduce the search space by half.

Recursion

This is a special programming technique for implementing algorithmic strategies like Iterative Refinement and Non-Linear Navigation. It enables a solution by breaking a problem down into smaller, similar subproblems.

Instead of explicitly managing state with a loop, recursion relies on the call stack, a system-managed stack-based data structure, to implicitly cache intermediate results.

i. Application of Recursion in Iterative Refinement

Recursion is a method for implementing the Iterative Refinement strategy. It solves a problem by repeatedly applying a function to smaller portions of the dataset.

Example: A recursive Binary Search is an example of iterative refinement. The search space is continually narrowed, and the state of each subproblem (the low and high indices) is implicitly stored on the call stack.

ii. Application of Recursion in Non-Linear Navigation

Recursion is a natural and common way to implement Non-Linear Navigation on hierarchical data structures.

Example: A recursive Depth-First Search (DFS) uses recursion to traverse a tree or graph. The call stack manages the path and allows the algorithm to backtrack to previous nodes, which is the core of DFS.

Heaps

Heaps are a great example of Precomputation. Building a heap from an array is a precomputation step that enables a fast Query (peek) and a specific Computation (extractMin).

Prefix Sums and Intervals

Prefix Sums are a perfect example of a Precomputation technique to build an intermediate array for future queries. Intervals are also a good example of precomputation that uses a combination of sorting (another precomputation) and multi-pointer navigation techniques.

Two-Pointer and Fast-and-Slow Pointer Techniques

These are classic examples of multi-pointer navigation for linear data structures. Both techniques use two or more indices or references to traverse the data simultaneously.

a. Two-Pointer Technique 🤝

This is a general technique often used on indexed data structures like arrays or strings. The pointers can move in the same direction (e.g., to find a subarray) or opposite directions (e.g., to find a pair of elements that meet a certain condition).

b. Fast-and-Slow Pointer Technique 🐇🐢:

This is a specialized variation typically used on pointer-based data structures like linked lists. The pointers move at different speeds (e.g., one moves two steps for every one step of the other). This speed difference allows them to be in different positions relative to each other after the same number of iterations. It's particularly useful for solving problems that don't require knowing the total length of the list, such as detecting a cycle, finding the middle element, or finding the k
th node from the end.

Sliding Windows

The Sliding Window technique fits neatly into Iterative Refinement because it's a looping method that repeatedly applies computations on a small, moving portion of a dataset.

Dynamic Programming.

This is a powerful form of Precomputation and Iterative Refinement. It involves solving a problem by breaking it down into subproblems and storing the results of these subproblems in an intermediary data structure (often an array or hash map) to avoid re-computation.

Greedy Algorithms.

A greedy algorithm is a great example of a Heuristic Computation. It's a strategy that makes a locally optimal choice at each step while navigating a data structure, with the hope of finding a globally optimal solution.

This strategy relies on a combination of fundamental operations:

Querying: It heavily uses querying to evaluate the available options at a given state (e.g., finding the minimum or maximum element, or the cheapest edge).

Computation: It performs a computation to make the optimal choice based on a specific heuristic.

Backtracking.

This is a strategy that uses a form of Non-Linear Navigation. It explores a search space by trying to build a solution incrementally. If a path leads to a dead end, it "backtracks" to a previous state and tries a different path. This is often implemented with recursion and a stack (a form of Precomputation with an auxiliary data structure).

Leap Before You Look - An Alternative Mental Model to Data Structures and Algorithms

lusayo_ny — Sat, 09 Aug 2025 04:21:26 +0000

Like the title says, this article is going to be about an alternative mental model to learning about and possibly teaching data structures and algorithms. The reason I'm writing it is out of a personal gripe of mine, so allow me to tell you a bit about myself first. If you want to skip that though, you can go sthreat to “The Mental Model”.

Like many developers in today's landscape, I did not go through a formal education in computer science. I went to college for management information systems for a few years, barely did any math and/or theoretical programming classes, and was thrust into the world of systems administration. After about 2 years of that, I got laid off and decided instead of looking for another job in that field, I'd focus on trying to do what I always wanted to do - code for a living. I coded everyday, picked up django and react, applied for as many jobs as I could and after about 8 months, I finally got myself a job. After about 4 years of basically hovering around the same level in terms of salary, I wanted to get a better job, but found that the types of jobs that paid what I wanted to be paid required an interview process that I dreaded - what people today would call the "FAANG interview." Basically, an interview process that involves a good understanding of data structures and algorithms which I've always hesitated to really pick up.

When you're not formally trained, data structures and algorithms can be a very intimidating topic. Sure, there's lots of materials to learn online, and lots of free courses and books that offer university-level courses on them. However, that's kind of the problem - that they try to provide "university-level" style teaching, when not everyone needs to learn them in a university context.

For the working man (or woman) with limited time who last cracked open a math textbook half a decade ago, a more intuitive, get-into-details-later approach is necessary to introduce data structures and algorithms. Basically we need to "leap" into developing an intuition for solving problems using data structures and algorithms before spending time "looking" at how to analyze or even design them.

To this end, as I was studying data structures and algorithms for myself, I found I've developed a bit of a mental model that allows me to think about data structures and algorithms in a way that I think makes them more intuitive to understand. And I'm writing this article to share that approach to anyone who might be interested.

The Mental Model

For me, it helps to look at data structures and algorithms using a conceptual framework that I'd like to call the Index-Pointer approach. It's a fun little re-classification of the concepts related to the study of data structures and algorithms. Basically, every concept related to data structures can be organized starting from the concept of indexes and pointers, and we’ll build on these definitions.

The mental model I have organizes understanding data structures and algorithms in three phases:

Foundational Data Models

Abstract Data Types

Algorithmic Techniques

These three serve as the building blocks for the way I understand data structures and algorithms and the way that I would teach someone if I had to tutor them. Let's get into what each of these actually mean.

Foundational Data Models

So first things we need to define what exactly is a "Data Structure". For my mental model, a "Data Structure" is a way of grouping related items in a way a computer can understand.

There are fundamentally two ways of grouping related items, which is what I mean when I say "Foundational Data Models". These data models are:

a. Index-based data models - A data model where you can know its exact size without looking at the data. You can use the data model’s preconfigured size, and known properties about its elements to infer the position of its elements.

A good example is the number of seats on a plane. You know exactly how many there are before you know how many people are actually on the plane because the plane itself is designed to have a fixed number of seats.

b. Pointer-based data models - A data model where you do not know its exact size until you look at all the elements in the data model. You can only use the elements themselves to infer the positions of other elements.

A good example is the number of people in, say, two generations of a family tree. You cannot know the number until you quantify how many children and siblings each individual member has. Based on those two core data models, we can then talk about the traditional data structures that we know of.

Abstract Data Types

Now, based on those two core data models, we can now start defining abstract data types.

Abstract data types are basically representations of a group of items that have logical constraints on the way the items or ordered and a contract for how to access and manipulate their individual elements.

They are independent of the actual data model that's used to implement them. Of these, we have the examples:

Array

In normal computer science, maybe this isn't considered an ADT, but for this framework it is. An array is an ADT that defines the contract for a fixed-size collection of elements, where each element is identified by an index.

size() -> Get the number of elements in the array.

insertAt(index, element) -> Insert an element at a specific index. This operation may replace an existing element.

elementAt(index) -> Retrieve the element at a specific index.

removeAt(index) -> Remove the element at a specific index.

Hash Map A Hash Map is an ADT that defines the contract for a collection of key-value pairs. It uses a hashing function to map keys to specific locations, allowing for very fast insertion and retrieval.

size() -> Get the number of key-value pairs stored in the map.

insert(key, value) -> Insert a key and its associated value into the map. If the key already exists, its value is updated.

get(key) -> Retrieve the value associated with a specific key.

remove(key) -> Remove a key and its associated value from the map.

containsKey(key) -> Check if a given key exists in the map.

isEmpty() -> Check if the map has any key-value pairs.

Stack An ADT that defines the contract for a collection of elements with a Last-In, First-Out (LIFO) access pattern.

push(element) -> Add an element to the top of the stack.

pop() -> Remove and return the element at the top of the stack.

peek() -> Return the element at the top of the stack without removing it.

isEmpty() -> Check if the stack is empty.

Queue An ADT that defines the contract for a collection of elements with a First-In, First-Out (FIFO) access pattern.

enqueue(element) -> Add an element to the back (or tail) of the queue.

dequeue() -> Remove and return the element from the front (or head) of the queue.

peek() -> Return the element from the front of the queue without removing it.

isEmpty() -> Check if the queue is empty.

Linked List An ADT that defines the contract for a sequence of elements where each element points to the next one. This ADT can be implemented using either a singly or doubly linked list model.

insertFirst(element) -> Add an element to the beginning of the list.

insertLast(element) -> Add an element to the end of the list.

removeFirst() -> Remove and return the element at the beginning of the list.

removeLast() -> Remove and return the element at the end of the list.

size() -> Get the number of elements in the list.

isEmpty() -> Check if the list is empty.

Tree An ADT that defines the contract for a hierarchical data structure with a root node and child nodes. A tree has no cycles and a single path between any two nodes.

insert(element) -> Add an element to the tree in the correct position based on its value (for a Binary Search Tree) or a specific constraint.

remove(element) -> Remove an element from the tree.

search(element) -> Find and return a node containing the specified element.

traverse() -> Visit all nodes in the tree in a specific order (e.g., in-order, pre-order, post-order).

Graph An ADT that defines the contract for a collection of nodes (vertices) and the connections (edges) between them. Unlike a tree, a graph can contain cycles.

addVertex(vertex) -> Add a vertex to the graph.

addEdge(from, to) -> Add an edge connecting a from vertex to a to vertex. This can be a directed or undirected edge.

removeVertex(vertex) -> Remove a vertex and all associated edges from the graph.

removeEdge(from, to) -> Remove the edge connecting the from and to vertices.

hasPath(from, to) -> Determine if a path exists between two vertices.

Heap A Heap is an ADT that defines the contract for a specialized tree-based data structure where the parent node is either always greater than or equal to (a Max-Heap) or less than or equal to (a Min-Heap) its children.

The heap is special because its underlying logical structure as a "complete" binary tree allows it to be efficiently implemented using an index-based data structure, like an array, even though its conceptual contract is pointer-based.

insert(element) -> Add an element to the heap and rebalance it.

peek() -> Return the root element of the heap (the maximum in a Max-Heap or the minimum in a Min-Heap) without removing it.

extractMax() or extractMin() -> Remove and return the root element of the heap, then reorganize the heap to maintain the heap invariant.

isEmpty() -> Check if the heap has any elements.

size() -> Get the number of elements in the heap.

build(array) -> Create a heap from an unsorted array of elements in an efficient manner.

In addition to those above, we also have definitions for other ADTs which add additonal constraints. For example, a Binary Tree is an ADT that basically has the contract of a Tree but also enforces that each node can have at most two children. We can make definitions for AVL Trees, Red-Black Trees, and so on and so forth. I don't want to get bogged down here, but the key idea is to build upon this. So let's move on to the third part of this mental model.

Algorithmic Techniques

In this mental model, we can define algorithmic techniques as an ordered set of computational operations we perform directly on the underlying data of an Abstract Data Type to produce a new value.

So that this definition holds, I like to think of it as all abstract data types are immutable. So even when you "sort an array" for example, you're not sorting the original array, you're creating a new sorted array from your original array. Just for the purposes of the mental model, though I'm open to hear any criticism on this.

Algorithmic techniques broadly fall into four categories.

Navigation Techniques
Navigation is the process of moving through a data structure to access its elements. This is the most fundamental of all techniques.

Examples:

Array Traversal: Iterating through an array using a for loop from index 0 to n-1. This is a classic example of index-based navigation.

Linked List Traversal: Starting at the head of a linked list and following the next pointers until you reach the end. This is a primary example of pointer-based navigation.

Tree Search: Performing a Depth-First Search (DFS) or Breadth-First Search (BFS) to visit every node in a tree or graph.

Precomputation Techniques
Precomputation is doing work ahead of time to make future operations faster. It's an investment of time now for a return of speed later.

Examples:

Sorting: Arranging the elements of a list or array in a specific order. Once sorted, operations like searching become much faster.

Hashing: Creating a hash table from a list of items to allow for near-constant-time querying. - Prefix Sum Array: Creating a new array where each element stores the sum of all elements before it in the original array. This allows you to compute the sum of a range in constant time.

Querying Techniques
Querying is the act of answering a question about the underlying data. The answer is typically a boolean (true/false) or a specific value or range of values.

Examples:

contains(element): Checking if a data structure holds a specific element.

find(element): Locating and returning the index or position of an element.

isEmpty(): A query that checks if the data structure has any elements.

min() or max(): Finding the smallest or largest value in a data structure.

Computation Techniques
Computation is the process of creating a new value from the existing data. This can be a simple calculation or a complex aggregation.

Examples:

sum(): Calculating the sum of all elements in an array.

average(): Computing the mean value of a set of numbers.

transpose(matrix): Creating a new matrix by flipping the rows and columns of an original.

merge(list1, list2): Creating a single new list by combining the elements of two lists.

Each "algorithm" is essentially a collection of navigations, precomputations, queries, and/or computations that you perform on abstract data types until you produce the value you want.

Common Algorithms Using the Index-Pointer Mental Model

Here are some well-known algorithms kind of broken down using this mental model:

Binary Search Underlying Data Model: Index-based (most typically an array, could be a hashmap too).

Techniques:

Precomputation: The algorithm assumes the array is already sorted. If not, sorting is a necessary precomputation step.

Navigation: It uses two "pointers" (low and high indices) to navigate the array. The pointers are not physically stored in the data model but are computational artifacts.

Querying: It performs a query at the midpoint of the current search space (is the target greater than the middle element?).

Computation: Based on the query, it computes the new values for low or high to reduce the search space.

Breadth-First Search (BFS) BFS is a traversal algorithm that finds the shortest path between nodes in an unweighted graph or tree.

Underlying Data Model: Pointer-based (nodes and edges).

Techniques:

Data Structures: It uses a Queue ADT to manage the nodes it needs to visit. This ADT is often implemented with a pointer-based data model (a linked list).

Navigation: It starts at a source node and navigates to all of its immediate neighbors, then all of their neighbors, and so on.

Querying: It performs a crucial query: has this node already been visited? to avoid cycles.

Precomputation: It precomputes a visited set to store nodes it has already processed, which is a form of caching.

Merge Sort Underlying Data Model: Index-based (the arrays).

Techniques: Precomputation: The algorithm's core is a recursive precomputation. It continuously splits the original array and "precomputes" sorted subarrays until it reaches the base case of a single element.

Computation: The core of the algorithm is the merge function, which takes two sorted subarrays and creates a brand new, single sorted array from them. It computes a new value from two existing values.

Navigation: It performs navigation within two separate subarrays simultaneously, using two pointers to compare and select elements for the new, merged array.

Summary

So yeah, that is the gist of the mental model for algorithms that I've been cooking up in my head. I hope this has been an interesting read for you. I'm still learning more about data structures and algorithms, and while I'm on my journey, I gravitated towards this taxonomy as a better way of being introduced to data structures and algorithms if you want to understand what exactly is going on with algorithms before you start thinking about time-complexity and space-complexity and all that stuff.

If you've made it this far, thank you very much. I'd love to hear your feedback on this. I'm planning on turning this mental model into an ebook or a website, and would love to hear any feedback if you've got any criticisms or would like to collaborate. If you like the article please also give it a like at my blog: https://projectsayo.hashnode.dev/leap-before-you-look-a-mental-model-for-data-structures-and-algorithms

Have a great weekend!

An Intuition-First Approach to Learning and Teaching Data Structures and Algorithms

lusayo_ny — Sat, 09 Aug 2025 04:13:42 +0000

As the post says, I've written an article on an alternative approach to learning about data structures and algorithms that may come more intituively to some (it came more intutively to me). I tried to post the full article here, but I keep running into some JSON error so I assume it's too long. I'll give a brief summary and encourage you to read the rest on my blog page if you're interested.

So basically, I've developed a personal mental model for approaching data structures and algorithms that's divided into the three sections:

Foundational Data Models
Abstract Data Types
Algorithmic Techniques

Foundational Data Models are basically indexed data structures, and pointer based data structures. Every other data structure that you would learn about falls under Abstract Data Types. And I've also classified the algorithmic techniques we use for DSA questions into four broad categories.

If this sounds like something you're interested in, here's the link to my blog post: https://projectsayo.hashnode.dev/leap-before-you-look-a-mental-model-for-data-structures-and-algorithms.

Please provide feedback if you found the article interesting.

Thank you.

Why You Should Care About Sneaky Elon Buying Twitter Out

lusayo_ny — Tue, 19 Apr 2022 13:15:44 +0000

It’s 19 April, 2022. The Web3 cults are growing, NFT enthusiasts are fighting intense bidding wars to see who goes broke the fastest, a sovereign country is being invaded, Trump still hasn’t lost the election, and a sneaky billionaire has pulled the Twitter rug out from under the public’s bottom. Being swept up in the times yourself, it might be difficult to detach yourself from your everyday grind to see what events deserve your attention and why. Good thing you don’t have to, because I’ve done that for you. I took a closer look at what’s currently happening with the social media giant, Twitter. I wanted to find out if the events surrounding Twitter could impact regular developers, tech companies that rely on it, or content creators that are within the tech space, and these are my conclusions so far.

What Happened?

Since the 31st of January, sneaky Elon Musk has been chipping off and stashing twitter stocks in little batches almost every single day. Regardless of why he did so in such a shady manner, as of 4th April, he became the largest shareholder of Twitter with a 9% stake. That automatically granted him a seat on the board. One of his first moves in his newfound role was to initiate a massive hostile take-over that’ll make him 100% owner of Twitter. Classic Elon Musk.

His motivations seem to be purely political and ethical in nature, citing that Twitter’s moderation of hate-speech is somehow a war on free-speech. I’m not inclined to comment on that. The key takeaway is that Musk wants to revise Twitter as a platform to make it more conformed to his definition of free-speech, and that is the driving factor behind his policy changes, which we’re about to get into.

I’ve combed through the tweets and various news outlets to find if there’s anything remotely relevant to developers that make use of Twitter’s APIs, content creators that use it to promote their brands, or business models that rely on it, and I’ve only really found 3 potential policy changes that matter

Why Should It Matter to You?

1.Making Twitter’s Algorithm Public

In a poll that sneaky Elon conducted on his Twitter account, he asked his followers if Twitter’s algorithm should be made public and open source. 82.7% of his followers who voted on the pole said yes, which should fairly express the will of Twitter users in general seeing as how Elon Musks’s account is the 8th most popular account on Twitter coming out at around 81M followers.

Whether making Twitter’s algorithm open source would affect the tech world as much as similar moves done by NaN with the 3D editing software Blender, Twitter with Bootstrap, or Meta (Facebook) with React, is actually very questionable though. First of all, most of the people who agreed to make the algorithm open source wouldn’t be able to understand it in the first place. And second of all, Twitter doesn’t really have a single “algorithm”.

Anyone with programming knowledge would know that an “algorithm” is really just a computational and/or mathematical approach taken to solve a very specific computing problem. They usually deal with the methodology to handle, recognize, classify, and optimize data, not business goals.

The “algorithm” that people want made public is the one that Twitter uses to show content to its users. The only issue is, Twitter does not use a single “algorithm” to make sure content gets to it’s users. It employs a multitude of various heuristics, algorithms, and artificial intelligence to make sure content gets to particular users based on their locations, friends, search history, tags explored, interests, likes, retweets, etc. It would be a herculean read for any single developer, and it wouldn’t really serve a clear purpose that isn’t academic or corporate. If you add to that, the fact that those “algorithms” are really only functional within Twitter’s ecosystem, Twitter would have to expose some implementation details about their platform to make sure readers get the right context.

In my opinion, I would say not a lot of developers would be interested in this reveal at all, but Twitter’s competitors, other tech giants, and venture capitalists would certainly dig out a business model from it. However, if you’re that type of developer, maybe it’ll be like reading a good book.

2. Reducing the number of bots

This one deserves much more concern from the broad spectrum of developers directly. Elon Musk has suggested intensifying procedures that Twitter uses to detect and remove bots. He cited that bots are the biggest problem with Twitter, and that he would employ stricter authentication, verification, and screening of Twitter accounts to determine which ones should be removed.

If you’re a developer that has or relies on Twitter bots to offer some sort of service, this could impact the way you have to write your code. You could also have to modify the way your bot makes use of Twitter to make sure it isn’t flagged.

Potentially this might lead to some code-base rewrites for companies whose businesses are centered around twitter content generation and engagement or for developers who just like making bots in general. You might have to re-factor in a few months, so keep a heads up.

3. Removing ad-based revenue

This one doesn’t affect developers directly, but it does change the ecosystem of twitter as a whole for entrepreneurs and content creators in any industry. That of course includes software and tech. For Twitter to remove ad-based revenue would probably mean the end of sponsored tweets, and that could significantly impact some businesses.

This is a major flag that entrepreneurs and content creators have to address.

Finishing Thoughts?

All in all, this is just my assessment of the situation given what I can see. On top of influencing Twitter developers, content creators, and business owners, I feel like this purchase could prove to be politically shaking as well. What are your thoughts about what might happen if Elon Musk successfully buys Twitter out?

P.S: I'm new at content creation, so criticism is welcome. If you're interested in my coverage, more content on my new blog: https://cassaden.com/blogs/curated.

React JS Isn’t Actually A Web Framework But Why Are There So Many Others?

lusayo_ny — Mon, 18 Apr 2022 23:31:05 +0000

There’s a running joke among the developer community that for every tree that’s planted in Australia, a new JavaScript framework is born. Okay, I made that up, but it’s true that there’s a widespread proliferation of JavaScript frameworks, more so than with any other programming language. Stack Overflow’s annual developer surveys for 2021 established that JavaScript frameworks dominated the most wanted and most loved sections in the web development space yet again:

Nine of the eighteen frameworks cited in that poll are written in JavaScript, representing the fact that 50% of web developers would rather use various JavaScript frameworks than any other programming language. That’s an interesting fact on its own, but it’s a topic for later.

Over the years, we’ve come to take it for granted that JavaScript is the most popular language today. It boasts the widest ecosystem, therefore it makes sense that it has a lot of web frameworks, right? But have you ever stopped to ask yourself why JavaScript has so many different web frameworks in the first place, as opposed to maybe just one or two or at most three that everybody can build camps around and get behind like every other programming language?

Well, today I asked myself that question, and based on what I’ve seen so far, I think the most compelling arguments are the following.

1. JavaScript’s ecosystem of developers have a wider gap in technical backgrounds than other languages.

I think all developers can generally agree that most self-taught programmers fall into the JavaScript/PHP/Python bucket, with JavaScript taking a strong lead. Don’t just take my word for it though. Data driven research¹ that cites the most popular online learning platforms as data sources clearly showed that among self-enrolled programming courses, JavaScript was the highest up the list, followed by Python. That’s because JavaScript is the easiest language to become a full-stack developer with.

Why this is relevant now is that these self-taught programmers have different backgrounds, and thus different preexisting skill-sets and technical know-how. Some come from backgrounds in graphics design, some in pure sciences, and some in economics or business related courses; some are even war veterans². Depending on such technical background, it might be easier to use one framework over the other.

2. JavaScript can run on your back-end, front-end, or both.

This, I think, is the second most compelling reason for why there are multiple JavaScript frameworks. It is a problem that is unique to JavaScript, and no other language can share the weight of this burden.

JavaScript was built for front-end development, but then was eventually extended for back-end development. Some developers are accustomed to using other languages and frameworks for the back-end of an application. Other developers would like to use JavaScript for both front and back-end. And here in is where a major problem lies. It would be difficult to develop an all-encompassing framework that handles both those situations adequately without adding unnecessary bulk and logical complexity to the web application.

3. Most JavaScript developers just call anything that looks fancy a framework when it’s not really a framework.

Yes. This is the biggest reason why JavaScript has so many frameworks: most of them aren’t actually frameworks. A framework in programming is a tool that provides ready-made components or solutions that are customized in order to speed up development. A framework may include a library, but is defined by the principle of inversion of control (IoC)³.

The important thing to understand here is “inversion of control”. A computer library is composed of reusable components that your custom code calls in order to make use of a particular functionality. If you import code you downloaded from a repository and use it in your code, that’s a library. A framework, however, is when your program is structured such that the reusable, imported code within your program is the one that’s responsible for calling your custom code only when it’s needed. The framework controls the flow of the program, not the custom code.

Now given that explanation, it may come as a shock to some that the popular React framework isn’t actually strictly a framework. It leaves too much structural and logical control over the individual program to be really considered one.

What do you guys think about why there are so many JavaScript FrameWorks?

Shuwa, D. (2021). “The Top 100 Free University Courses of the Year (Ranked by Popularity)”. Free Code Camp, 22 Dec. Available at: https://www.freecodecamp.org/news/most-popular-free-online-courses/ (Accessed: 18 Apr 2022).
In 2014, an organization was started to teach war veterans how to reenter regular society as effective software developers: https://vetswhocode.io/.
Ranjan, R. (2021). “What is a Framework in Programming & Why You Should Use One”. Insights about Product Development, 7 Oct. Available at: https://www.netsolutions.com/insights/what-is-a-framework-in-programming/#:~:text=A%20framework%20in%20programming%20is,inversion%20of%20control%20(IoC). (Accessed: 18 Apr 2022).

P.S. Please subscribe to my blog for more detailed, thought provoking content: https://cassaden.com/blogs/curated

The Software Bug That Created a Bomb

lusayo_ny — Mon, 18 Apr 2022 01:57:46 +0000

Software bugs are pretty common, but very few of them could lead to an explosion that went on record as being the fourth largest non-nuclear explosion of all time. According to some sources, this incident was so catastrophically large, the explosion could be seen from outer space, shaking the Earth at a whopping three kilotons of raw destructive power. Thankfully, not a single person was harmed, which is interesting given the scale of this explosion. While that’s shocking enough on it’s own, it isn’t as shocking as the fact that this malicious “bug” was introduced to systems on purpose, and was part of a much larger struggle between two world powers. To fully understand this incident, we need to go back to the 70’s.

In the 70’s, Russia was fairly advanced in pure sciences and was caught in a fierce space race against the USA, but it had to play catch-up to other developed countries in areas of technology where it lacked. Russia’s solution to that problem was simple: it would pillage what it could not make.

For a little over a decade, the KGB took advantage of labor exchange programs that had been established to improve relations with other developed countries. They inserted spies into their delegates with the sole purpose of gathering privileged know-how from other countries and reporting back to the KGB.

Throughout this operation, there was a man named Vetrov working for the KGB in France. He was an engineer with the responsibility of evaluating the technology gathered through these acts of espionage.

In 1981, Vetrov defected from the KGB for ideological reasons and provided the French government with a list of all of the active spies he knew, as well as all of the active technology targets that the KGB was going for. Among this list of targets was a Canadian gas pipeline company that had a fairly sophisticated system for managing their gas plants and distribution lines. The French president at the time, François Mitterrand, shared this information with the freshly sworn in 40th president of the United States, Ronald Reagen, and that was what set the ball rolling for the fourth largest non-nuclear explosion of all time.

Having gathered this critical piece of information, the Reagan administration chose to not round up the spies they had uncovered, but instead feed them with misinformation. They tampered with software and doctored facts in an effort to foster instability within Russia’s economy. This proved to be particularly deadly when the Russians stole the software to manage their gas pipelines from the Canadian company. What the Russians got was a modified version of the software with a purposeful bug that would only affect their systems after a set amount of time, or after certain conditions have been met. In the world of computer science, this is what’s called a logic bomb.

The logic bomb reset the valves within the gas facilities so that they valves reported a lower pressure than they were actually under. As you can imagine, repressing what they were really feeling was as bad for those pipes as it is for us humans. They exploded in a cathartic chain reaction that shook the Earth and was visible from space.

This whole incident was documented by the CIA as the “Farewell Affair”, named after the assigned codename of Vetrov, the key informant to the west in the operation. There are voices of skepticism over the event due to the lack of corroborating contemporary sources. The only two sources that document it directly are a book by Thomas Reeds, and a published CIA report. Various skeptics also question if Russian pipelines were sophisticated enough to run software during the time, which, in my humble opinion, they probably were given that they used PCLs to run factories ever since the 50s.

Either way, this situation goes to show the power that software has on our lives. And how sometimes, one bug is all it takes to literally change the face the Earth.

P.S. I wrote this to try to get better at writing about tech. It was supposed to be an article about bugs, but this story really interested me so I looked into it more and ended up writing this. Anyway, I would appreciate criticism about my writing, though I'm not sure if this is the best space for that. For references to sources that this article used, please refer to my blog: https://cassaden.com/blogs/curated/the-software-bug-that-created-a-bomb.