chore: sync content to repo (#10283)

Co-authored-by: nilbuild <4921183+nilbuild@users.noreply.github.com>
2026-09-19 09:32:03 +08:00 · 2026-09-07 18:19:53 +02:00
parent 4786ec30c2
commit 58c0669052
100 changed files with 136 additions and 390 deletions
@@ -1,8 +1,6 @@
 # 2-3 Search Trees

-In practice: 2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees).
-
-You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.
+In practice: 2-3 trees have faster inserts at the expense of slower searches (since height is more compared to AVL trees). You would use 2-3 tree very rarely because its implementation involves different types of nodes. Instead, people use Red Black trees.

 Visit the following resources to learn more:

@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@article@Introduction to the A* Algorithm - Red Blob Games](https://www.redblobgames.com/pathfinding/a-star/introduction.html)
 - [@article@A* Search Algorithm - Wikipedia](https://en.wikipedia.org/wiki/A*_search_algorithm)
- [@video@A* Pathfinding (E01: algorithm explanation)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@A* Pathfinding (E01: algorithm explanation)](https://www.youtube.com/watch?v=-L-WgKMFuhE)
@@ -1,10 +1,6 @@
-# Graph Representation
-
-A graph can either be represented as an adjacency matrix or an adjacency list.
-
-The adjacency matrix is a 2D array of size `V x V` where `V` is the number of vertices in a graph. Let the 2D array be `adj[][]`, a slot `adj[i][j] = 1` indicates that there is an edge from vertex `i` to vertex `j`.
-
-Adjacency list is an array of vectors. Size of the array is equal to the number of vertices. Let the array be `array[]`. An entry `array[i]` represents the list of vertices adjacent to the ith vertex. This representation can also be used to represent a weighted graph. The weights of edges can be represented as lists of pairs.
+# Adjacency List
+ 
+An adjacency list represents a graph by storing, for each vertex, a list of the vertices it connects to. This representation uses memory proportional to the number of edges, which makes it efficient for sparse graphs where most vertices are not directly connected to each other.

 Visit the following resources to learn more:

@@ -1,13 +1,10 @@
 # Array

-Arrays store elements in contiguous memory locations, resulting in easily calculable addresses for the elements stored and this allows faster access to an element at a specific index.
+An array stores a fixed-size sequence of elements in contiguous memory, where each element is accessed directly by its index. This contiguous layout makes reading or writing any element an O(1) operation. Inserting or removing an element in the middle is slower, since it requires shifting the elements after it.

 Visit the following resources to learn more:

 - [@course@Array Data Structure - Coursera](https://www.coursera.org/lecture/data-structures/arrays-OsBSF)
 - [@article@What is Array in Data Structure? Types & Syntax](https://www.simplilearn.com/tutorials/data-structure-tutorial/arrays-in-data-structure)
 - [@video@Array Data Structure | Illustrated Data Structures](https://www.youtube.com/watch?v=QJNwK2uJyGs)
- [@video@Jagged Arrays](https://www.youtube.com/watch?v=1jtrQqYpt7g)
- [@video@Dynamic and Static Arrays](https://www.youtube.com/watch?v=PEnFFiQe1pM&list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&index=6)
- [@video@Dynamic Array Code](https://www.youtube.com/watch?v=tvw4v7FEF1w&list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&index=5)
- [@video@UC Berkeley CS61B - Linear and Multi-Dim Arrays (Start watching from 15m 32s)](https://archive.org/details/ucberkeley_webcast_Wp8oiO_CZZE)
+- [@video@Dynamic and Static Arrays](https://www.youtube.com/watch?v=PEnFFiQe1pM&list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&index=6)
@@ -1,17 +1,10 @@
 # Asymptotic Notation

-The efficiency of an algorithm depends on the amount of time, storage and other resources required to execute the algorithm. The efficiency is measured with the help of asymptotic notations.
-
-An algorithm may not have the same performance for different types of inputs. With the increase in the input size, the performance will change.
-
-The study of change in performance of the algorithm with the change in the order of the input size is defined as asymptotic analysis.
+Asymptotic notation describes how the running time or memory usage of an algorithm grows as the size of its input increases, without tying the description to a specific machine or implementation detail. It focuses on the dominant term as input size approaches infinity, ignoring constants and lower-order terms. This makes it possible to compare algorithms independent of hardware or programming language.

 Visit the following resources to learn more:

 - [@article@Asymptotic Analysis: Big-O Notation and More](https://www.programiz.com/dsa/asymptotic-notations)
 - [@article@Big-O Cheat Sheet](https://www.bigocheatsheet.com/)
- [@article@Big O Notation | Brilliant Math & Science Wiki](https://brilliant.org/wiki/big-o-notation/)
 - [@video@Big O Notation — Calculating Time Complexity](https://www.youtube.com/watch?v=Z0bH0cMY0E8)
- [@video@Big O Notation in 5 Minutes](https://www.youtube.com/watch?v=__vX2sjlpXU)
- [@video@Asymptotic Notation - CS50](https://www.youtube.com/watch?v=iOq5kSKqeR4)
 - [@video@CS 61B Lecture 19: Asymptotic Analysis](https://archive.org/details/ucberkeley_webcast_VIS4YDpuP98)
@@ -1,13 +1,10 @@
 # AVL Trees

-AVL trees are a type of self-balancing binary search tree. They are named after their inventors, Adelson-Velskii and Landis. AVL trees are the most popular self-balancing binary search tree.
-
-In practice: From what I can tell, these aren't used much in practice, but I could see where they would be: The AVL tree is another structure supporting O(log n) search, insertion, and removal. It is more rigidly balanced than red–black trees, leading to slower insertion and removal but faster retrieval. This makes it attractive for data structures that may be built once and loaded without reconstruction, such as language dictionaries (or program dictionaries, such as the opcodes of an assembler or interpreter)
+An AVL tree is a self-balancing binary search tree where the heights of the left and right subtrees of any node differ by at most one. When an insertion or deletion violates this balance, the tree performs rotations to restore it, guaranteeing O(log n) time for search, insert, and delete.

 Visit the following resources to learn more:

 - [@course@AVL Trees](https://www.coursera.org/learn/data-structures/lecture/Qq5E0/avl-trees)
 - [@course@AVL Tree Implementation](https://www.coursera.org/learn/data-structures/lecture/PKEBC/avl-tree-implementation)
 - [@course@Split And Merge](https://www.coursera.org/learn/data-structures/lecture/22BgE/split-and-merge)
- [@article@AVL Tree - Programiz](https://www.programiz.com/dsa/avl-tree)
- [@video@MIT AVL Trees / AVL Sort](https://www.youtube.com/watch?v=FNeL18KsWPc&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=6)
+- [@article@AVL Tree - Programiz](https://www.programiz.com/dsa/avl-tree)
@@ -1,14 +1,10 @@
 # B-Trees

-Fun fact: it's a mystery, but the B could stand for Boeing, Balanced, or Bayer (co-inventor).
-
-In Practice: B-Trees are widely used in databases. Most modern filesystems use B-trees (or Variants). In addition to its use in databases, the B-tree is also used in filesystems to allow quick random access to an arbitrary block in a particular file. The basic problem is turning the file block i address into a disk block (or perhaps to a cylinder-head-sector) address
+A B-tree is a self-balancing tree where each node can hold multiple keys and have multiple children, keeping the tree shallow even with a large number of elements. This makes B-trees well suited for storage systems like databases and file systems, where each node can be sized to match a disk block and minimize the number of disk reads needed to find data.

 Visit the following resources to learn more:

 - [@article@B-Tree - Wikipedia](https://en.wikipedia.org/wiki/B-tree)
 - [@article@B-Tree Datastructure](http://btechsmartclass.com/data_structures/b-trees.html)
 - [@video@Introduction to B-Trees](https://www.youtube.com/watch?v=I22wEC1tTGo&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6&index=6)
- [@video@B-Tree Definition and Insertion](https://www.youtube.com/watch?v=s3bCdZGrgpA&index=7&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
- [@video@B-Tree Deletion](https://www.youtube.com/watch?v=svfnVhJOfMc&index=8&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
- [@video@B-Trees (playlist) in 26 minutes](https://www.youtube.com/playlist?list=PL9xmBV_5YoZNFPPv98DjTdD9X6UI9KMHz)
+- [@video@B-Tree Definition and Insertion](https://www.youtube.com/watch?v=s3bCdZGrgpA&index=7&list=PLA5Lqm4uh9Bbq-E0ZnqTIa8LRaL77ica6)
@@ -1,6 +1,6 @@
 # Balanced Tree

-A balanced binary tree, also referred to as a height-balanced binary tree, is defined as a binary tree in which the height of the left and right subtree of any node differ by not more than 1.
+A balanced tree keeps the height difference between subtrees small, typically bounded by a constant, so no path from root to leaf is much longer than another. This guarantees that operations like search, insert, and delete stay close to O(log n) regardless of insertion order. AVL trees and red-black trees are common implementations that enforce balance automatically.

 Visit the following resources to learn more:

@@ -1,10 +1,6 @@
 # BASE Model

-The rise in popularity of NoSQL databases provided flexibility and fluidity in manipulating data, and as a result a new database model was designed that reflects these properties. The acronym BASE is slightly more confusing than ACID; however, the words behind it highlight how the BASE model differs. BASE stands for:
-
-*   **B**asically **A**vailable
-*   **S**oft state
-*   **E**ventual consistency
+BASE describes an alternative to the ACID model used by many distributed and NoSQL databases, standing for basically available, soft state, and eventually consistent. It favors availability and scalability over the strict consistency guarantees of ACID, accepting that data may be temporarily inconsistent across nodes before converging.

 Visit the following resources to learn more:

@@ -1,21 +1,10 @@
 # Basic Math Skills

-Math is a fundamental skill for computer science.
+Basic math skills for computer science cover the mathematical foundations that algorithm analysis and design rely on, including logic, probability, and combinatorics. These skills come up when estimating an algorithm's performance, reasoning about randomized algorithms, or counting the number of possible outcomes in a problem.

 Visit the following resources to learn more:

 - [@article@Computer Science 70, 001 - Spring 2015 - Discrete Mathematics and Probability Theory](http://www.infocobuild.com/education/audio-video-courses/computer-science/cs70-spring2015-berkeley.html)
 - [@article@Discrete Mathematics By IIT Ropar NPTEL](https://nptel.ac.in/courses/106/106/106106183/)
 - [@video@Lec 1 | MIT 6.042J Mathematics for Computer Science, Fall 2010](https://www.youtube.com/watch?v=L3LMbpZIKhQ&list=PLB7540DEDD482705B)
- [@video@Integer Arithmetic, Karatsuba Multiplication](https://www.youtube.com/watch?v=eCaXlAaN2uE&index=11&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
- [@video@The Chinese Remainder Theorem (used in cryptography)](https://www.youtube.com/watch?v=ru7mWZJlRQg)
- [@video@Discrete Mathematics by Shai Simonson (19 videos)](https://www.youtube.com/playlist?list=PLWX710qNZo_sNlSWRMVIh6kfTjolNaZ8t)
- [@video@MIT 6.042J - Probability Introduction](https://www.youtube.com/watch?v=SmFwFdESMHI&index=18&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Conditional Probability](https://www.youtube.com/watch?v=E6FbvM-FGZ8&index=19&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Independence](https://www.youtube.com/watch?v=l1BCv3qqW4A&index=20&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Random Variables](https://www.youtube.com/watch?v=MOfhhFaQdjw&list=PLB7540DEDD482705B&index=21)
- [@video@MIT 6.042J - Expectation I](https://www.youtube.com/watch?v=gGlMSe7uEkA&index=22&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Expectation II](https://www.youtube.com/watch?v=oI9fMUqgfxY&index=23&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Large Deviations](https://www.youtube.com/watch?v=q4mwO2qS2z4&index=24&list=PLB7540DEDD482705B)
- [@video@MIT 6.042J - Random Walks](https://www.youtube.com/watch?v=56iFMY8QW2k&list=PLB7540DEDD482705B&index=25)
- [@feed@Explore top posts about Math](https://app.daily.dev/tags/math?ref=roadmapsh)
+- [@video@Integer Arithmetic, Karatsuba Multiplication](https://www.youtube.com/watch?v=eCaXlAaN2uE&index=11&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@article@Big-O Notation: A Simple Explanation with Examples](https://medium.com/better-programming/big-o-notation-a-simple-explanation-with-examples-a56347d1daca)
 - [@article@CS 61B Lecture 19: Asymptotic Analysis](https://archive.org/details/ucberkeley_webcast_VIS4YDpuP98)
 - [@article@Big O Notation | Brilliant Math & Science Wiki](https://brilliant.org/wiki/big-o-notation/)
- [@video@Big O Notation — Calculating Time Complexity](https://www.youtube.com/watch?v=Z0bH0cMY0E8)
- [@video@Big O Notations](https://www.youtube.com/watch?v=V6mKVRU1evU)
- [@video@Big Oh Notation (and Omega and Theta)](https://www.youtube.com/watch?v=ei-A_wy5Yxw&list=PL1BaGV1cIH4UhkL8a9bJGG356covJ76qN&index=3)
+- [@video@Big O Notation — Calculating Time Complexity](https://www.youtube.com/watch?v=Z0bH0cMY0E8)
@@ -1,6 +1,6 @@
 # Big Omega Notation

-The Big Omega notation is similar to the Big O notation. The only difference is that it denotes the lower bound on the growth rate of a function.
+Big Omega (Ω) notation describes a lower bound on an algorithm's growth rate, meaning the algorithm will take at least this much time or space in the best case. It is used to express the minimum amount of work an algorithm is guaranteed to do for a given input size.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Big Theta Notation

-If a function has the same Big O and Big Omega, they also become the function's Big Theta. Big Theta is used to describe the exact growth rate of a function. It is denoted by the symbol Θ.
+Big-Theta (Θ) notation describes a tight bound on an algorithm's growth rate, meaning the algorithm's running time grows at the same rate as the given function in both the best and worst case. It gives the most precise asymptotic description when an algorithm's upper and lower bounds match.

 Visit the following resources to learn more:

@@ -1,16 +1,10 @@
 # Binary Search Tree

-A binary search tree, also called an ordered or sorted binary tree, is a rooted binary tree data structure with the key of each internal node being greater than all the keys in the respective node's left subtree and less than the ones in its right subtree.
+A binary search tree (BST) is a binary tree where, for every node, all values in its left subtree are smaller and all values in its right subtree are larger. This ordering allows searching, insertion, and deletion in O(log n) time on average, since each comparison rules out half of the remaining nodes. Without balancing, a BST can degrade into a linked list in the worst case, which slows every operation to O(n).

 Visit the following resources to learn more:

 - [@course@Binary Search Trees - Coursera](https://www.coursera.org/learn/data-structures/lecture/E7cXP/introduction)
 - [@video@Tree | Illustrated Data Structures](https://www.youtube.com/watch?v=S2W3SXGPVyU)
 - [@video@Binary Search Trees - MIT](https://www.youtube.com/watch?v=76dhtgZt38A)
- [@video@Binary Search Tree Implementation in C++](https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29)
- [@video@BST implementation - memory allocation in stack and heap](https://www.youtube.com/watch?v=hWokyBoo0aI&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=30)
- [@video@Find Min and Max Element in Binary Search Tree](https://www.youtube.com/watch?v=Ut90klNN264&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=31)
- [@video@Check if Given Tree is Binary Search Tree or Not](https://www.youtube.com/watch?v=yEwSGhSsT0U&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=36)
- [@video@Delete an Element from Binary Search Tree](https://www.youtube.com/watch?v=gcULXE7ViZw&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=37)
- [@video@Inorder Successor in a binary search tree](https://www.youtube.com/watch?v=5cPbNCrdotA&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=38)
- [@feed@Explore top posts about General Programming](https://app.daily.dev/tags/general-programming?ref=roadmapsh)
+- [@video@Binary Search Tree Implementation in C++](https://www.youtube.com/watch?v=COZK7NATh4k&list=PL2_aWCzGMAwI3W_JlcBbtYTwiQSsOTa6P&index=29)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@article@Binary Search - Khan Academy](https://www.khanacademy.org/computing/computer-science/algorithms/binary-search/a/binary-search)
 - [@article@Binary Search](https://www.topcoder.com/thrive/articles/Binary%20Search)
 - [@video@Binary Search in 4 Minutes](https://www.youtube.com/watch?v=fDKIpRe8GW4&feature=youtu.be)
- [@video@Binary Search - CS50](https://www.youtube.com/watch?v=D5SrAga1pno)
- [@feed@Explore top posts about Binary Search](https://app.daily.dev/tags/binary-search?ref=roadmapsh)
+- [@video@Binary Search - CS50](https://www.youtube.com/watch?v=D5SrAga1pno)
@@ -1,9 +1,8 @@
 # Binary Tree

-A binary tree is a tree data structure in which each node has at most two children, which are referred to as the left child and the right child.
+A binary tree is a tree where each node has at most two children, usually called the left and right child. This constraint makes it simple to reason about and forms the basis for more specialized structures like binary search trees and heaps. Binary trees can be traversed in different orders depending on when the current node is visited relative to its children.

 Visit the following resources to learn more:

 - [@video@Binary Trees - Part 1](https://www.youtube.com/watch?v=76dhtgZt38A&list=PLUl4u3cNGP63EdVPNLG3ToM6LaEUuStEY&index=9)
- [@video@Binary Trees - Part 2](https://www.youtube.com/watch?v=U1JYwHcFfso&list=PLUl4u3cNGP63EdVPNLG3ToM6LaEUuStEY&index=10)
- [@feed@Explore top posts about Binary Tree](https://app.daily.dev/tags/binary-tree?ref=roadmapsh)
+- [@video@Binary Trees - Part 2](https://www.youtube.com/watch?v=U1JYwHcFfso&list=PLUl4u3cNGP63EdVPNLG3ToM6LaEUuStEY&index=10)
@@ -1,6 +1,6 @@
 # Bubble Sort
-
-Bubble sort is a simple sorting algorithm that repeatedly steps through the list, compares adjacent elements and swaps them if they are in the wrong order. The pass through the list is repeated until the list is sorted.
+ 
+Bubble sort repeatedly steps through a list, comparing adjacent elements and swapping them if they are in the wrong order, until no swaps are needed. Each pass moves the largest unsorted element into its correct position, like a bubble rising to the top. It runs in O(n²) time in the average and worst case, which makes it inefficient for large datasets but simple to understand and implement.

 Visit the following resources to learn more:

@@ -1,12 +1,10 @@
 # C++

-C++ is a powerful general-purpose programming language. It can be used to develop operating systems, browsers, games, and so on. C++ supports different ways of programming like procedural, object-oriented, functional, and so on. This makes C++ powerful as well as flexible.
+C++ extends the C language with object-oriented features like classes, inheritance, and templates, while keeping low-level memory control. It compiles to native machine code and gives direct access to hardware resources, making it a common choice for game engines, operating systems, and performance-critical software. Manual memory management gives more control but also more room for bugs like leaks or dangling pointers.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated C++ Roadmap](https://roadmap.sh/cpp)
 - [@article@Learn C++](https://learncpp.com/)
- [@article@Cpp Reference](https://en.cppreference.com/)
 - [@article@CPlusPlus](https://cplusplus.com/)
- [@article@C++ TutorialsPoint](https://www.tutorialspoint.com/cplusplus/index.htm)
- [@feed@Explore top posts about C++ Programming](https://app.daily.dev/tags/c++?ref=roadmapsh)
+- [@article@C++ TutorialsPoint](https://www.tutorialspoint.com/cplusplus/index.htm)
@@ -1,10 +1,9 @@
 # C#

-C# (pronounced "C sharp") is a general purpose programming language made by Microsoft. It is used to perform different tasks and can be used to create web apps, games, mobile apps, etc.
+C# is an object-oriented language developed by Microsoft that runs on the .NET runtime. It combines a syntax similar to Java with features like properties, LINQ, and async/await for asynchronous programming. It is used heavily for Windows desktop apps, enterprise backends, and game development through Unity.

 Visit the following resources to learn more:

 - [@article@C# Learning Path](https://docs.microsoft.com/en-us/learn/paths/csharp-first-steps/?WT.mc_id=dotnet-35129-website)
 - [@article@Introduction to C#](https://docs.microsoft.com/en-us/shows/CSharp-101/?WT.mc_id=Educationalcsharp-c9-scottha)
- [@video@C# tutorials](https://www.youtube.com/watch?v=gfkTfcpWqAY&list=PLTjRvDozrdlz3_FPXwb6lX_HoGXa09Yef)
- [@feed@Explore top posts about C# Programming](https://app.daily.dev/tags/csharp?ref=roadmapsh)
+- [@video@C# tutorials](https://www.youtube.com/watch?v=gfkTfcpWqAY&list=PLTjRvDozrdlz3_FPXwb6lX_HoGXa09Yef)
@@ -4,9 +4,7 @@ C is a general-purpose computer programming language. It was created in the 1970

 Visit the following resources to learn more:

- [@book@Beej's Guide to C Programming](https://beej.us/guide/bgc/)
+- [@roadmap@Visit Dedicated C+ Roadmap](https://roadmap.sh/c)
 - [@book@Beej's Guide to C Programming](https://beej.us/guide/bgc/)
 - [@article@Learn C - Tutorials Point](https://www.tutorialspoint.com/cprogramming/index.htm)
- [@video@C Programming Tutorial for Beginners](https://www.youtube.com/watch?v=KJgsSFOSQv0)
- [@video@Learn C Programming with Dr. Chuck](https://www.youtube.com/watch?v=j-_s8f5K30I)
- [@video@C Programming Full Course 2025 (Bro Code)](https://youtu.be/xND0t1pr3KY?si=sy-Xzz7JHMqS6ruA)
+- [@video@C Programming Tutorial for Beginners](https://www.youtube.com/watch?v=KJgsSFOSQv0)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@article@What is CAP Theorem?](https://www.bmc.com/blogs/cap-theorem/)
 - [@article@CAP Theorem - Wikipedia](https://en.wikipedia.org/wiki/CAP_theorem)
 - [@article@An Illustrated Proof of the CAP Theorem](https://mwhittaker.github.io/blog/an_illustrated_proof_of_the_cap_theorem/)
- [@article@CAP Theorem and its applications in NoSQL Databases](https://www.ibm.com/uk-en/cloud/learn/cap-theorem)
- [@video@What is CAP Theorem?](https://www.youtube.com/watch?v=_RbsFXWRZ10)
+- [@article@CAP Theorem and its applications in NoSQL Databases](https://www.ibm.com/uk-en/cloud/learn/cap-theorem)
@@ -1,6 +1,6 @@
 # Character Encodings

-Character encodings are a way of representing characters as numbers. They are used to store and transmit text. The most common character encoding is ASCII, which is a 7-bit encoding. This means that each character is represented by a number between 0 and 127. The ASCII character set contains 128 characters, including letters, numbers, punctuation, and control characters. The ASCII character set is a subset of the Unicode character set, which is a 16-bit encoding. Unicode is a superset of ASCII, so ASCII characters can be represented by Unicode. Unicode is the most common character encoding used on the web.
+A character encoding maps characters, like letters, digits, and symbols, to numeric values that a computer can store and process as bytes. Different encodings can represent different sets of characters and use different numbers of bytes per character, which is why text can display as garbled symbols when read with the wrong encoding.

 Visit the following resources to learn more:

@@ -1,10 +1,7 @@
 # Cloud Design Patterns

-These design patterns are useful for building reliable, scalable, secure applications in the cloud.
-
-The link below has cloud design patterns where each pattern describes the problem that the pattern addresses, considerations for applying the pattern, and an example based on Microsoft Azure. Most patterns include code samples or snippets that show how to implement the pattern on Azure. However, most patterns are relevant to any distributed system, whether hosted on Azure or other cloud platforms.
+Cloud design patterns are reusable solutions for common problems that arise when building and operating applications on cloud infrastructure, such as handling transient failures, managing configuration across services, or scaling components independently. Patterns like circuit breaker, retry, and sidecar address the distributed and elastic nature of cloud environments.

 Visit the following resources to learn more:

- [@article@Cloud Design Patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/)
- [@feed@Explore top posts about Cloud](https://app.daily.dev/tags/cloud?ref=roadmapsh)
+- [@article@Cloud Design Patterns](https://learn.microsoft.com/en-us/azure/architecture/patterns/)
@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@Complexity: Approximation Algorithms](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [@video@Lecture 23: Computational Complexity](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=24)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
+- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
@@ -1,6 +1,6 @@
 # Combinatorics

-Combinatorics is the study of counting. It is a branch of mathematics that is used to solve problems in a variety of fields, including computer science, statistics, and physics. In computer science, combinatorics is used to solve problems related to counting the number of possible outcomes of a given problem. For example, if you are given a set of 10 objects, how many different ways can you arrange them? Or, if you are given a set of 10 objects, how many different ways can you choose 3 objects from that set? These are examples of combinatorial problems.
+Combinatorics is the branch of math concerned with counting, arranging, and combining objects according to given rules, covering concepts like permutations and combinations. It is used in algorithm analysis to count the number of possible states or configurations a problem can have, which often determines the feasibility of a brute-force approach.

 Visit the following resources to learn more:

@@ -1,18 +1,6 @@
 # Common Algorithms
-
-Here are some common algorithms that you should know. You can find more information about them in the Algorithms section of the Computer Science course.
-
-*   Sorting
-*   Recursion
-*   Searching
-*   Cache Algorithms
-*   Tree Algorithms
-*   Graph Algorithms
-*   Greedy Algorithms
-*   Backtracking
-*   Substring Search
-*   Suffix Arrays
-*   Dynamic Programming
+ 
+Common algorithms are well-established, reusable procedures for solving recurring problems like sorting a list, searching for a value, or finding a path through a graph. Studying them builds intuition for algorithm design and gives a shared vocabulary for discussing performance trade-offs, since most real-world problems can be broken down into variations of these known patterns.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Complete Binary Tree

-A complete binary tree is a special type of binary tree where all the levels of the tree are filled completely except the lowest level nodes which are filled from as left as possible.
+A complete binary tree fills every level from left to right, with all levels full except possibly the last, which is filled from the left. This shape allows the tree to be stored efficiently in an array, since a node's children can be found using simple index arithmetic instead of pointers. Binary heaps are usually implemented as complete binary trees for this reason.

 Visit the following resources to learn more:

@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@Complexity: Approximation Algorithms](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [@video@Lecture 23: Computational Complexity](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=24)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
+- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
@@ -1,6 +1,6 @@
 # Constant

-Constant time algorithms are the simplest and most efficient algorithms. They are algorithms that always take the same amount of time to run, regardless of the size of the input. This is the best case scenario for an algorithm, and is the goal of all algorithms.
+Constant time, written O(1), means an operation takes the same amount of time regardless of input size. Accessing an array element by index or reading a value from a hash table are typical examples, since neither depends on how much data the structure holds.

 Visit the following resources to learn more:

@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@article@What is CPU Cache](https://www.howtogeek.com/854138/what-is-cpu-cache/)
 - [@video@MIT 6.004 L15: The Memory Hierarchy](https://www.youtube.com/watch?v=vjYF_fAZI5E&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-&index=24)
- [@video@MIT 6.004 L16: Cache Issues](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-)
- [@feed@Explore top posts about Computing](https://app.daily.dev/tags/computing?ref=roadmapsh)
+- [@video@MIT 6.004 L16: Cache Issues](https://www.youtube.com/watch?v=ajgC3-pyGlk&index=25&list=PLrRW1w6CGAcXbMtDFj205vALOGmiRc82-)
@@ -5,5 +5,4 @@ CPU Interrupts are a way for the CPU to communicate with the rest of the compute
 Visit the following resources to learn more:

 - [@article@System Interrupts 100% CPU](https://www.wikihow.com/System-Interrupts-100-Cpu)
- [@video@Interrupts](https://youtu.be/iKlAWIKEyuw)
- [@feed@Explore top posts about Computing](https://app.daily.dev/tags/computing?ref=roadmapsh)
+- [@video@Interrupts](https://youtu.be/iKlAWIKEyuw)
@@ -1,11 +1,10 @@
 # Data Structures

-As the name indicates itself, a **Data Structure** is a way of organizing the data in the **memory** so that it can be used efficiently. Some common data structures are array, linked list, stack, hashtable, queue, tree, heap, and graph.
+A data structure is a way of organizing and storing data so it can be accessed and modified efficiently. Different structures, like arrays, linked lists, trees, and hash tables, trade off speed for different operations: some are fast to search, others are fast to insert into. Picking the right one for a problem often has a bigger effect on performance than optimizing the code around it.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated DSA Roadmap](https://roadmap.sh/datastructures-and-algorithms)
 - [@course@Data Structures and Algorithms By Google](https://techdevguide.withgoogle.com/paths/data-structures-and-algorithms/)
 - [@video@Data Structures Illustrated](https://www.youtube.com/watch?v=9rhT3P1MDHk&list=PLkZYeFmDuaN2-KUIv-mvbjfKszIGJ4FaY)
- [@video@Data Structures playlist](https://youtube.com/playlist?list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&si=_EEf7x58G6lUcMGG)
- [@feed@Explore top posts about Data Structures](https://app.daily.dev/tags/data-structures?ref=roadmapsh)
+- [@video@Data Structures playlist](https://youtube.com/playlist?list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&si=_EEf7x58G6lUcMGG)
@@ -4,5 +4,4 @@ Federation (or functional partitioning) splits up databases by function. The fed

 Visit the following resources to learn more:

- [@article@Database Federation](https://dev.to/karanpratapsingh/system-design-the-complete-course-10fo#database-federation)
- [@feed@Explore top posts about Database](https://app.daily.dev/tags/database?ref=roadmapsh)
+- [@article@Database Federation](https://dev.to/karanpratapsingh/system-design-the-complete-course-10fo#database-federation)
@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@article@What is a Database?](https://www.oracle.com/database/what-is-database/)
 - [@article@What are Databases?](https://www.prisma.io/dataguide/intro/what-are-databases)
- [@video@DBMS by Stanford](https://www.youtube.com/watch?v=D-k-h0GuFmE&list=PL9ysvtVnryGpnIj9rcIqNDxakUn6v72Hm)
- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh)
+- [@video@DBMS by Stanford](https://www.youtube.com/watch?v=D-k-h0GuFmE&list=PL9ysvtVnryGpnIj9rcIqNDxakUn6v72Hm)
@@ -5,5 +5,4 @@ Dependency injection is a software design pattern that allows us to decouple the
 Visit the following resources to learn more:

 - [@article@Dependency Injection - StackOverflow](https://stackoverflow.com/questions/130794/what-is-dependency-injection)
- [@video@What is Dependency Injection?](https://www.youtube.com/watch?v=0yc2UANSDiw)
- [@feed@Explore top posts about Dependency Injection](https://app.daily.dev/tags/dependency-injection?ref=roadmapsh)
+- [@video@What is Dependency Injection?](https://www.youtube.com/watch?v=0yc2UANSDiw)
@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@opensource@Design Patterns for Humans](https://github.com/nilbuild/design-patterns-for-humans)
 - [@article@Design Patterns](https://en.wikipedia.org/wiki/Software_design_pattern)
- [@article@Refactoring Guru - Design Patterns](https://refactoring.guru/design-patterns/)
- [@feed@Explore top posts about Design Patterns](https://app.daily.dev/tags/design-patterns?ref=roadmapsh)
+- [@article@Refactoring Guru - Design Patterns](https://refactoring.guru/design-patterns/)
@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@video@Dijkstras Algorithm in 3 Minutes](https://www.youtube.com/watch?v=_lHSawdgXpI)
 - [@video@Dijkstras Algorithm - MIT](https://www.youtube.com/watch?v=NSHizBK9JD8&t=1731s&ab_channel=MITOpenCourseWare)
- [@video@Speeding Up Dijkstras Algorithm - MIT](https://www.youtube.com/watch?v=CHvQ3q_gJ7E&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=18)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Speeding Up Dijkstras Algorithm - MIT](https://www.youtube.com/watch?v=CHvQ3q_gJ7E&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=18)
@@ -1,9 +1,8 @@
 # Dijkstra's Algorithm

-Dijkstra's algorithm is a graph traversal algorithm that finds the shortest path between two nodes in a graph. It is a weighted graph algorithm, meaning that each edge in the graph has a weight associated with it. The algorithm works by finding the shortest path from the starting node to all other nodes in the graph. It does this by keeping track of the distance from the starting node to each node, and then choosing the node with the shortest distance from the starting node to visit next. It then updates the distance of each node from the starting node, and repeats the process until all nodes have been visited.
+Dijkstra's algorithm finds the shortest path from a source vertex to all other vertices in a weighted graph with non-negative edge weights. It repeatedly picks the closest unvisited vertex and updates the shortest known distances to its neighbors, using a priority queue to make this selection efficient. It does not work correctly if the graph contains negative edge weights.

 Visit the following resources to learn more:

 - [@video@Dijkstras Algorithm - MIT](https://www.youtube.com/watch?v=NSHizBK9JD8&t=1731s&ab_channel=MITOpenCourseWare)
- [@video@Dijkstras Algorithm in 3 Minutes](https://www.youtube.com/watch?v=_lHSawdgXpI)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Dijkstras Algorithm in 3 Minutes](https://www.youtube.com/watch?v=_lHSawdgXpI)
@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@article@What is DNS?](https://www.cloudflare.com/en-gb/learning/dns/what-is-dns/)
 - [@article@How DNS works (comic)](https://howdns.works/)
 - [@video@DNS and How does it Work?](https://www.youtube.com/watch?v=Wj0od2ag5sk)
- [@video@DNS Records](https://www.youtube.com/watch?v=7lxgpKh_fRY)
- [@video@Complete DNS mini-series](https://www.youtube.com/watch?v=zEmUuNFBgN8&list=PLTk5ZYSbd9MhMmOiPhfRJNW7bhxHo4q-K)
- [@feed@Explore top posts about DNS](https://app.daily.dev/tags/dns?ref=roadmapsh)
+- [@video@DNS Records](https://www.youtube.com/watch?v=7lxgpKh_fRY)
@@ -1,6 +1,6 @@
 # DQL (Data Query Language)

-DQL statements are used for performing queries on the data within schema objects. The purpose of the DQL Command is to get some schema relation based on the query passed to it. We can define DQL as follows it is a component of SQL statement that allows getting data from the database and imposing order upon it. It includes the SELECT statement. This command allows getting the data out of the database to perform operations with it. When a SELECT is fired against a table or tables the result is compiled into a further temporary table, which is displayed or perhaps received by the program i.e. a front-end.
+DQL (Data Query Language) is the subset of SQL used to retrieve data from a database, primarily through the SELECT statement. It is used to read and filter existing data without modifying it.

 Visit the following resources to learn more:

@@ -1,14 +1,6 @@
 # Exponential
-
-Exponential algorithms are those that grow at a rate of 2^n. This means that for each additional input, the algorithm will take twice as long to run. The following function is an example of an exponential algorithm:
-
-    def exponential(n):
-        if n == 0:
-            return 1
-        return exponential(n - 1) + exponential(n - 1)
-    
-
-As you can see, the algorithm's runtime grows exponentially. For each additional input, the algorithm will take twice as long to run.
+ 
+Exponential time, written O(2^n), means the work doubles with each additional unit of input size. Algorithms with exponential time complexity become impractical quickly as input grows, and they often show up in brute-force solutions to problems without known efficient algorithms.

 Visit the following resources to learn more:

@@ -1,27 +1,6 @@
 # Factorial

-Factorial complexity algorithms have a runtime of `O(n!)`. This is the worst case scenario for an algorithm. Factorial complexity algorithms are very inefficient and should be avoided.
-
-    def generate_permutations(s):
-        # Base case: If the string length is 1, return a list containing the string
-        if len(s) == 1:
-            return [s]
-    
-        # Initialize the result list
-        permutations = []
-    
-        # Recursively generate all permutations
-        for i in range(len(s)):
-            # Current character
-            current_char = s[i]
-            # Remaining characters
-            remaining_chars = s[:i] + s[i + 1 :]
-            # Generate all permutations of the remaining characters
-            for perm in generate_permutations(remaining_chars):
-                # Add the current character to the front of each generated permutation
-                permutations.append(current_char + perm)
-    
-        return permutations
+Factorial time, written O(n!), means the work grows by the factorial of the input size, making it impractical for anything but very small inputs. Algorithms that generate every possible permutation of a set, like a brute-force solution to the traveling salesman problem, run in factorial time.

 Visit the following resources to learn more:

@@ -5,5 +5,4 @@ Ford Fulkerson Algorithm is a greedy algorithm that is used to find the maximum
 Visit the following resources to learn more:

 - [@article@Ford-Fulkerson Algorithm](https://www.programiz.com/dsa/ford-fulkerson-algorithm)
- [@video@Ford-Fulkerson in 5 minutes](https://www.youtube.com/watch?v=Tl90tNtKvxs)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Ford-Fulkerson in 5 minutes](https://www.youtube.com/watch?v=Tl90tNtKvxs)
@@ -1,6 +1,6 @@
 # Full Binary Tree

-A full Binary tree is a special type of binary tree in which every parent node/internal node has either two or no children. It is also known as a proper binary tree.
+A full binary tree is a binary tree where every node has either zero or two children, never just one. This property is used in some algorithm proofs and data structures, like certain heap implementations, where a strict shape simplifies reasoning about node counts and depth.

 Visit the following resources to learn more:

@@ -1,13 +1,10 @@
 # Go

-Go is an open source programming language supported by Google. Go can be used to write cloud services, CLI tools, used for API development, and much more.
+Go is a compiled, statically typed language created at Google to make concurrent, networked software simple to write and deploy. It has built-in support for concurrency through goroutines and channels, and it compiles to a single binary with no external runtime dependencies. Go is widely used for backend services, CLIs, and infrastructure tooling.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated Go Roadmap](https://roadmap.sh/golang)
 - [@official@A Tour of Go – Go Basics](https://go.dev/tour/welcome/1)
- [@official@Go Reference Documentation](https://go.dev/doc/)
 - [@article@Go by Example - annotated example programs](https://gobyexample.com/)
- [@article@Making a RESTful JSON API in Go](https://thenewstack.io/make-a-restful-json-api-go/)
- [@article@Go, the Programming Language of the Cloud](https://thenewstack.io/go-the-programming-language-of-the-cloud/)
- [@feed@Explore top posts about Golang](https://app.daily.dev/tags/golang?ref=roadmapsh)
+- [@article@Making a RESTful JSON API in Go](https://thenewstack.io/make-a-restful-json-api-go/)
@@ -6,10 +6,4 @@ Visit the following resources to learn more:

 - [@article@Graph Data Structure](https://www.simplilearn.com/tutorials/data-structure-tutorial/graphs-in-data-structure)
 - [@video@Graph Data Structure | Illustrated Data Structures](https://www.youtube.com/watch?v=0sQE8zKhad0)
- [@video@CSE373 2020 - Lecture 10 - Graph Data Structures](https://www.youtube.com/watch?v=Sjk0xqWWPCc&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=10)
- [@video@CSE373 2020 - Lecture 11 - Graph Traversal](https://www.youtube.com/watch?v=ZTwjXj81NVY&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=11)
- [@video@CSE373 2020 - Lecture 12 - Depth First Search](https://www.youtube.com/watch?v=KyordYB3BOs&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=12)
- [@video@CSE373 2020 - Lecture 13 - Minimum Spanning Trees](https://www.youtube.com/watch?v=oolm2VnJUKw&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=13)
- [@video@CSE373 2020 - Lecture 14 - Minimum Spanning Trees (cont)](https://www.youtube.com/watch?v=RktgPx0MarY&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=14)
- [@video@CSE373 2020 - Lecture 15 - Graph Algorithms (cont 2)](https://www.youtube.com/watch?v=MUe5DXRhyAo&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=15)
- [@video@6.006 Single-Source Shortest Paths Problem](https://www.youtube.com/watch?v=Aa2sqUhIn-E&index=15&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb)
+- [@video@CSE373 2020 - Lecture 10 - Graph Data Structures](https://www.youtube.com/watch?v=Sjk0xqWWPCc&list=PLOtl7M3yp-DX6ic0HGT0PUX_wiNmkWkXx&index=10)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@roadmap@Visit Dedicated GraphQL Roadmap](https://roadmap.sh/graphql)
 - [@official@GraphQL](https://graphql.org/)
 - [@official@GraphQL Documentation](https://graphql.org/learn/)
- [@article@Apollo GraphQL Tutorials](https://www.apollographql.com/tutorials/)
- [@feed@Explore top posts about GraphQL](https://app.daily.dev/tags/graphql?ref=roadmapsh)
+- [@article@Apollo GraphQL Tutorials](https://www.apollographql.com/tutorials/)
@@ -1,15 +1,10 @@
 # gRPC

-gRPC is a platform agnostic serialization protocol that is used to communicate between services. Designed by Google in 2015, it is a modern alternative to REST APIs. It is a binary protocol that uses HTTP/2 as a transport layer. It is a high performance, open source, general-purpose RPC framework that puts mobile and HTTP/2 first.
-
-It's main use case is for communication between two different languages within the same application. You can use Python to communicate with Go, or Java to communicate with C#.
-
-gRPC uses the protocol buffer language to define the structure of the data that is
+gRPC is a remote procedure call framework that lets a client call methods on a server as if they were local function calls, using Protocol Buffers for efficient binary serialization. It runs over HTTP/2, which enables features like multiplexed streaming, and is commonly used for fast communication between internal microservices.

 Visit the following resources to learn more:

 - [@official@gRPC Website](https://grpc.io/)
 - [@official@gRPC Introduction](https://grpc.io/docs/what-is-grpc/introduction/)
 - [@official@gRPC Core Concepts](https://grpc.io/docs/what-is-grpc/core-concepts/)
- [@video@Stephane Maarek - gRPC Introduction](https://youtu.be/XRXTsQwyZSU)
- [@feed@Explore top posts about gRPC](https://app.daily.dev/tags/grpc?ref=roadmapsh)
+- [@video@Stephane Maarek - gRPC Introduction](https://youtu.be/XRXTsQwyZSU)
@@ -1,12 +1,10 @@
 # Hash Table

-Hash Table, Map, HashMap, Dictionary or Associative are all the names of the same data structure. It is one of the most commonly used data structures.
+A hash table stores key-value pairs and uses a hash function to compute an index into an underlying array where each value is stored. This gives average-case O(1) time for lookups, insertions, and deletions. Collisions, where two keys hash to the same index, are handled with techniques like chaining or open addressing.

 Visit the following resources to learn more:

 - [@article@Hash Tables - Princeton University](https://algs4.cs.princeton.edu/34hash/)
 - [@video@Hash Table | Illustrated Data Structures](https://www.youtube.com/watch?v=jalSiaIi8j4)
 - [@video@Hash Table in 4 Minutes](https://youtu.be/knV86FlSXJ8)
- [@video@Hashing with Chaining](https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
- [@video@(Advanced) Randomization: Universal & Perfect Hashing](https://www.youtube.com/watch?v=z0lJ2k0sl1g&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=11)
- [@video@(Advanced) Perfect hashing](https://www.youtube.com/watch?v=N0COwN14gt0&list=PL2B4EEwhKD-NbwZ4ezj7gyc_3yNrojKM9&index=4)
+- [@video@Hashing with Chaining](https://www.youtube.com/watch?v=0M_kIqhwbFo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
@@ -1,12 +1,7 @@
 # Hashing/Encryption/Encoding

-Hashing is a one-way function that takes an input and produces a fixed-length output. The output is called a hash. The hash is a unique representation of the input. The hash is deterministic, meaning that the same input will always produce the same hash. The hash is irreversible, meaning that it is impossible to go from the hash back to the original input. The hash is not collision-resistant, meaning that it is possible to find two different inputs that produce the same hash.
-
-Encryption is a two-way function that takes an input and produces an output. The output is called ciphertext. The ciphertext is a unique representation of the input. The ciphertext is deterministic, meaning that the same input will always produce the same ciphertext. The ciphertext is reversible, meaning that it is possible to go from the ciphertext back to the original input. The ciphertext is collision-resistant, meaning that it is impossible to find two different inputs that produce the same ciphertext.
-
-Encoding is a two-way function that takes an input and produces an output. The output is called encoded text. The encoded text is a unique representation of the input. The encoded text is deterministic, meaning that the same input will always produce the same encoded text. The encoded text is reversible, meaning that it is possible to go from the encoded text back to the original input. The encoded text is collision-resistant, meaning that it is impossible to find two different inputs that produce the same encoded text.
+Hashing, encryption, and encoding are often confused but serve different purposes. Hashing produces a fixed-size, one-way output used to verify data integrity or store passwords securely, encryption transforms data reversibly so only someone with the right key can read it, and encoding transforms data into a different format for compatibility, with no security guarantee at all.

 Visit the following resources to learn more:

- [@video@Encoding, Encryption and Hashing -- What's the Difference?](https://www.youtube.com/watch?v=-bAnBzvMLig)
- [@feed@Explore top posts about Encryption](https://app.daily.dev/tags/encryption?ref=roadmapsh)
+- [@video@Encoding, Encryption and Hashing -- What's the Difference?](https://www.youtube.com/watch?v=-bAnBzvMLig)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@article@Hashing Algorithm Overview:](https://www.okta.com/identity-101/hashing-algorithms/)
 - [@video@Hashing Algorithms and Security - Computerphile](https://www.youtube.com/watch?v=b4b8ktEV4Bg)
 - [@video@Top Hashing Algorithms In Cryptography | MD5 and SHA 256 Algorithms Explained | Simplilearn](https://www.youtube.com/watch?v=Plp4F3ZfC7A)
- [@video@SHA: Secure Hashing Algorithm - Computerphile](https://www.youtube.com/watch?v=DMtFhACPnTY)
- [@feed@Explore top posts about Algorithms](https://app.daily.dev/tags/algorithms?ref=roadmapsh)
+- [@video@SHA: Secure Hashing Algorithm - Computerphile](https://www.youtube.com/watch?v=DMtFhACPnTY)
@@ -1,11 +1,10 @@
 # Heap

-Heap is a tree-based data structure that follows the properties of a complete binary tree and is either a Min Heap or a Max Heap.
+A heap is a tree-based structure that satisfies the heap property: in a max heap, every parent is greater than or equal to its children, and in a min heap, every parent is smaller than or equal to its children. This makes finding the maximum or minimum element an O(1) operation, while insertion and removal take O(log n). Heaps are commonly used to implement priority queues.

 Visit the following resources to learn more:

 - [@course@Priority Queue - Introduction](https://www.coursera.org/lecture/data-structures/introduction-2OpTs)
 - [@article@Heap Data Structure](https://www.programiz.com/dsa/heap-data-structure)
 - [@article@CS 61B Lecture 24: Priority Queues](https://archive.org/details/ucberkeley_webcast_yIUFT6AKBGE)
- [@video@Heap | Illustrated Data Structures](https://www.youtube.com/watch?v=F_r0sJ1RqWk)
- [@video@Heaps and Heap Sort](https://www.youtube.com/watch?v=B7hVxCmfPtM&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=5)
+- [@video@Heap | Illustrated Data Structures](https://www.youtube.com/watch?v=F_r0sJ1RqWk)
@@ -1,6 +1,6 @@
 # How Computers Calculate?

-Computers calculate using the binary system, where all data is represented as 0s and 1s. These binary states correspond to the ON/OFF positions of transistors, which are the building blocks of logic gates (AND, OR, NOT). Numbers, characters, and instructions are broken into binary sequences (bits), and grouped into bytes (8 bits). Arithmetic operations like addition are performed through logic gates, which combine binary values. The CPU executes these calculations by following a fetch-decode-execute cycle. Complex calculations, such as handling decimals, use floating-point representation. Programs written in high-level languages are compiled into machine code for the CPU to execute.
+Computers perform calculations by representing numbers in binary and manipulating them using logic gates built from transistors, which implement operations like addition through circuits called adders. Complex operations, like multiplication or floating point math, are built up from combinations of these basic binary operations at the hardware level.

 Visit the following resources to learn more:

@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@video@How CPU Executes A Program](https://www.youtube.com/watch?v=XM4lGflQFvA)
 - [@video@How Computers Calculate - ALU](https://youtu.be/1I5ZMmrOfnA)
 - [@video@Registers and RAM](https://youtu.be/fpnE6UAfbtU)
- [@video@The Central Processing Unit (CPU)](https://youtu.be/FZGugFqdr60)
- [@video@Instructions and Programs](https://youtu.be/zltgXvg6r3k)
+- [@video@The Central Processing Unit (CPU)](https://youtu.be/FZGugFqdr60)
@@ -4,5 +4,4 @@ The CPU executes programs by repeatedly fetching instructions from memory, decod

 Visit the following resources to learn more:

- [@video@How CPU Executes a Program](https://www.youtube.com/watch?v=XM4lGflQFvA)
- [@feed@Explore top posts about Computing](https://app.daily.dev/tags/computing?ref=roadmapsh)
+- [@video@How CPU Executes a Program](https://www.youtube.com/watch?v=XM4lGflQFvA)
@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@article@Everything you need to know about HTTP](https://cs.fyi/guide/http-in-depth)
 - [@article@What is HTTP?](https://www.cloudflare.com/en-gb/learning/ddos/glossary/hypertext-transfer-protocol-http/)
 - [@article@An overview of HTTP](https://developer.mozilla.org/en-US/docs/Web/HTTP/Overview)
- [@article@HTTP/3 From A To Z: Core Concepts](https://www.smashingmagazine.com/2021/08/http3-core-concepts-part1/)
- [@video@HTTP/1 to HTTP/2 to HTTP/3](https://www.youtube.com/watch?v=a-sBfyiXysI)
 - [@video@HTTP Crash Course & Exploration](https://www.youtube.com/watch?v=iYM2zFP3Zn0)
@@ -1,10 +1,9 @@
 # Java

-Java is general-purpose language, primarily used for Internet-based applications. It was created in 1995 by James Gosling at Sun Microsystems and is one of the most popular options for backend developers.
+Java is an object-oriented, statically typed language that compiles to bytecode and runs on the Java Virtual Machine (JVM), which lets the same compiled code run on any platform with a JVM installed. It manages memory automatically through garbage collection. Java is widely used in enterprise backend systems, Android development, and large-scale distributed applications.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated Java Roadmap](https://roadmap.sh/java)
 - [@official@Java](https://www.java.com/)
- [@video@Java Crash Course](https://www.youtube.com/watch?v=eIrMbAQSU34)
- [@feed@Explore top posts about Java](https://app.daily.dev/tags/java?ref=roadmapsh)
+- [@video@Java Crash Course](https://www.youtube.com/watch?v=eIrMbAQSU34)
@@ -1,10 +1,6 @@
 # N-ary (K-ary, M-ary) Trees

-Note: the N or K is the branching factor (max branches)
-
-Binary trees are a 2-ary tree, with branching factor = 2
-
-2-3 trees are 3-ary
+A k-ary (or m-ary) tree is a generalization of a binary tree where each node can have up to k children instead of just two. Increasing the branching factor reduces the tree's height for a given number of nodes, which is useful in structures like B-trees where minimizing height matters for disk access.

 Visit the following resources to learn more:

@@ -1,11 +1,6 @@
 # Knuth Morris Pratt

-Knuth morris pratt is a string searching algorithm that uses a precomputed array to find the substring in a string. This array is known as the prefix function. The prefix function is the longest prefix that is also a suffix of a substring. The prefix function is used to skip the characters that are already matched. The algorithm is as follows:
-
-*   Compute the prefix function of the substring.
-*   Traverse through the string and substring simultaneously.
-*   If the characters match, increment the index of both the string and substring.
-*   If the characters don't match, increment the index of the string by the value of the prefix function at the index of the substring.
+The Knuth-Morris-Pratt (KMP) algorithm searches for a pattern in text by preprocessing the pattern into a table that tracks the longest proper prefix that is also a suffix. This lets the algorithm skip re-checking characters it has already matched when a mismatch occurs, giving it O(n + m) time complexity.

 Visit the following resources to learn more:

@@ -5,5 +5,4 @@ Kruskal's algorithm is a greedy algorithm that finds a minimum spanning tree for
 Visit the following resources to learn more:

 - [@video@Kruskals Algorithm in 2 Minutes](https://www.youtube.com/watch?v=71UQH7Pr9kU)
- [@video@Graph Algorithms II - DFS, BFS, Kruskals Algorithm, Union Find Data Structure - Lecture 7](https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=8)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Graph Algorithms II - DFS, BFS, Kruskals Algorithm, Union Find Data Structure - Lecture 7](https://www.youtube.com/watch?v=ufj5_bppBsA&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=8)
@@ -6,10 +6,5 @@ Visit the following resources to learn more:

 - [@course@Singly Linked Lists](https://www.coursera.org/lecture/data-structures/singly-linked-lists-kHhgK)
 - [@course@Core: Linked Lists vs Arrays](https://www.coursera.org/lecture/data-structures-optimizing-performance/core-linked-lists-vs-arrays-rjBs9)
- [@course@In the Real World: Linked Lists vs Arrays](https://www.coursera.org/lecture/data-structures-optimizing-performance/in-the-real-world-lists-vs-arrays-QUaUd)
- [@course@Doubly Linked Lists](https://www.coursera.org/lecture/data-structures/doubly-linked-lists-jpGKD)
 - [@video@Linked List Data Structure | Illustrated Data Structures](https://www.youtube.com/watch?v=odW9FU8jPRQ)
- [@video@Linked Lists in 4 minutes](https://www.youtube.com/watch?v=F8AbOfQwl1c)
- [@video@CS 61B Lecture 7: Linked Lists I](https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0)
- [@video@CS 61B Lecture 7: Linked Lists II](https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w)
- [@video@Why you should avoid Linked Lists?](https://www.youtube.com/watch?v=YQs6IC-vgmo)
+- [@video@Linked Lists in 4 minutes](https://www.youtube.com/watch?v=F8AbOfQwl1c)
@@ -1,10 +1,6 @@
 # Lock / Mutex / Semaphore

-A lock allows only one thread to enter the part that's locked and the lock is not shared with any other processes.
-
-A mutex is the same as a lock but it can be system wide (shared by multiple processes).
-
-A semaphore does the same as a mutex but allows x number of threads to enter, this can be used for example to limit the number of cpu, io or ram intensive tasks running at the same time.
+A lock or mutex ensures that only one thread can access a shared resource at a time, preventing race conditions when multiple threads read and write the same data. A semaphore is a more general version that allows a set number of threads to access a resource concurrently, using a counter instead of a simple locked or unlocked state.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Logarithmic

-Logarithmic complexity algorithms are the second fastest algorithms. They are faster than linear algorithms, but slower than constant algorithms.
+Logarithmic time, written O(log n), means the work needed grows very slowly as input size increases, typically because the algorithm cuts the problem size in half (or by some fraction) at each step. Binary search is a classic example: doubling the input size only adds one more comparison.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Longest Path Problem

-Longest path problem is a problem that asks us to find the longest path in a graph.
+The Longest Path Problem asks for the longest simple path between two vertices in a graph, one that does not repeat any vertex. Unlike the shortest path problem, which has efficient algorithms, finding the longest path is NP-hard in general graphs, though it becomes solvable in polynomial time for special cases like directed acyclic graphs.

 Visit the following resources to learn more:

@@ -6,7 +6,7 @@ If you have networking experience or want to be a reliability engineer or operat

 Visit the following resources to learn more:

+- [@roadmap@Visit the Dedicated Network Engineer Roadmap](https://roadmap.sh/network-engineer)
 - [@article@Khan Academy - Networking](https://www.khanacademy.org/computing/code-org/computers-and-the-internet)
 - [@video@Computer Networking Course - Network Engineering](https://www.youtube.com/watch?v=qiQR5rTSshw)
- [@video@Networking Video Series (21 videos)](https://www.youtube.com/playlist?list=PLEbnTDJUr_IegfoqO4iPnPYQui46QqT0j)
- [@feed@Explore top posts about Networking](https://app.daily.dev/tags/networking?ref=roadmapsh)
+- [@video@Networking Video Series (21 videos)](https://www.youtube.com/playlist?list=PLEbnTDJUr_IegfoqO4iPnPYQui46QqT0j)
@@ -1,13 +1,10 @@
-# Non-tail recursion
-
-Tail recursion is when a function can directly return the result of a recursive call - there are no outstanding operations, and there is no need for the call stack frame to be preserved. So it can be translated to a “goto with arguments”, and the stack usage will be constant.
-
-In “non-tail recursion”, there are outstanding operations after the recursive call, and the stack frame cannot be nuked.
+# Non-Tail Recursion
+ 
+Non-tail recursion is a form of recursion where work remains to be done after the recursive call returns, such as combining the result with something else. Each call must keep its stack frame until the recursive call underneath it finishes, which means the call stack grows with each level of recursion and cannot be optimized away like tail recursion.

 Visit the following resources to learn more:

 - [@article@What is non-tail recursion?](https://www.quora.com/What-is-non-tail-recursion)
 - [@article@Tail vs Non-Tail Recursion](https://www.baeldung.com/cs/tail-vs-non-tail-recursion)
 - [@video@Recursion (Solved Problem 1)](https://www.youtube.com/watch?v=IVLUGb_gDDE)
- [@video@Types of Recursion (Part 2) | Tail & Non-tail Recursion](https://www.youtube.com/watch?v=HIt_GPuD7wk)
- [@feed@Explore top posts about Recursion](https://app.daily.dev/tags/recursion?ref=roadmapsh)
+- [@video@Types of Recursion (Part 2) | Tail & Non-tail Recursion](https://www.youtube.com/watch?v=HIt_GPuD7wk)
@@ -1,8 +1,6 @@
 # Normalization vs Denormalization

-Database normalization is a process used to organize a database into tables and columns. The idea is that a table should be about a specific topic and that only those columns which support that topic are included. This limits the number of duplicate data contained within your database. This makes the database more flexible by eliminating issues stemming from database modifications.
-
-Denormalization is the opposite of normalization. It is the process of adding redundant data to a database to improve read performance. This is done by adding duplicate data into multiple tables to avoid expensive joins. This is done at the expense of increased storage and decreased write performance.
+Normalization organizes a database schema to reduce data redundancy by splitting data into related tables, following a set of normal forms. Denormalization does the opposite, intentionally duplicating data across tables to reduce the number of joins needed for common queries, trading storage and update complexity for faster reads.

 Visit the following resources to learn more:

@@ -7,7 +7,4 @@ Visit the following resources to learn more:
 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@P vs. NP and the Computational Complexity Zoo](https://www.youtube.com/watch?v=YX40hbAHx3s)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
- [@video@NP Completeness II & Reductions](https://www.youtube.com/watch?v=e0tGC6ZQdQE&index=16&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness III](https://www.youtube.com/watch?v=fCX1BGT3wjE&index=17&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness IV](https://www.youtube.com/watch?v=NKLDp3Rch3M&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=18)
+- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
@@ -7,9 +7,4 @@ Visit the following resources to learn more:
 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@Complexity: Approximation Algorithms](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [@video@Lecture 23: Computational Complexity](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=24)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
- [@video@NP Completeness II & Reductions](https://www.youtube.com/watch?v=e0tGC6ZQdQE&index=16&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness III](https://www.youtube.com/watch?v=fCX1BGT3wjE&index=17&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness IV](https://www.youtube.com/watch?v=NKLDp3Rch3M&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=18)
+- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
@@ -7,9 +7,4 @@ Visit the following resources to learn more:
 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@Complexity: Approximation Algorithms](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [@video@Lecture 23: Computational Complexity](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=24)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
- [@video@NP Completeness II & Reductions](https://www.youtube.com/watch?v=e0tGC6ZQdQE&index=16&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness III](https://www.youtube.com/watch?v=fCX1BGT3wjE&index=17&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm)
- [@video@NP Completeness IV](https://www.youtube.com/watch?v=NKLDp3Rch3M&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=18)
+- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@official@OWASP](https://owasp.org/)
 - [@opensource@OWASP Web Application Security Testing Checklist](https://github.com/0xRadi/OWASP-Web-Checklist)
 - [@article@OWASP - Wiki](https://en.wikipedia.org/wiki/OWASP)
- [@article@OWASP Top 10 Security Risks](https://sucuri.net/guides/owasp-top-10-security-vulnerabilities-2021/)
- [@article@OWASP Cheatsheets](https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html)
+- [@article@OWASP Top 10 Security Risks](https://sucuri.net/guides/owasp-top-10-security-vulnerabilities-2021/)
@@ -1,12 +1,6 @@
 # P = NP

-The P = NP problem is one of the most famous problems in computer science. It asks whether a problem that can be solved in polynomial time on a non-deterministic machine (i.e., the problem is in NP) can also be solved in polynomial time on a deterministic machine (i.e., the problem is in P).
-
-If you can find a polynomial-time solution to an NP-complete problem, then all problems in NP can be solved in polynomial time. This shows that P = NP.
-
-If you can prove for any single NP-complete problem that it is only solvable in exponential time, then all NP-complete problems are only solvable in exponential time. This shows that P ≠ NP.
-
-So far, we don't know whether P = NP or P ≠ NP.
+P = NP is one of the most famous open problems in computer science, asking whether every problem whose solution can be verified quickly can also be solved quickly. Most researchers believe P does not equal NP, but no one has proven it either way, and a proof in either direction would have major implications for cryptography and optimization.

 Visit the following resources to learn more:

@@ -1,12 +1,10 @@
 # P

-The P in the P class stands for Polynomial Time. It is the collection of decision problems(problems with a “yes” or “no” answer) that can be solved by a deterministic machine in polynomial time.
+P is the complexity class of decision problems that can be solved by a deterministic algorithm in polynomial time. Problems in P are generally considered efficiently solvable, forming the baseline against which harder complexity classes are compared.

 Visit the following resources to learn more:

 - [@article@Trying to understand P vs NP vs NP Complete vs NP Hard](https://softwareengineering.stackexchange.com/questions/308178/trying-to-understand-p-vs-np-vs-np-complete-vs-np-hard)
 - [@video@Complexity: P, NP, NP-completeness, Reductions](https://www.youtube.com/watch?v=eHZifpgyH_4&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=22)
 - [@video@Complexity: Approximation Algorithms](https://www.youtube.com/watch?v=MEz1J9wY2iM&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp&index=24)
- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
- [@video@Lecture 23: Computational Complexity](https://www.youtube.com/watch?v=moPtwq_cVH8&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=24)
- [@video@Greedy Algs. II & Intro to NP Completeness](https://youtu.be/qcGnJ47Smlo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=2939)
+- [@video@Complexity: Fixed-Parameter Algorithms](https://www.youtube.com/watch?v=4q-jmGrmxKs&index=25&list=PLUl4u3cNGP6317WaSNfmCvGym2ucw3oGp)
@@ -1,18 +1,10 @@
 # Pick a Language

-You need to pick a programming language to learn the Computer Science concepts. My personal recommendation would be to pick C++ or C and the reason for that is:
-
-*   They allow you to deal with pointers and memory allocation/deallocation, so you feel the data structures and algorithms in your bones. In higher level languages like Python or Java, these are hidden from you. In day to day work, that's terrific, but when you're learning how these low-level data structures are built, it's great to feel close to the metal.
-*   You will be able to find a lot of resources for the topics listed in this roadmap using C or C++. You can find a lot of resources for Python and Java, but they are not as abundant as C++ and C.
-
-Given below is the list of resources; pick ones relevant to the language of your choice.
+You need to pick a programming language to learn computer science concepts. My personal recommendation would be to pick C++ or C. They allow you to deal with pointers and memory allocation/deallocation, so you feel the data structures and algorithms in your bones. In higher level languages like Python or Java, these are hidden from you. In day to day work, that's terrific, but when you're learning how these low-level data structures are built, it's great to feel close to the metal. Also, you will be able to find a lot of resources for the topics listed in this roadmap using C or C++.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated C++ Roadmap](https://roadmap.sh/cpp)
- [@article@Learn C++ - Tutorials Point](https://www.tutorialspoint.com/cplusplus/index.htm)
- [@article@Learn C - Tutorials Point](https://www.tutorialspoint.com/cprogramming/index.htm)
+- [@roadmap@Visit Dedicated C Roadmap](https://roadmap.sh/c)
 - [@video@C++ Programming Course - Beginner to Advanced](https://www.youtube.com/watch?v=8jLOx1hD3_o)
- [@video@C++ Tutorial for Beginners - Full Course](https://www.youtube.com/watch?v=vLnPwxZdW4Y)
- [@video@C Programming Tutorial for Beginners](https://www.youtube.com/watch?v=KJgsSFOSQv0)
- [@video@Learn C Programming with Dr. Chuck](https://www.youtube.com/watch?v=j-_s8f5K30I)
+- [@video@C Programming Tutorial for Beginners](https://www.youtube.com/watch?v=KJgsSFOSQv0)
@@ -1,11 +1,6 @@
 # Polynomial

-Polynomial algorithms are algorithms that have a runtime that is a polynomial function of the input size. This means that the runtime is a function of the form `n^k` where `k` is a constant. For example, the runtime of the following algorithm is `n^2`:
-
-    def polynomial_algorithm(n):
-        for i in range(n):
-            for j in range(n):
-                print(i, j)
+Polynomial time means an algorithm's running time can be expressed as n raised to some fixed power, such as O(n²) or O(n³). Problems solvable in polynomial time are generally considered tractable in complexity theory, forming the basis of the complexity class P.

 Visit the following resources to learn more:

@@ -5,5 +5,4 @@ Prim's algorithm is a greedy algorithm that finds a minimum spanning tree for a
 Visit the following resources to learn more:

 - [@article@Prims Algorithm](https://www.programiz.com/dsa/prim-algorithm)
- [@video@Graph Algorithms I - Topological Sorting, Prims Algorithm - Lecture 6](https://www.youtube.com/watch?v=i_AQT_XfvD8&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Graph Algorithms I - Topological Sorting, Prims Algorithm - Lecture 6](https://www.youtube.com/watch?v=i_AQT_XfvD8&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=7)
@@ -1,6 +1,6 @@
 # Probability

-Probability is the study of how likely an event is to occur. It is a measure of how certain we are that an event will happen.
+Probability measures how likely an event is to occur, expressed as a number between 0 and 1. In computer science, it comes up in randomized algorithms, hashing collision analysis, and average-case complexity analysis, where the expected behavior of an algorithm depends on the distribution of its inputs.

 Visit the following resources to learn more:

@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@article@Public-key Cryptography](https://en.wikipedia.org/wiki/Public-key_cryptography)
 - [@video@Public Key Cryptography - Computerphile](https://www.youtube.com/watch?v=GSIDS_lvRv4)
- [@video@Public Key Cryptography: RSA Encryption Algorithm](https://www.youtube.com/watch?v=wXB-V_Keiu8)
- [@feed@Explore top posts about Cryptography](https://app.daily.dev/tags/cryptography?ref=roadmapsh)
+- [@video@Public Key Cryptography: RSA Encryption Algorithm](https://www.youtube.com/watch?v=wXB-V_Keiu8)
@@ -5,11 +5,6 @@ Python is a well known programming language which is both a strongly typed and a
 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated Python Roadmap](https://roadmap.sh/python)
- [@official@Python](https://www.python.org/)
 - [@official@Getting Started with Python](https://www.python.org/about/gettingstarted/)
- [@article@Automate the Boring Stuff](https://automatetheboringstuff.com/)
- [@article@Python principles - Python basics](https://pythonprinciples.com/)
 - [@article@Python Crash Course](https://ehmatthes.github.io/pcc/)
- [@article@An Introduction to Python for Non-Programmers](https://thenewstack.io/an-introduction-to-python-for-non-programmers/)
- [@article@Getting Started with Python and InfluxDB](https://thenewstack.io/getting-started-with-python-and-influxdb/)
- [@feed@Explore top posts about Python](https://app.daily.dev/tags/python?ref=roadmapsh)
+- [@article@Getting Started with Python and InfluxDB](https://thenewstack.io/getting-started-with-python-and-influxdb/)
@@ -1,6 +1,6 @@
 # Queue

-Queue is a linear collection of items where items are inserted and removed in a particular order. The queue is also called a FIFO Data Structure because it follows the "First In, First Out" principle i.e., the item that is inserted in the first is the one that is taken out first.
+A queue is a data structure that processes elements in the order they arrived, following a first-in, first-out (FIFO) rule. New elements are added at the back and removed from the front. Queues are used for task scheduling, handling requests in order, and breadth-first traversal of trees and graphs.

 Visit the following resources to learn more:

@@ -7,6 +7,4 @@ Visit the following resources to learn more:
 - [@course@Rabin Karps Algorithm](https://www.coursera.org/lecture/data-structures/rabin-karps-algorithm-c0Qkw)
 - [@course@Optimization: Precomputation](https://www.coursera.org/learn/data-structures/lecture/nYrc8/optimization-precomputation)
 - [@course@Optimization: Implementation and Analysis](https://www.coursera.org/learn/data-structures/lecture/h4ZLc/optimization-implementation-and-analysis)
- [@video@Lecture 9: Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
- [@video@Rolling Hashes, Amortized Analysis](https://www.youtube.com/watch?v=w6nuXg0BISo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=33)
- [@feed@Explore top posts about Data Science](https://app.daily.dev/tags/data-science?ref=roadmapsh)
+- [@video@Lecture 9: Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
@@ -1,15 +1,10 @@
-# Red/Black Trees
-
-In computer science, a red–black tree is a kind of self-balancing binary search tree. Each node stores an extra bit representing "color", used to ensure that the tree remains balanced during insertions and deletions.
-
-These are a translation of a 2-3 tree (see below).
-
-In practice: Red–black trees offer worst-case guarantees for insertion time, deletion time, and search time. Not only does this make them valuable in time-sensitive applications such as real-time applications, but it makes them valuable building blocks in other data structures which provide worst-case guarantees; for example, many data structures used in computational geometry can be based on red–black trees, and the Completely Fair Scheduler used in current Linux kernels uses red–black trees. In the version 8 of Java, the Collection HashMap has been modified such that instead of using a LinkedList to store identical elements with poor hashcodes, a Red-Black tree is used.
+# Red / Black Trees
+ 
+A red-black tree is a self-balancing binary search tree where each node is colored red or black, and a set of coloring rules ensures the tree never becomes more than roughly twice as tall as the shortest possible balanced tree. It requires fewer rotations on average than an AVL tree, which makes it a common choice for implementing ordered maps and sets in standard libraries.

 Visit the following resources to learn more:

 - [@article@Red-Black Tree - Wikipedia](https://en.wikipedia.org/wiki/Red%E2%80%93black_tree)
 - [@article@An Introduction To Binary Search And Red Black Tree](https://www.topcoder.com/thrive/articles/An%20Introduction%20to%20Binary%20Search%20and%20Red-Black%20Trees)
 - [@video@Red-Black Trees (playlist) in 30 minutes](https://www.youtube.com/playlist?list=PL9xmBV_5YoZNqDI8qfOZgzbqahCUmUEin)
- [@video@Aduni - Algorithms - Lecture 4 (link jumps to starting point)](https://youtu.be/1W3x0f_RmUo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3871)
- [@video@Aduni - Algorithms - Lecture 5](https://www.youtube.com/watch?v=hm2GHwyKF1o&list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&index=5)
+- [@video@Aduni - Algorithms - Lecture 4 (link jumps to starting point)](https://youtu.be/1W3x0f_RmUo?list=PLFDnELG9dpVxQCxuD-9BSy2E7BWY3t5Sm&t=3871)
@@ -6,5 +6,4 @@ Visit the following resources to learn more:

 - [@article@What is a REST API?](https://www.redhat.com/en/topics/api/what-is-a-rest-api)
 - [@article@Roy Fieldings dissertation chapter, Representational State Transfer (REST)](https://www.ics.uci.edu/~fielding/pubs/dissertation/rest_arch_style.htm)
- [@article@Learn REST: A RESTful Tutorial](https://restapitutorial.com/)
- [@feed@Explore top posts about REST API](https://app.daily.dev/tags/rest-api?ref=roadmapsh)
+- [@article@Learn REST: A RESTful Tutorial](https://restapitutorial.com/)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@course@Rabin Karps Algorithm](https://www.coursera.org/lecture/data-structures/rabin-karps-algorithm-c0Qkw)
 - [@course@Optimization: Precomputation](https://www.coursera.org/learn/data-structures/lecture/nYrc8/optimization-precomputation)
 - [@course@Optimization: Implementation and Analysis](https://www.coursera.org/learn/data-structures/lecture/h4ZLc/optimization-implementation-and-analysis)
- [@video@Lecture 9: Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
- [@video@Rolling Hashes, Amortized Analysis](https://www.youtube.com/watch?v=w6nuXg0BISo&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=33)
+- [@video@Lecture 9: Table Doubling, Karp-Rabin](https://www.youtube.com/watch?v=BRO7mVIFt08&list=PLUl4u3cNGP61Oq3tWYp6V_F-5jb5L2iHb&index=9)
@@ -1,12 +1,10 @@
 # Rust

-Rust is a modern systems programming language focusing on safety, speed, and concurrency. It accomplishes these goals by being memory safe without using garbage collection.
+Java is an object-oriented, statically typed language that compiles to bytecode and runs on the Java Virtual Machine (JVM), which lets the same compiled code run on any platform with a JVM installed. It manages memory automatically through garbage collection. Java is widely used in enterprise backend systems, Android development, and large-scale distributed applications.

 Visit the following resources to learn more:

 - [@roadmap@Visit Dedicated Rust Roadmap](https://roadmap.sh/rust)
 - [@official@The Rust Programming Language - online book](https://doc.rust-lang.org/book/)
 - [@official@Rust by Example - collection of runnable examples](https://doc.rust-lang.org/stable/rust-by-example/index.html)
- [@article@Rust vs. Go: Why They’re Better Together](https://thenewstack.io/rust-vs-go-why-theyre-better-together/)
- [@article@Rust by the Numbers: The Rust Programming Language in 2021](https://thenewstack.io/rust-by-the-numbers-the-rust-programming-language-in-2021/)
- [@feed@Explore top posts about Rust](https://app.daily.dev/tags/rust?ref=roadmapsh)
+- [@article@Rust vs. Go: Why They’re Better Together](https://thenewstack.io/rust-vs-go-why-theyre-better-together/)
@@ -1,18 +1,6 @@
 # Scheduling Algorithms

-CPU Scheduling is the process of selecting a process from the ready queue and allocating the CPU to it. The selection of a process is based on a particular scheduling algorithm. The scheduling algorithm is chosen depending on the type of system and the requirements of the processes.
-
-Here is the list of some of the most commonly used scheduling algorithms:
-
-*   **First Come First Serve (FCFS):** The process that arrives first is allocated the CPU first. It is a non-preemptive algorithm.
-*   **Shortest Job First (SJF):** The process with the smallest execution time is allocated the CPU first. It is a non-preemptive algorithm.
-*   **Shortest Remaining Time First (SRTF):** The process with the smallest remaining execution time is allocated the CPU first. It is a preemptive algorithm.
-*   **Round Robin (RR):** The process is allocated the CPU for a fixed time slice. The time slice is usually 10 milliseconds. It is a preemptive algorithm.
-*   **Priority Scheduling:** The process with the highest priority is allocated the CPU first. It is a preemptive algorithm.
-*   **Multi-level Queue Scheduling:** The processes are divided into different queues based on their priority. The process with the highest priority is allocated the CPU first. It is a preemptive algorithm.
-*   **Multi-level Feedback Queue Scheduling:** The processes are divided into different queues based on their priority. The process with the highest priority is allocated the CPU first. If a process is preempted, it is moved to the next queue. It is a preemptive algorithm.
-*   **Highest Response Ratio Next(HRRN):** CPU is allotted to the next process which has the highest response ratio and not to the process having less burst time. It is a Non-Preemptive algorithm.
-*   **Lottery Scheduling:** The process is allocated the CPU based on a lottery system. It is a preemptive algorithm.
+Scheduling algorithms determine the order in which an operating system runs competing processes or threads on the available CPU cores. Different algorithms, like round robin, shortest job first, or priority scheduling, balance goals such as fairness, responsiveness, and overall throughput differently.

 Visit the following resources to learn more:

@@ -7,8 +7,4 @@ Visit the following resources to learn more:
 - [@opensource@OWASP Web Application Security Testing Checklist](https://github.com/0xRadi/OWASP-Web-Checklist)
 - [@article@Why HTTPS Matters](https://developers.google.com/web/fundamentals/security/encrypt-in-transit/why-https)
 - [@article@Wikipedia - OWASP](https://en.wikipedia.org/wiki/OWASP)
- [@article@OWASP Top 10 Security Risks](https://sucuri.net/guides/owasp-top-10-security-vulnerabilities-2021/)
- [@article@OWASP Cheatsheets](https://cheatsheetseries.owasp.org/cheatsheets/AJAX_Security_Cheat_Sheet.html)
- [@article@Content Security Policy (CSP)](https://developer.mozilla.org/en-US/docs/Web/HTTP/CSP)
- [@video@MIT 6.858 Computer Systems Security, Fall 2014](https://www.youtube.com/playlist?list=PLUl4u3cNGP62K2DjQLRxDNRi0z2IRWnNh)
- [@feed@Explore top posts about Security](https://app.daily.dev/tags/security?ref=roadmapsh)
+- [@article@OWASP Top 10 Security Risks](https://sucuri.net/guides/owasp-top-10-security-vulnerabilities-2021/)
@@ -1,6 +1,6 @@
 # Sequence Diagrams

-Sequence diagrams are a way to show how objects or systems interact with each other over time.
+A sequence diagram shows how objects interact with each other over time by depicting the order in which messages are sent between them. It is commonly used to visualize the flow of a specific scenario, like a user login process, across multiple components.

 Visit the following resources to learn more:

@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@article@Sharding](https://dev.to/karanpratapsingh/system-design-the-complete-course-10fo#sharding)
 - [@video@Sharding & Database Partitioning | System Design Basics](https://www.youtube.com/watch?v=RynPj8C0BXA)
 - [@video@Database Sharding - Watch](https://www.youtube.com/watch?v=hdxdhCpgYo8)
- [@video@Database Sharding in 5 minutes](https://www.youtube.com/watch?v=kSH4bt8ypOQ)
- [@feed@Explore top posts about Backend Development](https://app.daily.dev/tags/backend?ref=roadmapsh)
+- [@video@Database Sharding in 5 minutes](https://www.youtube.com/watch?v=kSH4bt8ypOQ)
@@ -1,6 +1,6 @@
 # Small O Notation

-Small o notation, denoted as o(g(n)), defines an upper bound on the growth of a function f(n) that is *not* asymptotically tight. In simpler terms, f(n) is o(g(n)) if, for any positive constant c, there exists a value n₀ such that f(n) is strictly less than c*g(n) for all n greater than n₀. This means that g(n) grows strictly faster than f(n) as n approaches infinity.
+Small o notation describes an upper bound that is strictly greater than the actual growth rate, rather than a tight or achievable bound like Big O. It is used to express that one function grows strictly slower than another, useful in more formal algorithm analysis and proofs.

 Visit the following resources to learn more:

@@ -1,6 +1,6 @@
 # Small Omega

-Small Omega (ω) notation is used to describe a lower bound on the growth rate of a function. Specifically, it indicates that a function *g(n)* grows strictly slower than another function *f(n)* as *n* approaches infinity. This means that for any constant *c > 0*, there exists a value *n₀* such that *g(n) < c*f(n)* for all *n > n₀*. In simpler terms, *f(n)* is a strict lower bound for *g(n)*.
+Small omega notation describes a lower bound that is strictly less than the actual growth rate, the counterpart to small o. It states that an algorithm's growth rate is strictly greater than a given function, used mainly in theoretical analysis rather than everyday complexity comparisons.

 Visit the following resources to learn more:

@@ -1,12 +1,10 @@
 # SQL vs NoSQL databases

-SQL stands for Structured Query Language. It's used for relational databases. A SQL database is a collection of tables that stores a specific set of structured data. Some examples are PostgreSQL, MySQL, MariaDB etc.
-
-NoSQL stands for Not Only SQL. It's used for non-relational databases. A NoSQL database is a collection of collections that stores a specific set of unstructured data. Some examples are MongoDB, CouchDB, Redis etc.
+SQL databases store data in structured tables with fixed schemas and use SQL to query relationships between them, prioritizing consistency and complex querying. NoSQL databases store data in more flexible formats, like documents, key-value pairs, or graphs, and generally prioritize horizontal scalability and flexible schemas over strict consistency guarantees.

 Visit the following resources to learn more:

 - [@video@SQL vs. NoSQL: What's the difference?](https://www.youtube.com/watch?v=Q5aTUc7c4jg)
+- [@feed@Types of NoSQL Databases: How to Choose the Right One](https://roadmap.sh/backend/types-of-nosql-databases)
 - [@video@Database Design Tips | Choosing the Best Database in a System Design Interview](https://www.youtube.com/watch?v=cODCpXtPHbQ&t=22s)
- [@video@NoSQL vs SQL – Which Type of Database Should You Use?](https://www.youtube.com/watch?v=FzlpwoeSrE0)
- [@feed@Explore top posts about NoSQL](https://app.daily.dev/tags/nosql?ref=roadmapsh)
+- [@video@NoSQL vs SQL – Which Type of Database Should You Use?](https://www.youtube.com/watch?v=FzlpwoeSrE0)
@@ -5,5 +5,4 @@ Server-Sent Events is a server push technology enabling a client to receive auto
 Visit the following resources to learn more:

 - [@article@What is Server-Sent Events (SSE) and how to implement it?](https://medium.com/yemeksepeti-teknoloji/what-is-server-sent-events-sse-and-how-to-implement-it-904938bffd73)
- [@article@Using server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
- [@feed@Explore top posts about Cryptography](https://app.daily.dev/tags/cryptography?ref=roadmapsh)
+- [@article@Using server-sent events](https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events/Using_server-sent_events)
@@ -7,5 +7,4 @@ Visit the following resources to learn more:
 - [@course@Suffix Arrays - Coursera](https://www.coursera.org/learn/algorithms-part2/lecture/TH18W/suffix-arrays)
 - [@article@Suffix Arrays - Princeton University](https://algs4.cs.princeton.edu/63suffix/)
 - [@video@Suffix Array Introduction](https://www.youtube.com/watch?v=zqKlL3ZpTqs)
- [@video@Advanced Data Structures: Suffix Arrays](https://www.youtube.com/watch?v=IzMxbboPcqQ)
- [@video@Suffix Arrays: building](https://www.youtube.com/watch?v=ZWlbhBjjwyA)
+- [@video@Advanced Data Structures: Suffix Arrays](https://www.youtube.com/watch?v=IzMxbboPcqQ)
@@ -4,9 +4,7 @@ System design is the process of defining the architecture, modules, interfaces,

 Visit the following resources to learn more:

- [@opensource@System Design Primer](https://github.com/donnemartin/system-design-primer)
+- [@roadmap@Visit the Dedicated System Design Roadmap](https://roadmap.sh/system-design)
 - [@article@System Design: The Complete Course](https://dev.to/karanpratapsingh/system-design-the-complete-course-10fo)
 - [@video@System Design 101](https://www.youtube.com/watch?v=Y-Gl4HEyeUQ)
- [@video@Scaling the Unscalable](https://www.youtube.com/watch?v=a2rcgzludDU)
- [@video@System Design interview: Scale to 1 million users](https://www.youtube.com/watch?v=YkGHxOg9d3M)
- [@feed@Explore top posts about Career](https://app.daily.dev/tags/career?ref=roadmapsh)
+- [@video@Scaling the Unscalable](https://www.youtube.com/watch?v=a2rcgzludDU)
@@ -1,6 +1,6 @@
 # Tree

-A tree is non-linear and a hierarchical data structure consisting of a collection of nodes such that each node of the tree stores a value and a list of references to other nodes (the “children”).
+A tree is a hierarchical data structure made of nodes connected by edges, with one node designated as the root and every other node reachable from it through exactly one path. Each node can have child nodes, and nodes with no children are called leaves. Trees are used to represent hierarchical relationships and support efficient searching, insertion, and deletion when balanced.

 Visit the following resources to learn more:

@@ -7,9 +7,4 @@ Visit the following resources to learn more:
 - [@course@0. Tries - Coursera](https://www.coursera.org/learn/algorithms-part2/home/week/4)
 - [@course@1. R Way Tries](https://www.coursera.org/learn/algorithms-part2/lecture/CPVdr/r-way-tries)
 - [@course@2. Ternary Search Tries](https://www.coursera.org/learn/algorithms-part2/lecture/yQM8K/ternary-search-tries)
- [@course@3. Character Based Operations](https://www.coursera.org/learn/algorithms-part2/lecture/jwNmV/character-based-operations)
- [@article@Tries - DataStructure Notes](http://www.cs.yale.edu/homes/aspnes/classes/223/notes.html#Tries)
- [@article@The Trie: A Neglected Data Structure](https://www.toptal.com/java/the-trie-a-neglected-data-structure)
- [@article@TopCoder - Using Tries](https://www.topcoder.com/thrive/articles/Using%20Tries)
- [@video@Stanford Lecture (real world use case)](https://www.youtube.com/watch?v=TJ8SkcUSdbU)
- [@video@MIT, Advanced Data Structures, Strings (can get pretty obscure about halfway through)](https://www.youtube.com/watch?v=NinWEPPrkDQ&index=16&list=PLUl4u3cNGP61hsJNdULdudlRL493b-XZf)
+- [@course@3. Character Based Operations](https://www.coursera.org/learn/algorithms-part2/lecture/jwNmV/character-based-operations)
@@ -1,6 +1,6 @@
 # Unbalanced Tree

-An unbalanced binary tree is one that is not balanced.
+An unbalanced tree has subtrees of very different heights, which can happen when data is inserted in a sorted or near-sorted order into a plain binary search tree. In the worst case, the tree degenerates into something resembling a linked list, and operations that should take O(log n) instead take O(n). Self-balancing tree variants exist specifically to prevent this.

 Visit the following resources to learn more:

@@ -1,12 +1,6 @@
 # Usecase Diagrams

-Usecase diagrams are a type of diagram that are used to model the interactions between the **actors** and the **usecases** of the system.
-
-An actor is a person or a system that interacts with the system. Actors are represented by a rectangle with the name of the actor written inside it.
-
-A usecase is a task that the system performs. Usecases are represented by an ellipse with the name of the usecase written inside it.
-
-A usecase diagram is a diagram that shows the actors and the usecases of the system. The diagram is represented by a rectangle that contains the name of the system inside it. The actors are represented by rectangles and the usecases are represented by ellipses.
+A use case diagram shows the interactions between actors, such as users or external systems, and the use cases, or goals, they can achieve within a system. It gives a high-level view of what a system does from the perspective of the people or systems that use it, without describing implementation details.

 Visit the following resources to learn more:

@@ -5,4 +5,5 @@ Web sockets are a bidirectional communication protocol between a client and a se
 Visit the following resources to learn more:

 - [@article@WebSockets](https://en.wikipedia.org/wiki/WebSocket)
+- [@article@WebSocket vs HTTP: Which Protocol Should You Use?](https://roadmap.sh/network-engineer/websocket-vs-http)
 - [@article@Web Sockets API](https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API)