info/developer-roadmap
1
0
Fork 0
mirror of https://github.com/kamranahmedse/developer-roadmap.git synced 2025-09-06 23:30:42 +02:00
Code Issues Releases Wiki Activity

chore: update roadmap content json (#8829)

Browse Source 
Co-authored-by: kamranahmedse <4921183+kamranahmedse@users.noreply.github.com>
This commit is contained in:
github-actions[bot]
2025-06-30 16:13:48 +01:00
committed by GitHub
parent 90ccd44e22
commit 14425bb18a
26 changed files with 1524 additions and 793 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
public/roadmap-content/ai-data-scientist.json
View File

@@ -312,8 +312,8 @@
"type": "article"
},
{
"title": "Exploratory Data Analysis with Seaborn",
"url": "https://imp.i384100.net/ZQmMgR",
"title": "Python for Data Visualization: Matplotlib & Seaborn",
"url": "https://imp.i384100.net/55xvzn",
"type": "article"
}
]

10
public/roadmap-content/android.json
View File

@@ -29,11 +29,6 @@
"url": "https://kotlinlang.org/docs/home.html",
"type": "article"
},
{
"title": "Learn Kotlin - w3schools",
"url": "https://www.w3schools.com/kotlin/",
"type": "article"
},
{
"title": "Learn Kotlin Programming for Beginners - Free Code Camp",
"url": "https://youtu.be/EExSSotojVI?si=4VPW8ZHa2UMX0HH1",
@@ -107,11 +102,6 @@
"title": "Kotlin Docs",
"url": "https://kotlinlang.org/docs/getting-started.html",
"type": "article"
},
{
"title": "Kotlin Tutorial for Beginners",
"url": "https://www.w3schools.com/kotlin/index.php",
"type": "article"
}
]
},

5
public/roadmap-content/api-design.json
View File

@@ -86,11 +86,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/HTTP/Methods",
"type": "article"
},
{
"title": "HTTP Request Methods - W3Schools",
"url": "https://www.w3schools.com/tags/ref_httpmethods.asp",
"type": "article"
},
{
"title": "What are HTTP Methods? - Postman",
"url": "https://blog.postman.com/what-are-http-methods/",

45
public/roadmap-content/aspnet-core.json
View File

@@ -34,16 +34,6 @@
"url": "https://learn.microsoft.com/en-us/dotnet/csharp//",
"type": "article"
},
{
"title": "The Beginners Guide to C#",
"url": "https://www.w3schools.com/CS/index.php",
"type": "article"
},
{
"title": "C# Tutorial",
"url": "https://www.w3schools.com/cs/index.php",
"type": "article"
},
{
"title": "Explore top posts about C#",
"url": "https://app.daily.dev/tags/csharp?ref=roadmapsh",
@@ -117,11 +107,6 @@
"url": "https://dotnettutorials.net/course/csharp-dot-net-tutorials/",
"type": "article"
},
{
"title": "C# tutorials - W3Schools",
"url": "https://www.w3schools.com/cs/index.php",
"type": "article"
},
{
"title": "Explore top posts about C#",
"url": "https://app.daily.dev/tags/csharp?ref=roadmapsh",
@@ -298,11 +283,6 @@
"title": "SQL Basics",
"description": "SQL stands for Structured Query Language. SQL lets you access and manipulate databases SQL became a standard of the American National Standards Institute (ANSI) in 1986, and of the International Organization for Standardization (ISO) in 1987.\n\nAlthough SQL is an ANSI/ISO standard, there are different versions of the SQL language.\n\nHowever, to be compliant with the ANSI standard, they all support at least the major commands (such as SELECT, UPDATE, DELETE, INSERT, WHERE) in a similar manner.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Introduction to SQL",
"url": "https://www.w3schools.com/sql/sql_intro.asp",
"type": "article"
},
{
"title": "Explore top posts about SQL",
"url": "https://app.daily.dev/tags/sql?ref=roadmapsh",
@@ -340,11 +320,6 @@
"title": "Stored Procedures",
"description": "A stored procedure is a pre-compiled collection of SQL statements that can be executed on a database server. Stored procedures are typically used to perform specific tasks, such as retrieving data from a database, inserting or updating data, or performing complex calculations. They are stored on the database server and can be called or executed from a client application or other stored procedures. Stored procedures can improve database performance by reducing the amount of SQL code needed to be executed and allowing developers to reuse common pieces of code. They can also provide security by allowing database administrators to control which users have access to specific stored procedures.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Stored Procedure Tutorial",
"url": "https://www.w3schools.com/sql/sql_stored_procedures.asp",
"type": "article"
},
{
"title": "Stored Procedure in SQL: Benefits And How to Create It",
"url": "https://www.simplilearn.com/tutorials/sql-tutorial/stored-procedure-in-sql",
@@ -361,11 +336,6 @@
"title": "Constraints",
"description": "Database constraints are rules that are used to limit the data that can be stored in a database table. These constraints can be used to ensure the integrity and accuracy of the data in the table, and they can be used to enforce business rules or other requirements. For example, a constraint might be used to ensure that a column only contains positive numbers, or to ensure that a column always has a unique value. Constraints can be specified at the time a table is created, or they can be added to an existing table. Some common types of constraints include primary keys, foreign keys, and NOT NULL constraints.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "SQL Constraints",
"url": "https://www.w3schools.com/sql/sql_constraints.asp",
"type": "article"
},
{
"title": "Constraints of SQL",
"url": "https://www.educative.io/courses/database-design-fundamentals/m7JnY9Xm6Qp",
@@ -1131,11 +1101,6 @@
"url": "https://learn.microsoft.com/en-us/aspnet/web-pages/overview/data/5-working-with-data",
"type": "article"
},
{
"title": "ASP.NET Web Pages - Databases",
"url": "https://www.w3schools.com/asp/webpages_database.asp",
"type": "article"
},
{
"title": "Explore top posts about Backend Development",
"url": "https://app.daily.dev/tags/backend?ref=roadmapsh",
@@ -1330,11 +1295,6 @@
"url": "https://docs.microsoft.com/en-us/sql/sql-server/tutorials-for-sql-server-2016?view=sql-server-ver15",
"type": "article"
},
{
"title": "Getting started with SQL",
"url": "https://www.w3schools.com/sql/default.asp",
"type": "article"
},
{
"title": "Explore top posts about SQL",
"url": "https://app.daily.dev/tags/sql?ref=roadmapsh",
@@ -2716,11 +2676,6 @@
"title": "Razor",
"description": "Razor is a markup syntax for embedding server-side code in web pages. It was introduced with [ASP.NET](http://ASP.NET) MVC 3 and later became a part of [ASP.NET](http://ASP.NET) Web Pages. It allows developers to write server-side code using C# or Visual Basic and embed it in HTML markup. Its syntax is designed to be compact and easy to read. It provides a rich set of features for building web applications, such as a component model for building reusable UI, a routing system for navigation, and support for dependency injection, it also allows you to use the same libraries, frameworks, and tools that you're already familiar with from building traditional [ASP.NET](http://ASP.NET) web applications.\n\nTo learn more, visit the following links:",
"links": [
{
"title": "Complete Guide to ASP.NET Razor",
"url": "https://w3schools.com/asp/razor_intro.asp",
"type": "article"
},
{
"title": "Introduction to ASP.NET Web Programming Using Razor",
"url": "https://learn.microsoft.com/en-us/aspnet/web-pages/overview/getting-started/introducing-razor-syntax-c",

25
public/roadmap-content/backend.json
View File

@@ -133,11 +133,6 @@
"url": "https://php.net/",
"type": "article"
},
{
"title": "Learn PHP - W3Schools",
"url": "https://www.w3schools.com/php/",
"type": "article"
},
{
"title": "PHP - The Right Way",
"url": "https://phptherightway.com/",
@@ -236,11 +231,6 @@
"url": "https://www.java.com/",
"type": "article"
},
{
"title": "W3 Schools Tutorials",
"url": "https://www.w3schools.com/java/",
"type": "article"
},
{
"title": "Explore top posts about Java",
"url": "https://app.daily.dev/tags/java?ref=roadmapsh",
@@ -303,11 +293,6 @@
"url": "https://learn.microsoft.com/en-us/dotnet/csharp/tour-of-csharp/",
"type": "article"
},
{
"title": "C# on W3 schools",
"url": "https://www.w3schools.com/cs/index.php",
"type": "article"
},
{
"title": "Explore top posts about C#",
"url": "https://app.daily.dev/tags/csharp?ref=roadmapsh",
@@ -613,11 +598,6 @@
"url": "https://www.mysql.com/",
"type": "article"
},
{
"title": "W3Schools - MySQL Tutorial",
"url": "https://www.w3schools.com/mySQl/default.asp",
"type": "article"
},
{
"title": "MySQL for Developers",
"url": "https://planetscale.com/courses/mysql-for-developers/introduction/course-introduction",
@@ -1089,11 +1069,6 @@
"title": "SOAP",
"description": "Simple Object Access Protocol (SOAP) is a message protocol for exchanging information between systems and applications. When it comes to application programming interfaces (APIs), a SOAP API is developed in a more structured and formalized way. SOAP messages can be carried over a variety of lower-level protocols, including the web-related Hypertext Transfer Protocol (HTTP).\n\nVisit the following resources to learn more:",
"links": [
{
"title": "w3school SOAP explanation",
"url": "https://www.w3schools.com/xml/xml_soap.asp",
"type": "article"
},
{
"title": "REST vs SOAP",
"url": "https://www.youtube.com/watch?v=_fq8Ye8kodA",

10
public/roadmap-content/blockchain.json
View File

@@ -2249,11 +2249,6 @@
"url": "https://www.docs.python.org/3",
"type": "article"
},
{
"title": "W3Schools - Python Tutorial",
"url": "https://www.w3schools.com/python/",
"type": "article"
},
{
"title": "Python Crash Course",
"url": "https://ehmatthes.github.io/pcc/",
@@ -2290,11 +2285,6 @@
"url": "https://gobyexample.com/",
"type": "article"
},
{
"title": "W3Schools Go Tutorial",
"url": "https://www.w3schools.com/go/",
"type": "article"
},
{
"title": "Explore top posts about Golang",
"url": "https://app.daily.dev/tags/golang?ref=roadmapsh",

40
public/roadmap-content/computer-science.json
View File

@@ -8,21 +8,11 @@
"url": "https://roadmap.sh/cpp",
"type": "article"
},
{
"title": "Learn C++ - W3Schools",
"url": "https://www.w3schools.com/cpp/",
"type": "article"
},
{
"title": "Learn C++ - Tutorials Point",
"url": "https://www.tutorialspoint.com/cplusplus/index.htm",
"type": "article"
},
{
"title": "Learn C - W3Schools",
"url": "https://www.w3schools.com/c/",
"type": "article"
},
{
"title": "Learn C - Tutorials Point",
"url": "https://www.tutorialspoint.com/cprogramming/index.htm",
@@ -79,11 +69,6 @@
"url": "https://pythonprinciples.com/",
"type": "article"
},
{
"title": "W3Schools - Python Tutorial ",
"url": "https://www.w3schools.com/python/",
"type": "article"
},
{
"title": "Python Crash Course",
"url": "https://ehmatthes.github.io/pcc/",
@@ -130,11 +115,6 @@
"url": "https://gobyexample.com/",
"type": "article"
},
{
"title": "W3Schools Go Tutorial",
"url": "https://www.w3schools.com/go/",
"type": "article"
},
{
"title": "Making a RESTful JSON API in Go",
"url": "https://thenewstack.io/make-a-restful-json-api-go/",
@@ -161,11 +141,6 @@
"url": "https://docs.microsoft.com/en-us/learn/paths/csharp-first-steps/?WT.mc_id=dotnet-35129-website",
"type": "article"
},
{
"title": "C# on W3 schools",
"url": "https://www.w3schools.com/cs/index.php",
"type": "article"
},
{
"title": "Introduction to C#",
"url": "https://docs.microsoft.com/en-us/shows/CSharp-101/?WT.mc_id=Educationalcsharp-c9-scottha",
@@ -248,11 +223,6 @@
"url": "https://www.tutorialspoint.com/cplusplus/index.htm",
"type": "article"
},
{
"title": "W3Schools C++",
"url": "https://www.w3schools.com/cpp/default.asp",
"type": "article"
},
{
"title": "Explore top posts about C++ Programming",
"url": "https://app.daily.dev/tags/c++?ref=roadmapsh",
@@ -264,11 +234,6 @@
"title": "C",
"description": "C is a general-purpose computer programming language. It was created in the 1970s by Dennis Ritchie, and remains very widely used and influential. By design, C's features cleanly reflect the capabilities of the targeted CPUs.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Learn C - W3Schools",
"url": "https://www.w3schools.com/c/",
"type": "article"
},
{
"title": "Learn C - Tutorials Point",
"url": "https://www.tutorialspoint.com/cprogramming/index.htm",
@@ -310,11 +275,6 @@
"url": "https://www.java.com/",
"type": "article"
},
{
"title": "W3 Schools Tutorials",
"url": "https://www.w3schools.com/java/",
"type": "article"
},
{
"title": "Explore top posts about Java",
"url": "https://app.daily.dev/tags/java?ref=roadmapsh",

10
public/roadmap-content/cpp.json
View File

@@ -29,11 +29,6 @@
"title": "What is C++?",
"description": "C++ is a general-purpose programming language created by Bjarne Stroustrup as an extension of the C programming language. It was first introduced in 1985 and provides object-oriented features like classes and inheritance. C++ is widely used in various applications like game development, system programming, embedded systems, and high-performance computing.\n\nC++ is a statically-typed language, meaning that the type of a variable is determined during compilation, and has an extensive library called the C++ Standard Library, which provides a rich set of functions, algorithms, and data structures for various tasks.\n\nC++ builds upon the features of C, and thus, most C programs can be compiled and run with a C++ compiler.\n\nCode Example\n------------\n\nHere's a simple example of a C++ program that demonstrates some essential features of the language:\n\n #include <iostream>\n \n // A simple function to add two numbers\n int add(int a, int b) {\n return a + b;\n }\n \n class Calculator {\n public:\n // A member function to multiply two numbers\n int multiply(int a, int b) {\n return a * b;\n }\n };\n \n int main() {\n int x = 5;\n int y = 3;\n \n // Using the standalone function 'add'\n int sum = add(x, y);\n std::cout << \"Sum: \" << sum << '\\n';\n \n // Using a class and member function\n Calculator calc;\n int product = calc.multiply(x, y);\n std::cout << \"Product: \" << product << '\\n';\n \n return 0;\n }\n \n\nIn the above program, we define a simple function `add` and a class `Calculator` with a member function `multiply`. The `main` function demonstrates how to use these to perform basic arithmetic.\n\nLearn more from the following resources:",
"links": [
{
"title": "w3schools C++ tutorial",
"url": "https://www.w3schools.com/cpp/",
"type": "article"
},
{
"title": "Learn C++",
"url": "https://www.learncpp.com/",
@@ -184,11 +179,6 @@
"title": "Function Overloading - Microsoft Learn",
"url": "https://learn.microsoft.com/en-us/cpp/cpp/function-overloading",
"type": "article"
},
{
"title": "C++ Function Overloading - W3Schools",
"url": "https://www.w3schools.com/cpp/cpp_function_overloading.asp",
"type": "article"
}
]
},

5
public/roadmap-content/data-analyst.json
View File

@@ -209,11 +209,6 @@
"title": "Microsoft Excel Course",
"url": "https://support.microsoft.com/en-us/office/excel-video-training-9bc05390-e94c-46af-a5b3-d7c22f6990bb",
"type": "course"
},
{
"title": "W3Schools - Excel",
"url": "https://www.w3schools.com/excel/index.php",
"type": "article"
}
]
},

65
public/roadmap-content/datastructures-and-algorithms.json
View File

@@ -13,26 +13,11 @@
"url": "https://roadmap.sh/javascript",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "The Modern JavaScript Tutorial",
"url": "https://javascript.info/",
"type": "article"
},
{
"title": "W3Schools – Node.js Tutorial",
"url": "https://www.w3schools.com/nodejs/",
"type": "article"
},
{
"title": "What is NPM?",
"url": "https://www.w3schools.com/nodejs/nodejs_npm.asp",
"type": "article"
},
{
"title": "Official Documentation",
"url": "https://nodejs.org/en/learn/getting-started/introduction-to-nodejs",
@@ -74,11 +59,6 @@
"url": "https://www.java.com/",
"type": "article"
},
{
"title": "W3 Schools Tutorials",
"url": "https://www.w3schools.com/java/",
"type": "article"
},
{
"title": "Explore top posts about Java",
"url": "https://app.daily.dev/tags/java?ref=roadmapsh",
@@ -120,11 +100,6 @@
"url": "https://gobyexample.com/",
"type": "article"
},
{
"title": "W3Schools Go Tutorial ",
"url": "https://www.w3schools.com/go/",
"type": "article"
},
{
"title": "Making a RESTful JSON API in Go",
"url": "https://thenewstack.io/make-a-restful-json-api-go/",
@@ -151,11 +126,6 @@
"url": "https://docs.microsoft.com/en-us/learn/paths/csharp-first-steps/?WT.mc_id=dotnet-35129-website",
"type": "article"
},
{
"title": "C# on W3 schools",
"url": "https://www.w3schools.com/cs/index.php",
"type": "article"
},
{
"title": "Introduction to C#",
"url": "https://docs.microsoft.com/en-us/shows/CSharp-101/?WT.mc_id=Educationalcsharp-c9-scottha",
@@ -228,11 +198,6 @@
"url": "https://pythonprinciples.com/",
"type": "article"
},
{
"title": "W3Schools - Python Tutorial ",
"url": "https://www.w3schools.com/python/",
"type": "article"
},
{
"title": "Python Crash Course",
"url": "https://ehmatthes.github.io/pcc/",
@@ -632,11 +597,6 @@
"title": "Bubble Sort",
"description": "Bubble Sort is a simple sorting algorithm that works by repeatedly swapping the adjacent elements if they are in the wrong order. It gets its name because with each iteration the largest element \"bubbles\" up to its proper location. It continues this process of swapping until the entire list is sorted in ascending order. The main steps of the algorithm are: starting from the beginning of the list, compare every pair of adjacent items and swap them if they are in the wrong order, and then pass through the list until no more swaps are needed. However, despite being simple, Bubble Sort is not suited for large datasets as it has a worst-case and average time complexity of O(n²), where n is the number of items being sorted.\n\nLearn more from the following resources:",
"links": [
{
"title": "Bubble Sort",
"url": "https://www.w3schools.com/dsa/dsa_algo_bubblesort.php",
"type": "article"
},
{
"title": "Bubble Sort Visualize",
"url": "https://www.hackerearth.com/practice/algorithms/sorting/bubble-sort/visualize/",
@@ -674,11 +634,6 @@
"title": "Insertion Sort",
"description": "Insertion sort is a simple sorting algorithm that builds the final sorted array (or list) one item at a time. It's much less efficient on large lists than more advanced algorithms like quicksort, heapsort, or merge sort. Still, it provides several advantages such as it's easy to understand the algorithm, it performs well with small lists or lists that are already partially sorted and it can sort the list as it receives it. The algorithm iterates, consuming one input element each repetition and growing a sorted output list. At each iteration, it removes one element from the input data, finds the location it belongs within the sorted list and inserts it there. It repeats until no input elements remain.",
"links": [
{
"title": "Insertion Sort - W3Schools",
"url": "https://www.w3schools.com/dsa/dsa_algo_insertionsort.php",
"type": "article"
},
{
"title": "Insertion Sort Visualization",
"url": "https://www.hackerearth.com/practice/algorithms/sorting/insertion-sort/visualize/",
@@ -716,11 +671,6 @@
"title": "Selection Sort",
"description": "Selection Sort is a simple and intuitive sorting algorithm. It works by dividing the array into two parts - sorted and unsorted. Initially, the sorted part is empty and the unsorted part contains all the elements. The algorithm repeatedly selects the smallest (or largest, if sorting in descending order) element from the unsorted part and moves that to the end of the sorted part. The process continues until the unsorted part becomes empty and the sorted part contains all the elements. Selection sort is not efficient on large lists, as its time complexity is O(n²) where n is the number of items.\n\nLearn more from the following resources:",
"links": [
{
"title": "Selection Sort - W3Schools",
"url": "https://www.w3schools.com/dsa/dsa_algo_selectionsort.php",
"type": "article"
},
{
"title": "Selection Sort Visualize",
"url": "https://www.hackerearth.com/practice/algorithms/sorting/selection-sort/practice-problems/",
@@ -758,11 +708,6 @@
"title": "Linear Search",
"description": "Linear search is one of the simplest search algorithms. In this method, every element in an array is checked sequentially starting from the first until a match is found or all elements have been checked. It is also known as sequential search. It works on both sorted and unsorted lists, and does not need any preconditioned list for the operation. However, its efficiency is lesser as compared to other search algorithms since it checks all elements one by one.\n\nLearn more from the following resources:",
"links": [
{
"title": "DSA Linear Search - W3Schools",
"url": "https://www.w3schools.com/dsa/dsa_algo_linearsearch.php",
"type": "article"
},
{
"title": "Learn Linear Search in 3 minutes",
"url": "https://www.youtube.com/watch?v=246V51AWwZM",
@@ -774,11 +719,6 @@
"title": "Binary Search",
"description": "`Binary Search` is a type of search algorithm that follows the divide and conquer strategy. It works on a sorted array by repeatedly dividing the search interval in half. Initially, the search space is the entire array and the target is compared with the middle element of the array. If they are not equal, the half in which the target cannot lie is eliminated and the search continues on the remaining half, again taking the middle element to compare to the target, and repeating this until the target is found. If the search ends with the remaining half being empty, the target is not in the array. Binary Search is log(n) as it cuts down the search space by half each step.\n\nLearn more from the following resources:",
"links": [
{
"title": "DSA Binary Search - W3Schools",
"url": "https://www.w3schools.com/dsa/dsa_algo_binarysearch.php",
"type": "article"
},
{
"title": "Learn Binary Search in 10 minutes",
"url": "https://www.youtube.com/watch?v=xrMppTpoqdw",
@@ -830,11 +770,6 @@
"title": "Binary Trees",
"description": "A **Binary Tree** is a type of tree data structure in which each node has at most two children, referred to as the left child and the right child. This distinguishes it from trees in which nodes can have any number of children. A binary tree is further classified as a strictly binary tree if every non-leaf node in the tree has non-empty left and right child nodes. A binary tree is complete if all levels of the tree, except possibly the last, are fully filled, and all nodes are as left-justified as possible. Multiple algorithms and functions employ binary trees due to their suitable properties for mathematical operations and data organization.\n\nLearn more from the following links:",
"links": [
{
"title": "Binary Tree",
"url": "https://www.w3schools.com/dsa/dsa_data_binarytrees.php",
"type": "article"
},
{
"title": "Binary Tree",
"url": "https://youtu.be/4r_XR9fUPhQ?si=PBsRjix_Z9kVHgMM",

15
public/roadmap-content/devops.json
View File

@@ -168,21 +168,11 @@
"url": "https://roadmap.sh/javascript",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "The Modern JavaScript Tutorial",
"url": "https://javascript.info/",
"type": "article"
},
{
"title": "What is NPM?",
"url": "https://www.w3schools.com/nodejs/nodejs_npm.asp",
"type": "article"
},
{
"title": "Explore top posts about JavaScript",
"url": "https://app.daily.dev/tags/javascript?ref=roadmapsh",
@@ -770,11 +760,6 @@
"url": "https://bitbucket.org/product/guides/getting-started/overview",
"type": "article"
},
{
"title": "Git and Bitbucket Introduction",
"url": "https://www.w3schools.com/git/git_intro.asp?remote=bitbucket",
"type": "article"
},
{
"title": "Explore top posts about Bitbucket",
"url": "https://app.daily.dev/tags/bitbucket?ref=roadmapsh",

35
public/roadmap-content/frontend.json
View File

@@ -175,11 +175,6 @@
"url": "https://www.freecodecamp.org/learn/2022/responsive-web-design/",
"type": "course"
},
{
"title": "W3Schools: Learn HTML",
"url": "https://www.w3schools.com/html/html_intro.asp",
"type": "article"
},
{
"title": "Explore top posts about HTML",
"url": "https://app.daily.dev/tags/html?ref=roadmapsh",
@@ -201,11 +196,6 @@
"title": "Learn the basics",
"description": "HTML (HyperText Markup Language) is the backbone of webpages. It structures the content you see online. You use CSS to style this HTML structure and JavaScript to make it interactive. Think of HTML as the skeleton of a website.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools: Learn HTML",
"url": "https://www.w3schools.com/html/html_intro.asp",
"type": "article"
},
{
"title": "web.dev: Learn HTML",
"url": "https://web.dev/learn/html",
@@ -227,11 +217,6 @@
"url": "https://cs.fyi/guide/writing-semantic-html",
"type": "article"
},
{
"title": "W3Schools: Semantic HTML",
"url": "https://www.w3schools.com/html/html5_semantic_elements.asp",
"type": "article"
},
{
"title": "Semantic HTML - web.dev",
"url": "https://web.dev/learn/html/semantic-html/",
@@ -257,11 +242,6 @@
"title": "Learn Forms by web.dev",
"url": "https://web.dev/learn/forms/",
"type": "article"
},
{
"title": "W3Schools: JavaScript Form Validation",
"url": "https://www.w3schools.com/js/js_validation.asp",
"type": "article"
}
]
},
@@ -347,11 +327,6 @@
"title": "Learn the basics",
"description": "CSS (Cascading Style Sheets) is the language for styling websites. It makes the frontend look good. Along with HTML and JavaScript, CSS is a key part of the World Wide Web. It controls colors, fonts, layout, and more to visually design webpages.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools — Learn CSS",
"url": "https://www.w3schools.com/css/",
"type": "article"
},
{
"title": "web.dev — Learn CSS",
"url": "https://web.dev/learn/css/",
@@ -508,11 +483,6 @@
"title": "Learn the Basics",
"description": "JavaScript makes webpages interactive. Think of sliders, what happens when you click something, or pop-up messages – that's often JavaScript at work. It adds dynamic behavior to the static structure created by HTML and styled by CSS.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "The Modern JavaScript Tutorial",
"url": "https://javascript.info/",
@@ -1737,11 +1707,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/Web_Components/Using_templates_and_slots",
"type": "article"
},
{
"title": "HTML Template Tag",
"url": "https://www.w3schools.com/tags/tag_template.asp",
"type": "article"
},
{
"title": "Explore top posts about HTML",
"url": "https://app.daily.dev/tags/html?ref=roadmapsh",

15
public/roadmap-content/full-stack.json
View File

@@ -3,11 +3,6 @@
"title": "HTML",
"description": "HTML stands for HyperText Markup Language. It is used on the frontend and gives the structure to the webpage which you can style using CSS and make interactive using JavaScript.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools: Learn HTML",
"url": "https://www.w3schools.com/html/html_intro.asp",
"type": "article"
},
{
"title": "Explore top posts about HTML",
"url": "https://app.daily.dev/tags/html?ref=roadmapsh",
@@ -29,11 +24,6 @@
"title": "CSS",
"description": "CSS or Cascading Style Sheets is the language used to style the frontend of any website. CSS is a cornerstone technology of the World Wide Web, alongside HTML and JavaScript.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools — Learn CSS",
"url": "https://www.w3schools.com/css/",
"type": "article"
},
{
"title": "Web.dev by Google — Learn CSS",
"url": "https://web.dev/learn/css/",
@@ -326,11 +316,6 @@
"url": "https://nodejs.org/en/learn/getting-started/introduction-to-nodejs",
"type": "article"
},
{
"title": "Node.JS Introduction",
"url": "https://www.w3schools.com/nodejs/nodejs_intro.asp",
"type": "article"
},
{
"title": "Explore top posts about Node.js",
"url": "https://app.daily.dev/tags/nodejs?ref=roadmapsh",

5
public/roadmap-content/java.json
View File

@@ -8,11 +8,6 @@
"url": "https://hyperskill.org/tracks/8",
"type": "course"
},
{
"title": "Java Basics - W3Schools",
"url": "https://www.w3schools.com/java/",
"type": "article"
},
{
"title": "Head First Java",
"url": "https://www.amazon.co.uk/Head-First-Java-3rd-Brain-Friendly/dp/1491910771",

175
public/roadmap-content/javascript.json
View File

@@ -13,11 +13,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "The Modern JavaScript Tutorial",
"url": "https://javascript.info/",
@@ -59,11 +54,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "The Modern JavaScript Tutorial",
"url": "https://javascript.info/",
@@ -136,11 +126,6 @@
"url": "https://roadmap.sh/guides/history-of-javascript",
"type": "article"
},
{
"title": "JavaScript Version",
"url": "https://www.w3schools.com/js/js_versions.asp",
"type": "article"
},
{
"title": "Explore top posts about JavaScript",
"url": "https://app.daily.dev/tags/javascript?ref=roadmapsh",
@@ -246,11 +231,6 @@
"title": "Variable Scopes",
"description": "In JavaScript, scope refers to the visibility of a variable or how it can be used after it is declared. The scope of a variable depends on the keyword that was used to declare it.\n\nThe three types of Scope are Global Scope, Function Scope, and Block Scope. Before ES6 (2015), JavaScript had only Global Scope and Function Scope with the `var` keyword. ES6 introduced `let` and `const` which allow Block Scope in JavaScript.\n\nGlobal Scope: Variables declared outside any function or curly braces '{}' have Global Scope, and can be accessed from anywhere within the same Javascript code. `var`, `let` and `const` all provide this Scope.\n\nFunction Scope: Variables declared within a function can only be used within that same function. Outside that function, they are undefined. `var`, `let` and `const` all provide this Scope.\n\nBlock Scope: A block is any part of JavaScript code bounded by '{}'. Variables declared within a block can not be accessed outside that block. This Scope is only provided by the `let` and `const` keywords. If you declare a variable within a block using the `var` keyword, it will NOT have Block Scope.\n\nLocal Scope: Local variables are only recognized inside their functions, variables with the same name can be used in different functions. Local variables are created when a function starts, and deleted when the function is completed. `var`, `let` and `const` all provide this Scope.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JavaScript Scope",
"url": "https://www.w3schools.com/js/js_scope.asp",
"type": "article"
},
{
"title": "javascript scope",
"url": "https://wesbos.com/javascript/03-the-tricky-bits/scope",
@@ -277,11 +257,6 @@
"url": "https://javascript.info/variables",
"type": "article"
},
{
"title": "JavaScript Variables - W3Schools",
"url": "https://www.w3schools.com/js/js_variables.asp",
"type": "article"
},
{
"title": "Declaring Variables without Var, Let, Const - What Would Happen?",
"url": "https://www.youtube.com/watch?v=6UAKBYpUC-Y",
@@ -341,11 +316,6 @@
"title": "Function",
"description": "When a variable is declared inside a function, it is only accessible within that function and cannot be used outside that function.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JavaScript Scope",
"url": "https://www.w3schools.com/js/js_scope.asp",
"type": "article"
},
{
"title": "Function Scope & Block Scope in JS",
"url": "https://medium.com/nerd-for-tech/function-scope-block-scope-in-js-d29c8e7cd216",
@@ -356,13 +326,7 @@
"oC4o6GLEES_nUgCJu9Q6I": {
"title": "Global",
"description": "Variables declared Globally (outside any function) have Global Scope. Global variables can be accessed from anywhere in a JavaScript program. Variables declared with `var`, `let` and `const` are quite similar when declared outside a block.\n\nNote\n----\n\nIf you assign a value to a variable that has not been declared i.e `potato = true` it will automatically become a _GLOBAL_ variable.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JavaScript Scope",
"url": "https://www.w3schools.com/js/js_scope.asp",
"type": "article"
}
]
"links": []
},
"kvActjpU4FUJdrmuFoFEe": {
"title": "All about Variables",
@@ -399,11 +363,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Data_structures",
"type": "article"
},
{
"title": "JavaScript Data Types",
"url": "https://www.w3schools.com/js/js_datatypes.asp",
"type": "article"
},
{
"title": "JavaScript Data Types",
"url": "https://javascript.info/types",
@@ -535,11 +494,6 @@
"title": "Working with Objects",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Working_with_Objects",
"type": "article"
},
{
"title": "JavaScript Object Definition",
"url": "https://www.w3schools.com/js/js_object_definition.asp",
"type": "article"
}
]
},
@@ -593,11 +547,6 @@
"title": "typeof Reference",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/typeof",
"type": "article"
},
{
"title": "typeof Live Examples",
"url": "https://www.w3schools.com/js/tryit.asp?filename=tryjs_typeof_all",
"type": "article"
}
]
},
@@ -626,11 +575,6 @@
"url": "https://javascript.info/type-conversions",
"type": "article"
},
{
"title": "JavaScript Type Conversion",
"url": "https://www.w3schools.com/js/js_type_conversion.asp",
"type": "article"
},
{
"title": "Type Casting in JavaScript",
"url": "https://www.tutorialspoint.com/type-casting-in-javascript",
@@ -694,11 +638,6 @@
"title": "Implicit Type Casting",
"description": "Implicit type conversion happens when the compiler or runtime automatically converts data types. JavaScript is loosely typed language and most of the time operators automatically convert a value to the right type.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools - JavaScript Tutorials",
"url": "https://www.w3schools.com/js/js_type_conversion.asp",
"type": "article"
},
{
"title": "TutorialsPoint - JavaScript Tutorials",
"url": "https://www.tutorialspoint.com/explain-typecasting-in-javascript",
@@ -926,11 +865,6 @@
"title": "Equality Comparisons",
"description": "Comparison operators are used in logical statements to determine equality or difference between variables or values. Comparison operators can be used in conditional statements to compare values and take action depending on the result.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JavaScript Comparisons",
"url": "https://www.w3schools.com/js/js_comparisons.asp",
"type": "article"
},
{
"title": "JavaScript Equality Operators",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators#equality_operators",
@@ -1059,11 +993,6 @@
"title": "do...while - MDN",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/do...while",
"type": "article"
},
{
"title": "JavaScript do...while Loop - W3Schools",
"url": "https://www.w3schools.com/jsref/jsref_dowhile.asp",
"type": "article"
}
]
},
@@ -1123,11 +1052,6 @@
"title": "JavaScript MDN Docs - break statement",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/break",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/js_break.asp",
"type": "article"
}
]
},
@@ -1220,11 +1144,6 @@
"title": "throw statement",
"description": "The throw statement throws a user-defined exception. Execution of the current function will stop (the statements after throw won't be executed), and control will be passed to the first catch block in the call stack. If no catch block exists among caller functions, the program will terminate. (excerpt from MDN)\n\nVisit the following resources to learn more:",
"links": [
{
"title": "throw statement - w3schools",
"url": "https://www.w3schools.com/jsref/jsref_throw.asp",
"type": "article"
},
{
"title": "JavaScript MDN Docs",
"url": "https://developer.mozilla.org/en-us/docs/web/javascript/reference/statements/throw",
@@ -1245,13 +1164,7 @@
"rbjEZe5vxCJ8reI1oZ-jf": {
"title": "try/catch/finally",
"description": "These are ways of handling errors in your JavaScript code. Inside the try code block we have the code to run, inside the catch block we handle the errors, and inside the finally block we have code that runs after the execution of the previous code blocks, regardless of the result.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JavaScript Errors",
"url": "https://www.w3schools.com/js/js_errors.asp",
"type": "article"
}
]
"links": []
},
"-z-4VTaC3tOThqChgyoMs": {
"title": "Error Objects",
@@ -1335,11 +1248,6 @@
"title": "Comparison Operators",
"description": "Comparison operators are the operators that compare values and return true or false. The operators include: `>`, `<`, `>=`, `<=`, `==`, `===`, `!=` and `!==`\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools - JavaScript Tutorials",
"url": "https://www.w3schools.com/js/js_comparisons.asp",
"type": "article"
},
{
"title": "JavaScript MDN Docs",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#comparison_operators",
@@ -1360,11 +1268,6 @@
"title": "Arithmetic Operators - JavaScript.info",
"url": "https://javascript.info/operators#maths",
"type": "article"
},
{
"title": "JavaScript Arithmetic Operators",
"url": "https://www.w3schools.com/js/js_arithmetic.asp",
"type": "article"
}
]
},
@@ -1430,11 +1333,6 @@
"title": "JavaScript MDN Docs",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#conditional_operator",
"type": "article"
},
{
"title": "W3Schools - JavaScript Tutorials",
"url": "https://www.w3schools.com/js/js_comparisons.asp",
"type": "article"
}
]
},
@@ -1510,11 +1408,6 @@
"title": "MDN - Arrow Function Expressions",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions",
"type": "article"
},
{
"title": "JavaScript Arrow Function",
"url": "https://www.w3schools.com/js/js_arrow_function.asp",
"type": "article"
}
]
},
@@ -1692,11 +1585,6 @@
"title": "Using (this) keyword",
"description": "In JavaScript, the `this` keyword is a little different compared to other languages. It refers to an object, but it depends on how or where it is being invoked. It also has some differences between strict mode and non-strict mode.\n\n* In an object method, `this` refers to the object\n* Alone, `this` refers to the global object\n* In a function, `this` refers to the global object\n* In a function, in strict mode, `this` is undefined\n* In an event, `this` refers to the element that received the event\n* Methods like call(), apply(), and bind() can refer `this` to any object\n\nVisit the following resources to learn more:",
"links": [
{
"title": "The JavaScript this Keyword",
"url": "https://www.w3schools.com/js/js_this.asp",
"type": "article"
},
{
"title": "This Keyword",
"url": "https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/this",
@@ -1717,46 +1605,23 @@
"title": "this in methods",
"url": "https://javascript.info/object-methods#this-in-methods",
"type": "article"
},
{
"title": "Short and clear post about the this keyword",
"url": "https://www.w3schools.com/js/js_this.asp",
"type": "article"
}
]
},
"azsXq6Y5iCvQDgTWZpWQ3": {
"title": "in a function",
"description": "The keyword `this` when used in a function refers to the global object.\n\n_Note: in a browser window the global object is the `window` object._\n\nVisit the following resources to learn more:",
"links": [
{
"title": "this in a function",
"url": "https://www.w3schools.com/js/js_this.asp",
"type": "article"
}
]
"links": []
},
"qps2Mdm-lwa4Wr0IxKm0C": {
"title": "using it alone",
"description": "The keyword `this` when used alone refers to the global object.\n\n_Note: in a browser window the global object is the `window` object._\n\nVisit the following resources to learn more:",
"links": [
{
"title": "this Alone",
"url": "https://www.w3schools.com/js/js_this.asp",
"type": "article"
}
]
"links": []
},
"JVbEBtVrTTFnTF3_yUIAC": {
"title": "in event handlers",
"description": "The keyword `this` when used in an event handler refers to the element that received the event.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "this in Event handlers",
"url": "https://www.w3schools.com/js/js_this.asp",
"type": "article"
}
]
"links": []
},
"P0190rTm2wLQmCzWOKour": {
"title": "in arrow functions",
@@ -1836,11 +1701,6 @@
"title": "Function binding",
"url": "https://javascript.info/bind",
"type": "article"
},
{
"title": "Javascript Function Bind()",
"url": "https://www.w3schools.com/js/js_function_bind.asp",
"type": "article"
}
]
},
@@ -1905,11 +1765,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/API/setTimeout",
"type": "article"
},
{
"title": "W3Schools – JavaScript - setTimeOut",
"url": "https://www.w3schools.com/jsref/met_win_settimeout.asp",
"type": "article"
},
{
"title": "setInterval and setTimeout: timing events",
"url": "https://www.youtube.com/watch?v=kOcFZV3c75I",
@@ -1946,11 +1801,6 @@
"title": "Callback Functions",
"url": "https://developer.mozilla.org/en-US/docs/Glossary/Callback_function",
"type": "article"
},
{
"title": "W3School CallBack Function",
"url": "https://www.w3schools.com/js/js_callback.asp",
"type": "article"
}
]
},
@@ -2057,11 +1907,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch",
"type": "article"
},
{
"title": "Fetch W3school Docs",
"url": "https://www.w3schools.com/jsref/api_fetch.asp",
"type": "article"
},
{
"title": "Network request - Fetch",
"url": "https://javascript.info/fetch",
@@ -2087,11 +1932,6 @@
"title": "Network request - XMLHttpRequest",
"url": "https://javascript.info/xmlhttprequest",
"type": "article"
},
{
"title": "W3Schools",
"url": "https://www.w3schools.com/xml/xml_http.asp",
"type": "article"
}
]
},
@@ -2260,11 +2100,6 @@
"title": "DOM- MDN Docs",
"url": "https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model",
"type": "article"
},
{
"title": "Web APIs- W3schools",
"url": "https://www.w3schools.com/js/js_api_intro.asp",
"type": "article"
}
]
},

532
public/roadmap-content/mongodb.json Normal file
View File

@@ -0,0 +1,532 @@
{
"z50iixpcCMe9sTh-gwTI3": {
"title": "MongoDB Basics",
"description": "",
"links": []
},
"cMfsRtvzvDZZJ0TqeUOxm": {
"title": "SQL vs NoSQL",
"description": "",
"links": []
},
"tJljSlb5S_tZLZhZHHd_I": {
"title": "What is MongoDB?",
"description": "",
"links": []
},
"qh8MEbXKPVt8mqlarhUj0": {
"title": "When to use MongoDB?",
"description": "MongoDB is ideal for applications that require flexible schema design, rapid development cycles, and need to handle large volumes of unstructured or semi-structured data. It's particularly well-suited for content management systems, real-time analytics, IoT applications, mobile app backends, and scenarios where you need to scale horizontally across multiple servers, making it an excellent choice when your data model is likely to evolve frequently or when you're dealing with complex nested data structures that don't fit well into traditional relational database tables.",
"links": []
},
"1UXfFROvcunyhkx0zB_1S": {
"title": "What is MongoDB Atlas?",
"description": "",
"links": []
},
"1pCWjSvjvbox5OpyWJ8Kv": {
"title": "MongoDB Terminology",
"description": "MongoDB terminology includes key concepts: databases contain collections (equivalent to tables), which store documents (equivalent to rows) composed of field-value pairs. Other terms include indexes for performance optimization, replica sets for high availability, shards for horizontal scaling, aggregation pipelines for data processing, and ObjectIds for unique document identifiers. Understanding these terms is fundamental for MongoDB development.",
"links": []
},
"_UIfRdlj6BeEESw1FW9RH": {
"title": "Data Model & Data Types",
"description": "MongoDB uses a flexible document data model storing data in BSON format with rich data types including strings, numbers, dates, arrays, embedded documents, binary data, and ObjectIds. The schema-less design allows varying document structures within collections while maintaining query performance. Documents can contain nested objects and arrays, enabling complex data relationships without traditional table joins.",
"links": []
},
"F4W9XBSbkpzWIrAhRBSRS": {
"title": "BSON vs JSON",
"description": "BSON (Binary JSON) is MongoDB's binary-encoded serialization format that extends JSON with additional data types like dates, binary data, and 64-bit integers. While JSON is human-readable text format, BSON provides faster parsing, compact storage, and native support for MongoDB's rich data types. BSON enables efficient storage and retrieval while maintaining JSON's flexibility and document structure.",
"links": []
},
"6MqhN-PTf1PRzYCTxC8pn": {
"title": "Embedded Objects & Arrays",
"description": "Embedded objects and arrays in MongoDB enable storing related data within a single document, eliminating the need for separate collections and joins. This design pattern improves query performance and maintains data locality. Embedded structures support nested queries, array operations, and complex data relationships while maintaining document atomicity and enabling efficient retrieval of complete entities.",
"links": []
},
"4Cf_wcoByPqpOOpdbAJuq": {
"title": "Double",
"description": "Double data type in MongoDB stores 64-bit floating-point numbers following IEEE 754 standard, providing high precision for decimal calculations. It's the default numeric type for JavaScript numbers and handles both integers and decimals. Doubles support mathematical operations in queries and aggregation pipelines, though precision limitations may occur with very large numbers or repeated calculations requiring exact decimal representation.",
"links": []
},
"eU4XCnrf27FO3KCda8QYw": {
"title": "String",
"description": "String data type in MongoDB stores UTF-8 encoded text data with no length restrictions within document size limits. Strings support text indexing for search capabilities, regex pattern matching, and various string manipulation operations in aggregation pipelines. MongoDB strings are case-sensitive by default but support collation options for case-insensitive comparisons and locale-specific sorting requirements.",
"links": []
},
"q6ZKxFcSAQ8bgUdGaDpuu": {
"title": "Array",
"description": "Array data type in MongoDB stores ordered lists of values including mixed data types, nested arrays, and embedded documents. Arrays support indexing with multikey indexes, enabling efficient queries on array elements. Special array operators like $push, $pull, $addToSet modify arrays, while query operators like $in, $all, $elemMatch enable sophisticated array querying and element matching capabilities.",
"links": []
},
"QcdZKNcCtKls6P4YNXR2W": {
"title": "Object",
"description": "",
"links": []
},
"UM6jH6bAijYS0Hmw87UQ-": {
"title": "Binary Data",
"description": "Binary data in MongoDB stores non-textual data like images, files, and encoded content using the BSON Binary data type. It supports various subtypes including generic binary, function code, UUID, and MD5 hashes. Binary data enables efficient storage of multimedia content, encrypted data, and arbitrary byte sequences while maintaining query and indexing capabilities within document structures.",
"links": []
},
"kx_GOr51UMpdUAnS5u9qZ": {
"title": "Undefined",
"description": "",
"links": []
},
"mxd3-l3-NtPw53dEvhqm4": {
"title": "Object ID",
"description": "ObjectId is MongoDB's default primary key type, consisting of a 12-byte identifier that includes timestamp, machine identifier, process ID, and counter components. It ensures uniqueness across distributed systems and provides automatic indexing. ObjectIds are automatically generated when documents are inserted without an explicit \\_id field, enabling efficient sorting by creation time and guaranteed uniqueness across collections.",
"links": []
},
"hmo7zCZ1jKgobS5R0eBSD": {
"title": "Boolean",
"description": "Boolean data type in MongoDB stores true or false values, representing logical states in documents. Booleans are commonly used for flags, status indicators, and conditional logic in queries and applications. They support direct comparison, logical operations with $and, $or, $not operators, and can be efficiently indexed for fast querying of true/false conditions in large datasets.",
"links": []
},
"T6cq--pute6-8aG7z6QKN": {
"title": "Date",
"description": "Date data type in MongoDB stores timestamps as 64-bit integers representing milliseconds since Unix epoch (January 1, 1970 UTC). Dates support range queries, sorting, and date arithmetic operations in aggregation pipelines. MongoDB automatically converts JavaScript Date objects and ISO date strings to BSON dates, providing timezone-aware date manipulation and efficient chronological data querying.",
"links": []
},
"g6AKQiFcY_8lsWRbkbZSC": {
"title": "Null",
"description": "Null data type in MongoDB represents absent or undefined values, distinct from empty strings or zero values. Null fields can be queried, indexed, and participate in aggregation operations with special handling. MongoDB treats null values specifically in comparisons and provides the $exists operator to distinguish between null values and missing fields in document structures.",
"links": []
},
"z6I9XgIGQYWUd5l9DIZRX": {
"title": "Regular Expression",
"description": "",
"links": []
},
"UXO5i6nPa5CRW1z7FAn_S": {
"title": "JavaScript",
"description": "The JavaScript data type in MongoDB allows you to store JavaScript code as BSON values within documents, enabling the execution of server-side JavaScript functions for operations like map-reduce, stored procedures, and complex data transformations. This type can store JavaScript functions or code snippets that can be executed within the MongoDB server environment, making it useful for scenarios where you need to perform complex calculations, business logic, or custom aggregation operations directly on the database server. However, the JavaScript type is primarily legacy functionality and is generally discouraged in modern MongoDB applications due to security concerns and performance implications, with the aggregation framework being the preferred approach for complex data processing tasks that previously required server-side JavaScript execution.",
"links": []
},
"XAS4jQlsHkttLDuSSsD2o": {
"title": "Symbol",
"description": "",
"links": []
},
"xKFZSKG2GPD-phY2HLMsx": {
"title": "Int32/Int",
"description": "Int32 data type in MongoDB stores 32-bit signed integers ranging from -2,147,483,648 to 2,147,483,647. This type provides exact integer representation without floating-point precision issues and takes less storage space than doubles. Int32 is ideal for counters, IDs, and whole numbers where precision is critical and the value range fits within 32-bit limits.",
"links": []
},
"iJFDFdIN_N4-DlJwrFIiB": {
"title": "Int64 / Long",
"description": "Int64 (Long) data type in MongoDB stores 64-bit signed integers with a range from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. This type handles large integer values that exceed Int32 limits while maintaining exact precision. Long integers are essential for timestamps, large counters, and applications requiring precise integer arithmetic with very large numbers.",
"links": []
},
"zbFH2NRHZEOv5eKLL_HR0": {
"title": "Timestamp",
"description": "",
"links": []
},
"OGtR5D_DUCSci1lFBT83z": {
"title": "Decimal128",
"description": "Decimal128 data type in MongoDB provides exact decimal representation for financial and monetary calculations requiring precision. Based on IEEE 754-2008 standard, it supports 34 decimal digits with exact arithmetic operations. Decimal128 eliminates floating-point precision errors, making it essential for applications handling currency, accounting, and scientific computations where decimal accuracy is critical.",
"links": []
},
"jQSMLd6gG158tJDzo1k_1": {
"title": "Min Key",
"description": "",
"links": []
},
"QF7SL237FyBQdqvKUzop6": {
"title": "Max Key",
"description": "",
"links": []
},
"7SGYNo3oHlgm_1cwhWfw7": {
"title": "Collections & Methods",
"description": "Collection methods in MongoDB provide comprehensive operations for data manipulation including CRUD operations (find, insert, update, delete), index management, and administrative functions. Key methods include createIndex(), drop(), count(), distinct(), and bulkWrite() for batch operations. These methods offer flexible options for data processing, schema validation, and collection maintenance.",
"links": []
},
"hC83jKoO_XFI83WpsdN_Z": {
"title": "Counting Documents",
"description": "Counting documents in MongoDB uses methods like countDocuments() for accurate filtered counts and estimatedDocumentCount() for fast approximate totals. countDocuments() supports query filters and provides precise results but may be slower on large collections. estimatedDocumentCount() uses collection metadata for rapid estimates, making it ideal for dashboard metrics and quick statistics.",
"links": []
},
"mXdn4u5CiQRDE83qMiWZX": {
"title": "insert() and relevant",
"description": "Insert operations add new documents to MongoDB collections using insertOne() for single documents and insertMany() for multiple documents. These methods support options like ordered/unordered inserts, write concerns, and automatic ObjectId generation. MongoDB also provides legacy insert() method and supports upsert operations through update methods when documents don't exist.",
"links": []
},
"iMpCEXRDXg0Kq9OFNywbI": {
"title": "find() and relevant",
"description": "The find() method retrieves documents from MongoDB collections using query filters, projections, and modifiers. Related methods include findOne() for single documents, findOneAndUpdate() for atomic updates, findOneAndDelete() for atomic deletions, and cursor methods like limit(), skip(), sort() for result manipulation. These methods support complex queries with operators, field projections, and cursor iteration.",
"links": []
},
"liGbnGyQaG-Vqt6cuB91N": {
"title": "update() and relevant",
"description": "Update operations modify existing documents using updateOne(), updateMany(), and replaceOne() methods with update operators like $set, $unset, $inc, and $push. These methods support upsert operations, array modifications, field updates, and atomic operations. Advanced features include findOneAndUpdate() for atomic read-modify-write operations and update pipelines for complex transformations using aggregation operators.",
"links": []
},
"qjoLxSkfKbzG1sZUXnyw9": {
"title": "delete() and relevant",
"description": "Delete operations remove documents from MongoDB collections using deleteOne() for single document removal and deleteMany() for multiple documents. These methods use query filters to specify which documents to delete and support write concerns for reliability. Additional methods include findOneAndDelete() for atomic read-and-delete operations and drop() for removing entire collections.",
"links": []
},
"yc2HqhjhIV6UU_2P-ykKB": {
"title": "bulkWrite() and relevant",
"description": "bulkWrite() in MongoDB performs multiple write operations in a single command, improving performance through reduced network round trips. It supports mixed operations including inserts, updates, deletes, and replaces with options for ordered or unordered execution. Bulk operations provide error handling, write concern configuration, and significant performance benefits for high-volume data manipulation tasks.",
"links": []
},
"4h8NdcdXmNqJxLkVJqPtX": {
"title": "validate()",
"description": "The validate() method in MongoDB is a database administration command that checks the integrity and consistency of a collection's data structures, indexes, and storage format, providing detailed information about potential corruption, missing records, or structural issues. This method performs comprehensive validation by examining the collection's namespace, scanning all documents and indexes for consistency, checking BSON document structure validity, and verifying that index entries correctly correspond to their associated documents. The validate() operation is crucial for database maintenance and troubleshooting, especially after hardware failures, unexpected shutdowns, or when experiencing unusual query behavior, as it helps identify data corruption early and provides detailed reports that can guide repair operations or data recovery procedures.",
"links": []
},
"thOckmrCJ45NVNPNxm4eg": {
"title": "Read / Write Concerns",
"description": "Read and write concerns in MongoDB control data consistency and acknowledgment levels for operations. Write concerns specify acknowledgment requirements from replica set members, while read concerns determine data consistency guarantees for queries. Options range from unacknowledged writes to majority confirmation, and from local reads to causally consistent reads, balancing performance with data reliability requirements.",
"links": []
},
"K9x7yQP59cB764Q5PqAs_": {
"title": "Cursors",
"description": "Cursors in MongoDB are pointers to query result sets that enable efficient iteration through large datasets without loading all documents into memory. They support methods like hasNext(), next(), forEach(), and limit() for result manipulation. Cursors automatically handle batching, provide lazy loading of results, and can be configured with timeouts and batch sizes for optimal performance.",
"links": []
},
"s8El0Q22GD_rOZGlDtkgH": {
"title": "Retryable Reads / Writes",
"description": "Retryable reads and writes in MongoDB are client-side features that automatically retry certain database operations when they encounter transient network errors or temporary server unavailability, improving application resilience and user experience. The MongoDB drivers can automatically retry read operations and specific write operations (like inserts, updates, deletes, and findAndModify) exactly once when they fail due to network issues, replica set elections, or other recoverable errors, without requiring changes to application code. This feature is particularly valuable in distributed environments, cloud deployments, and replica set configurations where temporary connectivity issues or failover events are common, as it reduces the likelihood of application errors and provides a better user experience by handling transient failures transparently.",
"links": []
},
"B8SFhoVV8ei1Yz6vl57l_": {
"title": "Query Operators",
"description": "Query operators in MongoDB enable sophisticated document filtering and selection using comparison, logical, element, evaluation, and array operators. These include equality operators ($eq, $ne), comparison operators ($gt, $lt, $gte, $lte), logical operators ($and, $or, $not), and specialized operators for arrays ($in, $nin, $all) and existence checks ($exists), providing powerful and flexible querying capabilities.",
"links": []
},
"gakF5Zfgk7QIgg_UwqG_Y": {
"title": "$project",
"description": "",
"links": []
},
"sxDyp3bP-YhgmDMVUFTaA": {
"title": "$include",
"description": "The $include projection operator in MongoDB allows you to explicitly specify which fields should be included in query results, providing precise control over the data returned from the database. When using $include (or simply setting fields to 1 or true in a projection document), only the specified fields and the \\_id field (unless explicitly excluded) will be present in the returned documents, which helps reduce network traffic, improve query performance, and enhance security by limiting data exposure. This operator is essential for optimizing applications that only need specific fields from large documents, especially in scenarios where documents contain many fields or large nested objects that would unnecessarily consume bandwidth and processing resources.",
"links": []
},
"nk0V3o3oKuIb8A0gDECFJ": {
"title": "$exclude",
"description": "The $exclude projection operator in MongoDB is used to explicitly exclude specific fields from query results, allowing you to return all fields of a document except those that are explicitly excluded. When using $exclude, you specify which fields to omit by setting them to 0 or false in the projection document, and all other fields will be automatically included in the result set. This operator is particularly useful when you want to retrieve most of a document's data while excluding sensitive information like passwords, internal metadata, or large fields that are not needed for a particular operation, helping reduce network bandwidth and improve query performance by transferring only the necessary data.",
"links": []
},
"9mmxYBtvPYZlvFjQvE-2N": {
"title": "$slice",
"description": "The $slice projection operator in MongoDB returns a subset of array elements from documents. It supports positive values for elements from the beginning, negative values from the end, and skip/limit combinations for pagination within arrays. $slice is essential for managing large arrays in documents, implementing array pagination, and reducing network traffic by returning only required array portions.",
"links": []
},
"2h8z2mrgRKSLKI-eBc3zM": {
"title": "$eq",
"description": "The $eq operator in MongoDB matches documents where a field value equals a specified value. It performs exact equality comparison and is the default behavior when using field: value syntax. $eq supports all BSON data types including nested documents and arrays, enabling precise matching in queries. It's fundamental for filtering documents by specific field values in find operations.",
"links": []
},
"wbZb0RwmANH4ssF07cAar": {
"title": "$gt",
"description": "The $gt (greater than) operator in MongoDB selects documents where a field value is greater than a specified value. It works with numbers, dates, strings (lexicographically), and other comparable BSON types. $gt is essential for range queries, date filtering, and numeric comparisons. Combined with other operators, it enables complex filtering conditions for data analysis and reporting.",
"links": []
},
"5-MLEEigFPRloN7wLa05T": {
"title": "$lt",
"description": "The $lt (less than) operator in MongoDB selects documents where a field value is less than a specified value. It supports comparison operations on numbers, dates, strings, and other ordered BSON types. $lt is commonly used in range queries, date boundaries, and filtering datasets by numeric thresholds. It combines well with $gt to create range-based queries.",
"links": []
},
"eOfsrmOQI0dJW6HV_myVH": {
"title": "$lte",
"description": "The $lte (less than or equal to) operator in MongoDB selects documents where a field value is less than or equal to a specified value. It provides inclusive upper bound comparison for range queries, end date filtering, and maximum value constraints. $lte is essential for creating inclusive upper limits in queries and combining with $gte for complete range specifications.",
"links": []
},
"kV5Tmu9ocDnuPQvkx2W0u": {
"title": "$gte",
"description": "The $gte (greater than or equal to) operator in MongoDB selects documents where a field value is greater than or equal to a specified value. It provides inclusive comparison for range queries, date boundaries, and numeric filtering. $gte is particularly useful for minimum threshold queries, start date filtering, and creating inclusive lower bounds in data selection criteria.",
"links": []
},
"Q8dr1JPEnLX0z4DiQwnAz": {
"title": "$ne",
"description": "The $ne (not equal) operator in MongoDB selects documents where a field value is not equal to a specified value. It performs inverse equality comparison and excludes documents with matching values, including exact matches and type equivalence. $ne is fundamental for exclusion filtering, finding outliers, and creating queries that avoid specific values or patterns.",
"links": []
},
"Wd20OKQYYuW_bT6U-yRxT": {
"title": "$in",
"description": "The $in operator in MongoDB selects documents where a field value matches any value in a specified array. It provides efficient multiple value matching without using multiple $or conditions. $in supports all BSON data types and is particularly useful for filtering by lists of IDs, categories, or enumerated values, offering better performance than equivalent $or queries.",
"links": []
},
"ZKHUCskdKQf4IaMUTN_e7": {
"title": "$nin",
"description": "The $nin (not in) operator in MongoDB selects documents where a field value does not match any value in a specified array. It's the logical opposite of $in and excludes documents with field values present in the given array. $nin is useful for filtering out unwanted values, excluding specific categories, and creating blacklist-style queries.",
"links": []
},
"hPPoO8ysGeEGEQhdveiDO": {
"title": "$all",
"description": "The $all operator in MongoDB selects documents where an array field contains all specified elements, regardless of order or additional elements. It's useful for tag-based filtering and ensuring multiple required values exist in arrays. $all performs element-wise matching and can work with arrays of different data types, making it essential for multi-criteria array filtering.",
"links": []
},
"TJHVY8DRWbDKeT_pIPJay": {
"title": "$elemMatch",
"description": "The $elemMatch operator in MongoDB matches documents containing array elements that satisfy multiple specified criteria within a single array element. It ensures all conditions apply to the same array element rather than different elements. $elemMatch is crucial for querying arrays of embedded documents, complex array filtering, and maintaining logical consistency in multi-condition array queries.",
"links": []
},
"-VMIkV6S6H1blngxLXk7Y": {
"title": "$size",
"description": "The $size operator in MongoDB matches documents where an array field has exactly the specified number of elements. It only works with arrays and requires an exact count match, not range queries. $size is useful for validating array lengths, filtering documents by array dimensions, and ensuring data consistency in array-based document structures.",
"links": []
},
"12kfpSapv2uNxpHzLkFSL": {
"title": "$exists",
"description": "The $exists operator in MongoDB matches documents based on the presence or absence of a specified field. When set to true, it finds documents containing the field regardless of value (including null), and when false, it finds documents missing the field entirely. $exists is useful for schema validation, data quality checks, and filtering documents with optional fields.",
"links": []
},
"BxzMbF7cdvGPuy1EcRvWd": {
"title": "$type",
"description": "The $type operator in MongoDB selects documents based on the BSON data type of a specified field. It accepts either BSON type numbers or string aliases like \"string\", \"int\", \"array\", \"object\". $type is useful for data validation, schema analysis, and filtering documents by field data types, especially when working with collections containing varied or dynamic schemas.",
"links": []
},
"PmfjHFz-DW69pNh_t13Nm": {
"title": "$regex",
"description": "The $regex operator in MongoDB provides regular expression pattern matching for string fields. It supports Perl-compatible regular expressions (PCRE) with options for case sensitivity, multiline matching, and extended syntax. $regex enables sophisticated text searching, pattern validation, and complex string filtering, though it may impact performance on large datasets without proper indexing.",
"links": []
},
"-62S4wRxHpIM2I59xjGun": {
"title": "$and",
"description": "The $and operator in MongoDB performs logical AND operation on multiple query expressions, returning documents that satisfy all specified conditions. It accepts an array of query expressions and is implicitly used when multiple conditions are provided at the same level. $and is explicit when combining complex expressions or when the same field needs multiple conditions.",
"links": []
},
"43BfjlUju-yJaGv-FaJty": {
"title": "$or",
"description": "The $or operator in MongoDB performs logical OR operation on multiple query expressions, returning documents that satisfy at least one of the specified conditions. It accepts an array of query expressions and enables alternative matching criteria. $or is essential for flexible querying when documents can match any of several different conditions or field combinations.",
"links": []
},
"qaUj9916Fh4BtiLz_pwQs": {
"title": "$not",
"description": "The $not operator in MongoDB performs logical negation on a query expression, returning documents that do not match the specified condition. It accepts a single query expression and inverts its result. $not is useful for excluding specific patterns, finding documents that don't meet certain criteria, and creating inverse filters in complex queries.",
"links": []
},
"7xq_mdQOlUTuhfnogOl8h": {
"title": "$nor",
"description": "The $nor operator in MongoDB performs logical NOR operation, selecting documents that fail to match any of the specified query expressions. It's the inverse of $or and returns documents that don't satisfy any of the given conditions. $nor is useful for complex exclusion logic and finding documents that don't match multiple alternative criteria.",
"links": []
},
"A9W2LsivDc0ialLp83fYP": {
"title": "Performance Optimization",
"description": "Performance optimization in MongoDB involves proper indexing strategies, query optimization, schema design, and hardware configuration. Key techniques include creating appropriate indexes, using explain plans, optimizing aggregation pipelines, proper sharding strategies, and connection pooling. Regular monitoring of query performance, index usage, and database metrics helps identify bottlenecks and improve overall system efficiency.",
"links": []
},
"haA1ltV6VzgJVJcJNMK0W": {
"title": "Creating Indexes",
"description": "Creating indexes in MongoDB uses the createIndex() method to build data structures that improve query performance. Indexes can be created on single fields, multiple fields (compound), or with special types like text, geospatial, or hashed. Best practices include analyzing query patterns, creating indexes before large data imports, and monitoring index usage to ensure optimal performance without over-indexing.",
"links": []
},
"SjPzR6JjdBeiqFsrRJPfW": {
"title": "Single Field",
"description": "Single field indexes in MongoDB are created on individual document fields to optimize queries filtering, sorting, or ranging on that specific field. They can be ascending (1) or descending (-1) and automatically optimize equality, range, and sort operations. Single field indexes are the simplest index type and form the foundation for more complex indexing strategies.",
"links": []
},
"eSb4WAfWxJu6R95pPX6wm": {
"title": "Compound",
"description": "Compound indexes in MongoDB are built on multiple fields in a specified order, optimizing queries that filter on multiple fields. Field order matters significantly as it determines which queries can efficiently use the index. Compound indexes support prefix patterns, meaning they can optimize queries on any left subset of the indexed fields, making them versatile for various query patterns.",
"links": []
},
"PV_3TEYdtVZ2VCDZEOsu_": {
"title": "Text",
"description": "The $text operator in MongoDB performs full-text search on fields with text indexes. It supports phrase matching, stemming, stop words, and relevance scoring. $text searches across all text-indexed fields simultaneously and provides score-based ranking of results. This operator requires a text index on the collection and enables efficient search functionality for text-heavy applications.",
"links": []
},
"butGgZXGPTZI-sWx24bOr": {
"title": "Expiring",
"description": "Expiring indexes (TTL - Time To Live) in MongoDB automatically delete documents from a collection after a specified period, making them ideal for managing time-sensitive data like session information, log entries, temporary caches, or any data that becomes obsolete after a certain duration. These indexes are created on date fields and use a background process that runs every 60 seconds to remove expired documents, helping maintain optimal collection size and performance by preventing the accumulation of outdated data. TTL indexes are particularly useful for applications that generate large volumes of transient data, as they provide an automated cleanup mechanism that reduces storage costs and improves query performance without requiring manual intervention or complex application logic to handle data expiration.",
"links": []
},
"bqXlDnPuMQIKulD9cTvPf": {
"title": "Geospatial Indexes",
"description": "Geospatial indexes in MongoDB enable efficient querying of geographic coordinate data using 2d, 2dsphere, and geoHaystack index types. They support location-based queries like finding points within a specific distance, polygon intersection, and nearest neighbor searches. These indexes work with GeoJSON objects and legacy coordinate pairs for mapping applications and location services.",
"links": []
},
"YidhAuVk_VGukx_FfJSz2": {
"title": "Atlas Search Indexes",
"description": "Atlas Search indexes in MongoDB Atlas provide full-text search capabilities using Apache Lucene technology. They enable sophisticated text search with relevance scoring, autocomplete, faceted search, and synonyms. These indexes support complex search queries across multiple fields, fuzzy matching, and advanced text analysis features for building modern search experiences in applications.",
"links": []
},
"kG0ZeGatgvC1azZKMQiA_": {
"title": "Query Optimization",
"description": "",
"links": []
},
"gpihoIJkzSS1WOvmH2ueo": {
"title": "Aggregation",
"description": "Aggregation in MongoDB is a powerful framework for data processing and transformation using a pipeline of stages. Each stage performs specific operations like filtering, grouping, sorting, or computing values, allowing complex data analytics and reporting. The aggregation pipeline offers operators for mathematical calculations, string manipulation, date operations, and advanced data transformations.",
"links": []
},
"_c7itVw1R1_UB-NPtL-WI": {
"title": "$match",
"description": "The $match aggregation stage filters documents in the pipeline, similar to the find() query operation. It should be placed early in the pipeline to reduce document count and improve performance. $match supports all query operators and can use indexes when positioned at the beginning of the pipeline, making it essential for efficient data filtering in aggregation workflows.",
"links": []
},
"nz048lC4Q4S7fMVbxLGEk": {
"title": "$group",
"description": "The $group aggregation stage groups documents by specified identifier expressions and applies accumulator operators like $sum, $avg, $max, $min, and $push. It's essential for data aggregation, calculating statistics, and creating summary reports. $group can group by single or multiple fields and supports complex expressions for dynamic grouping criteria.",
"links": []
},
"BCWS8uV2pSWe7CX-VlnTg": {
"title": "$sort",
"description": "The $sort aggregation stage orders documents by specified field values in ascending (1) or descending (-1) order. It can sort by multiple fields with different directions and supports sorting by computed values from previous pipeline stages. Placing $sort early in the pipeline can leverage indexes for better performance, while late sorting applies to aggregated results.",
"links": []
},
"dO2mJejkWBH903LG0dWgN": {
"title": "$project",
"description": "The $project stage in MongoDB aggregation pipelines is used to reshape documents by including, excluding, or transforming fields, allowing you to control exactly which data is passed to subsequent pipeline stages. It can perform field selection (similar to SQL SELECT), create computed fields using expressions, rename fields, nest or flatten document structures, and apply various transformations like mathematical operations, string manipulations, or date formatting. The $project stage is essential for optimizing pipeline performance by reducing document size early in the pipeline, creating derived fields for analysis, formatting output for client applications, and controlling data exposure by excluding sensitive fields, making it one of the most versatile and commonly used aggregation operators.",
"links": []
},
"4CjjGPOy-385Bco_PeQwa": {
"title": "$skip",
"description": "The $skip aggregation stage skips a specified number of documents before passing the remaining documents to the next pipeline stage. It's commonly used with $limit for pagination implementation, allowing applications to skip previous pages and retrieve specific result sets. $skip should be used carefully with large skip values as it can impact performance.",
"links": []
},
"AzUVaGnGv9uypJ31alR9r": {
"title": "$limit",
"description": "The $limit aggregation stage restricts the number of documents passed to the next stage in the pipeline. It's commonly used with $sort to get top N results, implement pagination, or reduce data processing overhead. $limit is efficient when combined with indexes and should be placed strategically in the pipeline to minimize document processing in subsequent stages.",
"links": []
},
"AY-8KJGA9ZA6ay3rbURt3": {
"title": "$unwind",
"description": "The $unwind aggregation stage deconstructs array fields, creating separate documents for each array element. It's essential for processing documents with embedded arrays by flattening them into individual records. $unwind supports options for preserving null/empty arrays and including array indices, enabling detailed analysis of array-based data structures and normalization workflows.",
"links": []
},
"strw_oGTkZEH-o8zA4IRP": {
"title": "$lookup",
"description": "The $lookup aggregation stage performs left outer joins between collections, similar to SQL JOINs. It adds an array field containing matching documents from the \"joined\" collection based on specified local and foreign fields. $lookup supports pipeline-based lookups for complex matching conditions and enables denormalization of related data for efficient querying and reporting.",
"links": []
},
"CfM0iyd2bNRIiDWTUkspd": {
"title": "$sum",
"description": "The $sum aggregation operator calculates the total sum of numeric values across grouped documents or array elements. It's commonly used with $group to aggregate numeric data, create totals, and perform mathematical operations in aggregation pipelines. $sum ignores non-numeric values and can sum field values, literal numbers, or results from expressions, making it essential for financial and statistical calculations.",
"links": []
},
"eDks8Jmsbq3_nHgLydyxP": {
"title": "Pipelines, Stages and Operators",
"description": "MongoDB aggregation pipelines are composed of sequential stages that process and transform documents, where each stage performs a specific operation using various operators before passing results to the next stage. Stages like $match (filtering), $group (grouping and aggregating), $project (field selection and transformation), $sort (ordering), $lookup (joins), and $unwind (array expansion) can be combined in any order to create complex data processing workflows. Operators within these stages include arithmetic operators ($add, $multiply), comparison operators ($eq, $gt), array operators ($push, $addToSet), date operators ($dateToString, $year), and conditional operators ($cond, $ifNull), providing a powerful and flexible framework for data analysis, reporting, and ETL operations directly within the database.",
"links": []
},
"aHcmsaqAfG5fC90VV-EHP": {
"title": "Transactions",
"description": "Transactions in MongoDB provide ACID guarantees for multi-document operations, ensuring data consistency across multiple operations. They support read and write operations spanning multiple documents, collections, and databases within a single atomic unit. Transactions use snapshot isolation and optimistic concurrency control, making them essential for applications requiring strict data integrity and consistency.",
"links": []
},
"6H2MMnEfS6uHGS-6pFo8u": {
"title": "Developer Tools",
"description": "MongoDB developer tools include MongoDB Compass (GUI), MongoDB Shell (mongosh), VS Code extensions, and various language drivers. These tools provide visual database exploration, query building, performance monitoring, and development assistance. Additional tools include MongoDB Atlas for cloud management, migration utilities, and third-party tools for enhanced productivity and database administration.",
"links": []
},
"73REfcB_T0yBP-KQ0EYmF": {
"title": "Language Drivers",
"description": "MongoDB language drivers are official and community-maintained libraries that provide idiomatic APIs for interacting with MongoDB databases from various programming languages including Python (PyMongo), JavaScript/Node.js, Java, C#, Go, PHP, Ruby, and many others. These drivers handle the low-level communication protocols, connection management, authentication, and data serialization between applications and MongoDB servers, while providing language-specific features like object mapping, connection pooling, and async/await support. They abstract away the complexity of the MongoDB wire protocol and BSON encoding, allowing developers to work with MongoDB using familiar programming patterns and data structures native to their chosen language, making database integration seamless and efficient.",
"links": []
},
"JAosQ9tFj7y70lGQ0vHzC": {
"title": "Kafka",
"description": "",
"links": []
},
"K09-nD6xF5YJUQBBpFXMz": {
"title": "Spark",
"description": "",
"links": []
},
"kJJ-W6BV1ofIvuFT_PCcz": {
"title": "Elastic Search",
"description": "The MongoDB Elasticsearch connector enables seamless integration between MongoDB and Elasticsearch, allowing you to automatically synchronize data from MongoDB collections to Elasticsearch indices for powerful full-text search, analytics, and visualization capabilities. This connector streams data changes in real-time using MongoDB's change streams, transforms documents as needed, and maintains data consistency between the two systems, making it ideal for applications that need both MongoDB's flexible document storage and Elasticsearch's advanced search and aggregation features. It's particularly useful for building search-heavy applications, log analytics systems, and business intelligence dashboards that require complex text search, faceted search, and real-time data analysis capabilities.",
"links": []
},
"xaWDHCkcGm4oovPPxVMB9": {
"title": "mongodump",
"description": "mongodump is a MongoDB utility that creates binary backups of database content by exporting data in BSON format. It supports selective backup options including specific databases, collections, and query-based filtering. mongodump preserves data types, indexes metadata, and can perform live backups without stopping the database, making it essential for backup strategies and data migration workflows.",
"links": []
},
"TKngxMNGMgrdO26D7eeSg": {
"title": "mongorestore",
"description": "mongorestore is a MongoDB utility that restores data from binary BSON dumps created by mongodump. It can restore entire databases, specific collections, or subsets of data with options for data transformation and index rebuilding. mongorestore supports various restore modes including replacement, merge, and upsert operations, making it crucial for disaster recovery and data migration scenarios.",
"links": []
},
"cOKQQ7SaiawWF49MdCGTh": {
"title": "Scaling MongoDB",
"description": "Scaling MongoDB involves vertical scaling (upgrading hardware) and horizontal scaling through sharding and replica sets. Horizontal scaling distributes data across multiple servers using shard keys, while replica sets provide high availability and read scaling. Effective scaling strategies include proper shard key selection, monitoring performance metrics, and balancing data distribution for optimal throughput and reliability.",
"links": []
},
"QrHT-H12AV4-V-y_nzmNk": {
"title": "Replicasets",
"description": "Replica Sets in MongoDB provide high availability and data redundancy through a group of mongod instances that maintain identical data copies. The primary node handles write operations while secondary nodes replicate data and can serve read operations. Automatic failover ensures continuous service if the primary becomes unavailable, with secondary nodes electing a new primary to maintain database availability.",
"links": []
},
"CijW3HCjVRZHQIBsQ9_0H": {
"title": "Sharded Clusters",
"description": "Sharded Clusters enable horizontal scaling by distributing data across multiple servers based on a shard key. MongoDB automatically partitions collections and balances data distribution across shards, allowing databases to handle massive datasets and high throughput workloads. Sharding includes config servers for metadata management and mongos routers for query distribution across the cluster.",
"links": []
},
"iVDxuERBjKMBHueEfqP0x": {
"title": "Tuning Configuration",
"description": "MongoDB tuning configuration involves optimizing various server parameters and settings to maximize performance, efficiency, and resource utilization based on your specific workload patterns and hardware environment. Key configuration areas include memory management (WiredTiger cache size, storage engine settings), connection pooling (maximum connections, timeout values), journaling options, read/write concerns, chunk size for sharded clusters, and operating system-level optimizations like file descriptor limits and memory allocation. Proper tuning requires analyzing metrics like query performance, memory usage, disk I/O patterns, and network throughput to adjust parameters such as index builds, background operations, and replication lag, ensuring your MongoDB deployment can handle peak loads while maintaining optimal response times and resource efficiency.",
"links": []
},
"XjB0uOnsYl4edzZWpQ-nm": {
"title": "Indexing",
"description": "Indexing in MongoDB creates data structures that improve query performance by creating shortcuts to documents. Indexes are built on specific fields and allow the database to quickly locate data without scanning entire collections. MongoDB supports various index types including single field, compound, multikey, geospatial, text, and hashed indexes to optimize different query patterns and use cases.",
"links": []
},
"4L9UQ4oaaK3wZwOLIMa6T": {
"title": "Query Optimization",
"description": "Query optimization in MongoDB involves analyzing and improving query performance through various techniques including proper indexing strategies, query plan analysis, and efficient query structure design. It encompasses understanding how MongoDB's query planner works, using tools like explain() to analyze query execution, creating appropriate indexes to support common query patterns, avoiding inefficient operations like full collection scans, and structuring queries to take advantage of MongoDB's document model and aggregation framework for optimal performance and resource utilization.",
"links": []
},
"LC923iJhfiUDIs_0-9rc7": {
"title": "MongoDB Security",
"description": "MongoDB security encompasses authentication, authorization, encryption, auditing, and network security features. It includes role-based access control (RBAC), field-level security, encryption in transit and at rest, and comprehensive audit logging. MongoDB provides multiple authentication mechanisms including SCRAM, x.509 certificates, LDAP, and Kerberos to secure database access and protect sensitive data from unauthorized access.",
"links": []
},
"yRJ6jeysFXBpwLEqvrdKk": {
"title": "Role-based Access Control",
"description": "Role-Based Access Control (RBAC) in MongoDB is a security framework that manages user permissions by assigning roles that define specific privileges and access levels to database resources. It allows administrators to create custom roles with granular permissions for actions like read, write, or administrative operations on specific databases, collections, or even individual fields, ensuring users only have access to the resources they need for their job functions. This approach simplifies security management by grouping permissions into logical roles rather than managing individual user permissions, making it easier to maintain consistent security policies and comply with the principle of least privilege in enterprise environments.",
"links": []
},
"NV39oWwr7iB_dnlnD_Q6Y": {
"title": "X.509 Certificate Auth",
"description": "x.509 certificate authentication in MongoDB provides secure, certificate-based client and cluster authentication without passwords. It uses public key infrastructure (PKI) for strong identity verification and supports both client authentication and internal cluster member authentication. This method offers enhanced security through certificate validation, expiration management, and integration with existing PKI infrastructures.",
"links": []
},
"YuzMOO7kf2tO6V6WehqF_": {
"title": "Kerberos Authentication",
"description": "Kerberos authentication in MongoDB provides enterprise-grade security through ticket-based authentication protocol. It integrates with existing Active Directory or Kerberos infrastructures, allowing centralized user management and single sign-on capabilities. This authentication method eliminates password transmission over networks and provides strong mutual authentication between clients and MongoDB servers using encrypted tickets.",
"links": []
},
"NoDNdno9UOlMrOC0Wga9E": {
"title": "LDAP Proxy Auth",
"description": "LDAP Proxy Authentication in MongoDB allows the database to authenticate users through an external LDAP (Lightweight Directory Access Protocol) server, enabling organizations to integrate MongoDB with their existing directory services like Active Directory. This authentication method acts as a proxy between MongoDB and the LDAP server, allowing users to authenticate using their corporate credentials while maintaining centralized user management, making it particularly valuable for enterprise environments that need to enforce consistent security policies and user access controls across multiple systems.",
"links": []
},
"w1L-yFBM2AyeNBFyH5skW": {
"title": "MongoDB Audit",
"description": "MongoDB Audit is a security feature that enables comprehensive logging and monitoring of database activities, including authentication attempts, authorization failures, CRUD operations, and administrative actions. It provides detailed audit trails that track who accessed what data, when operations occurred, and whether they succeeded or failed, which is essential for compliance with regulatory requirements like GDPR, HIPAA, or SOX, and helps organizations detect suspicious activities, investigate security incidents, and maintain accountability in their database operations.",
"links": []
},
"iJjqlTgXxHWC-8bh6uCGQ": {
"title": "Encryption at Rest",
"description": "Encryption at Rest in MongoDB protects data stored on disk by encrypting database files, indexes, and logs using industry-standard encryption algorithms. This security feature prevents unauthorized access to physical storage media and ensures compliance with data protection regulations. MongoDB supports both enterprise-grade WiredTiger storage engine encryption and file system-level encryption options.",
"links": []
},
"LpfuM6SuhlNNjBcHM68ee": {
"title": "Queryable Encryption",
"description": "Queryable Encryption is MongoDB's advanced security feature that allows you to encrypt sensitive data while still being able to query it efficiently without decrypting the entire dataset. This cryptographic technique enables applications to perform equality queries on encrypted fields using deterministic encryption and range queries using order-preserving encryption, providing a balance between data security and functionality. It's particularly valuable for applications that need to comply with strict data protection regulations while maintaining the ability to search and filter encrypted data, such as healthcare systems handling patient records or financial applications managing sensitive transaction data.",
"links": []
},
"YJiWemHO1l5q9WhgoHyYd": {
"title": "Client-Side Field Level",
"description": "Client-Side Field Level Encryption (CSFLE) allows applications to encrypt sensitive data fields before storing them in MongoDB. The database receives only encrypted data and remains unaware of the encryption keys, ensuring zero-trust security. This feature provides deterministic and randomized encryption algorithms, enabling both exact match queries and enhanced security for highly sensitive information.",
"links": []
},
"5F7zAAnvnVTTnBzOB7TSu": {
"title": "TLS / SSL Encryption",
"description": "TLS/SSL encryption in MongoDB provides secure communication channels between clients and the database server, as well as between replica set members and sharded cluster components, ensuring that data transmitted over networks is protected from eavesdropping and tampering. This transport layer security encrypts all network traffic using industry-standard cryptographic protocols, supports certificate-based authentication for enhanced security, and can be configured for mutual authentication where both client and server verify each other's identities. Implementing TLS/SSL is essential for production deployments, especially in cloud environments or when MongoDB instances communicate across untrusted networks, as it prevents man-in-the-middle attacks and ensures data confidentiality during transmission.",
"links": []
}
}

15
public/roadmap-content/nodejs.json
View File

@@ -34,11 +34,6 @@
"url": "https://nodejs.org/en/learn/getting-started/introduction-to-nodejs",
"type": "article"
},
{
"title": "Node.js - Introduction",
"url": "https://www.w3schools.com/nodejs/nodejs_intro.asp",
"type": "article"
},
{
"title": "Explore top posts about Node.js",
"url": "https://app.daily.dev/tags/nodejs?ref=roadmapsh",
@@ -681,11 +676,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/API/setTimeout",
"type": "article"
},
{
"title": "W3Schools – JavaScript - setTimeOut",
"url": "https://www.w3schools.com/jsref/met_win_settimeout.asp",
"type": "article"
},
{
"title": "setInterval and setTimeout: timing events",
"url": "https://www.youtube.com/watch?v=kOcFZV3c75I",
@@ -865,11 +855,6 @@
"url": "https://nodejs.org/api/fs.html",
"type": "article"
},
{
"title": "More about fs module",
"url": "https://www.w3schools.com/nodejs/nodejs_filesystem.asp",
"type": "article"
},
{
"title": "Using fs",
"url": "https://www.youtube.com/watch?v=ZySsdm576wE",

5
public/roadmap-content/postgresql-dba.json
View File

@@ -734,11 +734,6 @@
"title": "Joins Between Tables",
"url": "https://www.postgresql.org/docs/current/tutorial-join.html",
"type": "article"
},
{
"title": "PostgreSQL - Joins",
"url": "https://www.w3schools.com/postgresql/postgresql_joins.php",
"type": "article"
}
]
},

68
public/roadmap-content/python.json
View File

@@ -23,11 +23,6 @@
"url": "https://developers.google.com/edu/python",
"type": "article"
},
{
"title": "W3Schools - Python Tutorial",
"url": "https://www.w3schools.com/python",
"type": "article"
},
{
"title": "Explore top posts about Python",
"url": "https://app.daily.dev/tags/python?ref=roadmapsh",
@@ -44,11 +39,6 @@
"title": "Basic Syntax",
"description": "Setup the environment for python and get started with the basics.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools - Python",
"url": "https://www.w3schools.com/python/",
"type": "article"
},
{
"title": "Python Basics",
"url": "https://www.tutorialspoint.com/python/python_basic_syntax.htm",
@@ -75,16 +65,6 @@
"url": "https://realpython.com/python-variables",
"type": "article"
},
{
"title": "W3Schools — Python Variables",
"url": "https://www.w3schools.com/python/python_variables.asp",
"type": "article"
},
{
"title": "Python Data Types",
"url": "https://www.w3schools.com/python/python_datatypes.asp",
"type": "article"
},
{
"title": "Python for Beginners: Data Types",
"url": "https://thenewstack.io/python-for-beginners-data-types/",
@@ -169,11 +149,6 @@
"url": "https://docs.python.org/3/library/functions.html",
"type": "article"
},
{
"title": "Python Functions - W3Schools",
"url": "https://www.w3schools.com/python/python_functions.asp",
"type": "article"
},
{
"title": "Defining Python Functions",
"url": "https://realpython.com/defining-your-own-python-function/",
@@ -242,11 +217,6 @@
"url": "https://learnpython.com/blog/python-sets/",
"type": "article"
},
{
"title": "An W3Schools - Python Sets",
"url": "https://www.w3schools.com/python/python_sets.asp",
"type": "article"
},
{
"title": "Python Sets tutorial for Beginners",
"url": "https://www.youtube.com/watch?v=t9j8lCUGZXo",
@@ -263,11 +233,6 @@
"url": "https://docs.python.org/3/tutorial/datastructures.html#dictionaries",
"type": "article"
},
{
"title": "W3 Schools - Dictionaries",
"url": "https://www.w3schools.com/python/python_dictionaries.asp",
"type": "article"
},
{
"title": "Dictionaries in Python",
"url": "https://realpython.com/python-dicts/",
@@ -525,11 +490,6 @@
"title": "Lambdas",
"description": "Python Lambda Functions are anonymous function means that the function is without a name. As we already know that the def keyword is used to define a normal function in Python. Similarly, the lambda keyword is used to define an anonymous function in Python.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Lambdas in Python",
"url": "https://www.w3schools.com/python/python_lambda.asp",
"type": "article"
},
{
"title": "How to use Lambda functions",
"url": "https://realpython.com/python-lambda/",
@@ -572,11 +532,6 @@
"title": "Iterators",
"description": "An iterator is an object that contains a countable number of values. An iterator is an object that can be iterated upon, meaning that you can traverse through all the values. Technically, in Python, an iterator is an object which implements the iterator protocol, which consist of the methods **iter**() and **next**() .\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Iterators in Python",
"url": "https://www.w3schools.com/python/python_iterators.asp",
"type": "article"
},
{
"title": "Python Iterators",
"url": "https://www.programiz.com/python-programming/iterator",
@@ -645,11 +600,6 @@
"url": "https://docs.python.org/3/tutorial/classes.html",
"type": "article"
},
{
"title": "Python Classes and Objects",
"url": "https://www.w3schools.com/python/python_classes.asp",
"type": "article"
},
{
"title": "Python OOP Tutorial",
"url": "https://www.youtube.com/watch?v=ZDa-Z5JzLYM&list=PL-osiE80TeTsqhIuOqKhwlXsIBIdSeYtc",
@@ -660,13 +610,7 @@
"S0FLE70szSVUPI0CDEQK7": {
"title": "Inheritance",
"description": "Inheritance is a fundamental concept in object-oriented programming (OOP) that allows one class to inherit the properties and behavior of another class.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Python Inheritance",
"url": "https://www.w3schools.com/python/python_inheritance.asp",
"type": "article"
}
]
"links": []
},
"zAS4YiEJ6VPsyABrkIG8i": {
"title": "Methods, Dunder",
@@ -740,11 +684,6 @@
"url": "https://realpython.com/what-is-pip/",
"type": "article"
},
{
"title": "Python PIP Introduction",
"url": "https://www.w3schools.com/python/python_pip.asp",
"type": "article"
},
{
"title": "Explore top posts about PIP",
"url": "https://app.daily.dev/tags/pip?ref=roadmapsh",
@@ -788,11 +727,6 @@
"url": "https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions",
"type": "article"
},
{
"title": "Python - List Comprehension",
"url": "https://www.w3schools.com/python/python_lists_comprehension.asp",
"type": "article"
},
{
"title": "What Exactly are List Comprehensions in Python? - CodeGuage",
"url": "https://www.codeguage.com/courses/python/lists-list-comprehensions",

20
public/roadmap-content/qa.json
View File

@@ -835,21 +835,6 @@
"title": "HTML, CSS, JavaScript",
"description": "HTML stands for HyperText Markup Language. It is used on the front and gives structure to the webpage, which you can style using CSS and make interactive using JavaScript.\n\nCSS or Cascading Style Sheets is the language used to style the front end of any website. CSS is a cornerstone technology of the World Wide Web, alongside HTML and JavaScript.\n\nJavaScript allows you to add interactivity to your pages. You may have seen common examples on the websites: sliders, click interactions, popups, and so on.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "W3Schools - Learn HTML",
"url": "https://www.w3schools.com/html/html_intro.asp",
"type": "article"
},
{
"title": "W3Schools — Learn CSS",
"url": "https://www.w3schools.com/css/",
"type": "article"
},
{
"title": "W3Schools – JavaScript Tutorial",
"url": "https://www.w3schools.com/js/",
"type": "article"
},
{
"title": "Explore top posts about CSS",
"url": "https://app.daily.dev/tags/css?ref=roadmapsh",
@@ -877,11 +862,6 @@
"title": "Ajax",
"description": "AJAX stands for Asynchronous JavaScript And XML. In a nutshell, it is the use of the XMLHttpRequest object to communicate with servers. It can send and receive information in various formats, including JSON, XML, HTML, and text files.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "What is AJAX?",
"url": "https://www.w3schools.com/whatis/whatis_ajax.asp",
"type": "article"
},
{
"title": "Getting Started with AJAX",
"url": "https://developer.mozilla.org/en-US/docs/Web/Guide/AJAX/Getting_Started",

5
public/roadmap-content/react-native.json
View File

@@ -118,11 +118,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/CSS",
"type": "article"
},
{
"title": "CSS Tutorial - w3schools",
"url": "https://www.w3schools.com/css/",
"type": "article"
},
{
"title": "Explore top posts about CSS",
"url": "https://app.daily.dev/tags/css?ref=roadmapsh",

15
public/roadmap-content/react.json
View File

@@ -127,11 +127,6 @@
"url": "https://www.codeguage.com/courses/react/jsx",
"type": "article"
},
{
"title": "JSX in React on w3school",
"url": "https://www.w3schools.com/react/react_jsx.asp",
"type": "article"
},
{
"title": "Explore top posts about JSX",
"url": "https://app.daily.dev/tags/jsx?ref=roadmapsh",
@@ -502,11 +497,6 @@
"url": "https://react.dev/reference/react/useRef",
"type": "article"
},
{
"title": "W3Schools",
"url": "https://www.w3schools.com/react/react_useref.asp",
"type": "article"
},
{
"title": "WebDevSimplified",
"url": "https://www.youtube.com/watch?v=t2ypzz6gJm0",
@@ -697,11 +687,6 @@
"url": "https://react.dev/learn/passing-data-deeply-with-context",
"type": "article"
},
{
"title": "Basic useContext Guide",
"url": "https://www.w3schools.com/react/react_usecontext.asp",
"type": "article"
},
{
"title": "State with useContext and useState/useReducer",
"url": "https://www.robinwieruch.de/react-state-usereducer-usestate-usecontext/",

15
public/roadmap-content/software-architect.json
View File

@@ -311,11 +311,6 @@
"url": "https://automatetheboringstuff.com/",
"type": "article"
},
{
"title": "W3Schools - Python Tutorial ",
"url": "https://www.w3schools.com/python/",
"type": "article"
},
{
"title": "Python Crash Course",
"url": "https://ehmatthes.github.io/pcc/",
@@ -373,11 +368,6 @@
"url": "https://gobyexample.com/",
"type": "article"
},
{
"title": "W3Schools Go Tutorial ",
"url": "https://www.w3schools.com/go/",
"type": "article"
},
{
"title": "Explore top posts about Golang",
"url": "https://app.daily.dev/tags/golang?ref=roadmapsh",
@@ -501,11 +491,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Learn/JavaScript/Objects/Object-oriented_programming",
"type": "article"
},
{
"title": "W3schools - OOP Concepts",
"url": "https://www.w3schools.com/java/java_oop.asp",
"type": "article"
},
{
"title": "FreeCodeCamp - (OOP) in C++",
"url": "https://www.youtube.com/watch?v=wN0x9eZLix4",

982
public/roadmap-content/spring-boot.json Normal file
View File

@@ -0,0 +1,982 @@
{
"jy2heDVZuM6ASCXlI1TDn": {
"title": "Introduction",
"description": "Spring Boot is a framework for building applications based on the Spring Framework, a widely-used, open-source framework for building Java-based enterprise applications. Spring Boot aims to make it easy to create stand-alone, production-grade Spring-based applications that you can \"just run\".\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Boot",
"url": "https://spring.io/projects/spring-boot",
"type": "article"
},
{
"title": "Spring Boot - Introduction",
"url": "https://www.tutorialspoint.com/spring_boot/spring_boot_introduction.htm",
"type": "article"
},
{
"title": "Introduction to Spring Boot",
"url": "https://medium.com/adessoturkey/introduction-to-spring-boot-458cb814ec14",
"type": "article"
},
{
"title": "What-is-Spring-Boot?",
"url": "https://www.ibm.com/topics/java-spring-boot",
"type": "article"
}
]
},
"OB--nMudscm0p6RqqfA7T": {
"title": "Configuration",
"description": "Spring Core Configuration is the process of configuring the Spring Framework, which involves specifying the various configuration details required for an application to function properly. This can include setting up beans, specifying bean dependencies, configuring aspect-oriented programming (AOP) aspects, and more. Configuration can be done through Java code, XML files, or using annotations in the code.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Framework Documentation",
"url": "https://docs.spring.io/spring/docs/current/spring-framework-reference/",
"type": "article"
},
{
"title": "\"Spring Configuration\" tutorial",
"url": "https://www.baeldung.com/project-configuration-with-spring",
"type": "article"
},
{
"title": "\"Spring Framework\" tutorial",
"url": "https://www.tutorialspoint.com/spring/index.htm",
"type": "article"
},
{
"title": "\"Spring Core\" video tutorial",
"url": "https://www.youtube.com/watch?v=GB8k2-Egfv0",
"type": "video"
}
]
},
"C2EQ5J1aJYF9e9Rr2KysT": {
"title": "Dependency Injection",
"description": "Spring Boot uses the Spring Framework's Inversion of Control (IoC) container to manage objects and their dependencies. The IoC container is responsible for creating objects, wiring them together, and managing their lifecycle. When an object is created, its dependencies are also created and injected into the object.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Dependency Injection",
"url": "https://www.baeldung.com/spring-dependency-injection",
"type": "article"
},
{
"title": "Dependency Injection Using Spring Boot",
"url": "https://medium.com/edureka/what-is-dependency-injection-5006b53af782",
"type": "article"
},
{
"title": "Explore top posts about Dependency Injection",
"url": "https://app.daily.dev/tags/dependency-injection?ref=roadmapsh",
"type": "article"
}
]
},
"PlUU_vzFQ3Xx6Z5XREIYP": {
"title": "Spring IOC",
"description": "Inversion of Control (IoC) is a design pattern that is often used in conjunction with the Dependency Injection (DI) pattern. The basic idea behind IoC is to invert the flow of control in a program, so that instead of the program controlling the flow of logic and the creation of objects, the objects themselves control the flow of logic and the creation of other objects.\n\nSpring is a popular Java framework that uses IoC and DI to provide a more flexible, modular approach to software development. The Spring IoC container is responsible for managing the creation and configuration of objects in a Spring-based application.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring IoC, Spring Bean Example Tutorial",
"url": "https://www.digitalocean.com/community/tutorials/spring-ioc-bean-example-tutorial",
"type": "article"
},
{
"title": "Intro to Inversion of Control with Spring",
"url": "https://www.baeldung.com/inversion-control-and-dependency-injection-in-spring",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"wV1_I_4czMIxpBionvLs4": {
"title": "Spring AOP",
"description": "Spring AOP (Aspect-Oriented Programming) is a feature of the Spring Framework that allows developers to define certain behaviors (i.e., \"aspects\") that cut across multiple classes, such as logging or transaction management. These behaviors, which are called \"advices,\" can be applied to specific \"join points\" (i.e., points in the execution of a program) in the application, using \"pointcuts\" to determine where the advices should be applied.\n\nSpring AOP allows developers to separate the implementation of these cross-cutting concerns from the business logic of the application, making the code more modular and easier to understand. This can also make the application more flexible, since the same advices can be applied to different parts of the code without having to duplicate the code for the advices themselves.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring AOP Tutorial",
"url": "https://www.simplilearn.com/tutorials/spring-tutorial/spring-aop-aspect-oriented-programming",
"type": "article"
},
{
"title": "AOP with Spring Framework",
"url": "https://www.tutorialspoint.com/spring/aop_with_spring.htm",
"type": "article"
},
{
"title": "Spring AOP Tutorial",
"url": "https://howtodoinjava.com/spring-aop-tutorial/",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"QiNWE4sMTao3cVzjt3yPp": {
"title": "Spring MVC",
"description": "Spring MVC is a framework for building web applications in Java. It is part of the Spring Framework, which is a larger ecosystem of tools for building Java applications. Spring MVC is built on the Model-View-Controller (MVC) design pattern, which helps to separate the concerns of the application into three distinct components: the Model, the View, and the Controller.\n\nSpring MVC provides a powerful and flexible way to build web applications, and it integrates well with other parts of the Spring ecosystem, such as Spring Security for authentication and authorization, and Spring Data for data access.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Web MVC framework",
"url": "https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html",
"type": "article"
},
{
"title": "Spring - MVC Framework",
"url": "https://www.tutorialspoint.com/spring/spring_web_mvc_framework.htm",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"HdCpfGMrMaXxk5QrtYn3X": {
"title": "Annotations",
"description": "One of the key features of Spring Boot is its use of annotations, which are used to configure various aspects of the application and to enable certain features.\n\nSome of the most commonly used annotations in Spring Boot include:\n\n* `@SpringBootApplication`\n* `@RestController`\n* `@Autowired`\n* `@Value`\n* `@Enable`\n* `@Configuration`\n* `@Bean`\n\nThese are just a few examples of the many annotations that are available in Spring Boot. There are many other annotations that you can use to configure various aspects of your application, such as security, caching, and data access.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Annotations",
"url": "https://www.digitalocean.com/community/tutorials/spring-annotations",
"type": "article"
},
{
"title": "Annotations in Spring",
"url": "https://www.techferry.com/articles/spring-annotations.html",
"type": "article"
}
]
},
"KdN62IpNgPFMndXfLaYa1": {
"title": "Spring Bean Scope",
"description": "In the Spring Framework, a bean is an object that is instantiated, assembled, and managed by the Spring IoC container. One of the key features of the Spring container is its ability to manage the lifecycle of beans, which includes creating, configuring, and destroying beans as necessary. One way the container can control the lifecycle of a bean is by specifying its scope.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring - Bean Scopes",
"url": "https://www.tutorialspoint.com/spring/spring_bean_scopes.htm",
"type": "article"
},
{
"title": "Quick Guide to Spring Bean Scopes",
"url": "https://www.baeldung.com/spring-bean-scopes",
"type": "article"
},
{
"title": "Spring Bean Scopes",
"url": "https://www.digitalocean.com/community/tutorials/spring-bean-scopes",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"WrUCyVfFNUpHB8jyjjKna": {
"title": "Terminology",
"description": "Spring Core, the base of the Spring Framework, provides a model for configuring Java applications. Key concepts include **Beans** (Java objects managed by Spring), **Inversion of Control (IoC)** (Spring managing bean lifecycles and dependencies), and **Dependency Injection (DI)** (Spring providing bean dependencies). The **Spring container** (specifically an **ApplicationContext**) creates and manages these beans. Spring also offers **Aspect-Oriented Programming (AOP)** for handling cross-cutting concerns, an **event model** for decoupled communication using **ApplicationEvent** and **listeners**, abstractions for **Data Access** and **Transactions**, and utilities for **Task Execution and Scheduling**.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Boot",
"url": "https://spring.io/projects/spring-boot",
"type": "article"
},
{
"title": "Spring Boot - Starter Guide",
"url": "https://spring.io/quickstart",
"type": "article"
}
]
},
"yuXN-rD4AyyPYUYOR50L_": {
"title": "Architecture",
"description": "Spring Boot follows a layered architecture in which each layer communicates with the layer directly below or above (hierarchical structure) it. There are four layers in Spring Boot are as follows:\n\n* **Presentation Layer**: handles the HTTP requests, translates the JSON parameter to object, and authenticates the request and transfer it to the business layer.\n* **Business Layer**: The business layer handles all the business logic. It consists of service classes and uses services provided by data access layers. It also performs authorization and validation.\n* **Persistence Layer**: The persistence layer contains all the storage logic and translates business objects from and to database rows.\n* **Database Layer**: In the database layer, CRUD (create, retrieve, update, delete) operations are performed.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Boot Architecture – Detailed Explanation",
"url": "https://www.interviewbit.com/blog/spring-boot-architecture",
"type": "article"
},
{
"title": "Explore top posts about Architecture",
"url": "https://app.daily.dev/tags/architecture?ref=roadmapsh",
"type": "article"
}
]
},
"WGf3W6bdWL0rK0o6O28G2": {
"title": "Why use Spring?",
"description": "Spring Boot provides a number of features that make it easier to create a Spring-based application, including:\n\n* Embedded Application Server\n* Automatic Configuration\n* Pre-configured Starters\n* Ease of Packaging and Distribution\n* Ease of monitoring through built-in health check endpoint and the ability to customize the management endpoint.\n\nAdditionally, it's come with a lot of best practices and conventions baked in, which reduces the amount of work and boiler plate code developers need to write.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Why Spring?",
"url": "https://spring.io/why-spring",
"type": "article"
},
{
"title": "Spring vs Spring Boot: Know The Difference",
"url": "https://www.interviewbit.com/blog/spring-vs-spring-boot",
"type": "article"
},
{
"title": "A Comparison Between Spring and Spring Boot",
"url": "https://www.baeldung.com/spring-vs-spring-boot",
"type": "article"
},
{
"title": "Advantages of Spring Boot",
"url": "https://www.adservio.fr/post/advantages-of-spring-boot",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"KaUdyVWEiZa6lUDRBlOKt": {
"title": "Spring Security",
"description": "Spring Security is a framework for securing Java-based applications. It is a powerful and highly customizable authentication and access-control framework that can be easily integrated with a wide variety of applications, including web applications and RESTful web services. Spring Security provides a comprehensive security solution for both authentication and authorization, and it can be used to secure applications at both the web and method level.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Security",
"url": "https://spring.io/projects/spring-security",
"type": "article"
},
{
"title": "What is Spring security",
"url": "https://www.javadevjournal.com/spring/what-is-spring-security/",
"type": "article"
},
{
"title": "Spring Security: Authentication and Authorization In-Depth",
"url": "https://www.marcobehler.com/guides/spring-security",
"type": "article"
},
{
"title": "Explore top posts about Security",
"url": "https://app.daily.dev/tags/security?ref=roadmapsh",
"type": "article"
}
]
},
"ssdk2iAt4avhc8B5tnIzQ": {
"title": "Authentication",
"description": "Spring Security is a framework for securing Java-based applications. One of its core features is authentication, which is the process of verifying that a user is who they claim to be. Spring Security provides a wide range of options for implementing authentication, including support for traditional username/password-based authentication as well as more modern alternatives such as OAuth and JSON Web Tokens (JWT).\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Authentication",
"url": "https://docs.spring.io/spring-security/reference/features/authentication/index.html",
"type": "article"
},
{
"title": "Spring Security Authentication",
"url": "https://spring.io/projects/spring-security",
"type": "article"
},
{
"title": "Spring Security Basic Authentication",
"url": "https://www.baeldung.com/spring-security-basic-authentication",
"type": "article"
},
{
"title": "Explore top posts about Authentication",
"url": "https://app.daily.dev/tags/authentication?ref=roadmapsh",
"type": "article"
}
]
},
"c7w7Z3Coa81FKa_yAKTse": {
"title": "Authorization",
"description": "Spring Security supports a variety of authentication mechanisms, such as username and password authentication, OAuth2, and more. Once a user is authenticated, Spring Security can then be used to authorize that user's access to specific resources or functionality. There are several annotations that can be used to control access to specific methods or classes.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Authorization",
"url": "https://docs.spring.io/spring-security/reference/servlet/authorization/index.html",
"type": "article"
},
{
"title": "Advanced authorization in Spring",
"url": "https://docs.spring.io/spring-security/site/docs/5.2.11.RELEASE/reference/html/authorization.html",
"type": "article"
},
{
"title": "Spring Security: Authentication and Authorization In-Depth",
"url": "https://www.marcobehler.com/guides/spring-security",
"type": "article"
},
{
"title": "Explore top posts about Authorization",
"url": "https://app.daily.dev/tags/authorization?ref=roadmapsh",
"type": "article"
}
]
},
"p7t3RlIIm9U08GFC6azff": {
"title": "OAuth2",
"description": "Spring Security OAuth2 library provides support for both the authorization code grant type (for web apps) and the implicit grant type (for single-page apps). You can also use Spring Security to protect your resources, and to configure your application as an OAuth2 resource server. The OAuth2 authentication process can be complex and time-consuming, but the Spring Security OAuth2 library makes it easy to get started by providing a set of convenient configuration classes and annotations.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Boot and OAuth2",
"url": "https://spring.io/guides/tutorials/spring-boot-oauth2/",
"type": "article"
},
{
"title": "Spring Boot - OAuth2 with JWT",
"url": "https://www.tutorialspoint.com/spring_boot/spring_boot_oauth2_with_jwt.htm",
"type": "article"
},
{
"title": "Spring Security",
"url": "https://www.tutorialspoint.com/spring_security/spring_security_with_oauth2.htm",
"type": "article"
}
]
},
"1My7mbdwAbRcJoiA50pWW": {
"title": "JWT Authentication",
"description": "Spring Security can be used to implement JWT Authentication and Authorization to your APIs. The library provides a JWT-based authentication filter that you can add to your API endpoints. The filter will check the JWT that is included in the request header, and if it is valid, it will set the authentication information in the security context. You can then use the security context to perform authorization checks on the API endpoints.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "JWT Token Authentication in Spring",
"url": "https://springframework.guru/jwt-authentication-in-spring-microservices-jwt-token/",
"type": "article"
},
{
"title": "Spring Security with JWT for REST API",
"url": "https://www.toptal.com/spring/spring-security-tutorial",
"type": "article"
},
{
"title": "Spring Security - JWT",
"url": "https://www.tutorialspoint.com/spring_security/spring_security_with_jwt.htm",
"type": "article"
},
{
"title": "Explore top posts about Authentication",
"url": "https://app.daily.dev/tags/authentication?ref=roadmapsh",
"type": "article"
}
]
},
"JrH2hiu27PhIO1VtrArMa": {
"title": "Spring Boot Starters",
"description": "Spring Boot starters are a set of convenient dependency descriptors that you can include in your application. They provide a variety of functionality, such as security, data access, and web services, and help to minimize the amount of boilerplate code and configuration you need to write.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Intro to Spring Boot Starters",
"url": "https://www.baeldung.com/spring-boot-starters",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"88-h3d7kb-VmUBsnUUXW_": {
"title": "Autoconfiguration",
"description": "Spring Boot's Autoconfiguration is a powerful and convenient feature that makes it easy to configure beans and other components in your application based on the presence of certain dependencies and properties. It saves developer's time by reducing the need for boilerplate configuration code, and can be fine-tuned through properties and annotations, to provide a fine-grained control over the auto-configurations.\n\nFor more information, visit the following links:",
"links": [
{
"title": "Auto-configuration using Spring Boot",
"url": "https://docs.spring.io/spring-boot/docs/2.0.x/reference/html/using-boot-auto-configuration.html",
"type": "article"
}
]
},
"N7hd3d_XQtvOgnCqdCFt3": {
"title": "Actuators",
"description": "Spring Boot Actuators are a set of production-ready features in Spring Boot that allow you to monitor and manage your application in various ways. They provide a variety of endpoints that expose information about the health and performance of your application, and allow you to perform various management tasks such as shutting down the application or refreshing its configuration.\n\nSpring Boot Actuators are typically used in production environments to monitor the health and performance of an application and identify any issues that may arise. They can also be used in development and testing environments to gain insight into the internal workings of the application.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Building a RESTful Web Service with Spring Boot Actuator",
"url": "https://spring.io/guides/gs/actuator-service/",
"type": "article"
},
{
"title": "What is Spring Boot Actuator",
"url": "https://www.baeldung.com/spring-boot-actuators",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"ONb0VnSUMY8JBeW3G2mTp": {
"title": "Embedded Server",
"description": "Spring Boot's Embedded Server feature is a convenient and powerful feature that allows you to run a web server directly within your application, without the need to deploy it to a separate standalone web server. This makes it easy to develop, test, and deploy web applications, and it's also lightweight, easy to start and stop, and easy to configure.\n\nFor more resources, visit the following links:",
"links": [
{
"title": "Embedded Web Servers ‘How-to’ guides",
"url": "https://docs.spring.io/spring-boot/docs/2.1.9.RELEASE/reference/html/howto-embedded-web-servers.html",
"type": "article"
},
{
"title": "Embedded Servers in Spring",
"url": "https://subscription.packtpub.com/book/application-development/9781789132588/3/ch03lvl1sec24/embedded-servers",
"type": "article"
},
{
"title": "What is an Embedded Server? (Spring Boot)",
"url": "https://www.springboottutorial.com/java-programmer-essentials-what-is-an-embedded-server",
"type": "article"
},
{
"title": "Explore top posts about Embedded Systems",
"url": "https://app.daily.dev/tags/embedded?ref=roadmapsh",
"type": "article"
}
]
},
"h5-HnycxfbJgwalSdXTAz": {
"title": "Hibernate",
"description": "Hibernate is a Java framework that provides an object-relational mapping to an object-oriented model to the relational database. It means hibernate provides from Java classes to database tables and also provides data querying and retrieval facility.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Difference Between Spring vs Hibernate",
"url": "https://www.educba.com/spring-vs-hibernate/",
"type": "article"
},
{
"title": "Spring Hibernate Integration Example",
"url": "https://www.digitalocean.com/community/tutorials/spring-hibernate-integration-example-tutorial",
"type": "article"
}
]
},
"H9Z0EvKT_148vD0mR-dUf": {
"title": "Transactions",
"description": "A transaction simply represents a unit of work. In such case, if one step fails, the whole transaction fails (which is termed as atomicity). A transaction can be described by ACID properties (Atomicity, Consistency, Isolation and Durability).\n\nIn hibernate framework, we have Transaction interface that defines the unit of work. It maintains abstraction from the transaction implementation (JTA,JDBC).\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Hibernate Transaction Management",
"url": "https://www.javaguides.net/2018/12/hibernate-transaction-management-tutorial.html",
"type": "article"
},
{
"title": "Hibernate Transaction",
"url": "https://www.w3schools.blog/hibernate-transaction-management",
"type": "article"
}
]
},
"D4ybyh0ydvl9W2_xUcvZ_": {
"title": "Relationships",
"description": "Using hibernate, if we want to have relationship between two entities, there must exist a foreign key relationship between the tables, we call it as Referential integrity. The main advantage of having relationship between objects is, we can do operation on one object, and the same operation can transfer onto the other object in the database.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Hibernate Relationships In Depth",
"url": "https://www.java4s.com/hibernate/hibernate-relationships-in-depth/",
"type": "article"
},
{
"title": "Guide to JPA with Hibernate - Relationship Mapping",
"url": "https://stackabuse.com/a-guide-to-jpa-with-hibernate-relationship-mapping/",
"type": "article"
},
{
"title": "Hibernate Mapping",
"url": "https://dzone.com/articles/hibernate-mapping",
"type": "article"
}
]
},
"Ijmy0J3VyaeTGXtu2VkkQ": {
"title": "Entity Lifecycle",
"description": "In Hibernate, we can either create a new object of an entity and store it into the database, or we can fetch the existing data of an entity from the database. These entity is connected with the lifecycle and each object of entity passes through the various stages of the lifecycle.\n\nThere are mainly four states of the Hibernate Lifecycle :\n\n* Transient State\n* Persistent State\n* Detached State\n* Removed State\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Hibernate Entity Lifecycle & and its state",
"url": "https://www.baeldung.com/hibernate-entity-lifecycle",
"type": "article"
}
]
},
"pvVLbFQoT50vz_VRK4VbJ": {
"title": "Spring Data",
"description": "Spring Data is a collection of projects for data access in Spring-based applications. It provides a common interface for working with various types of data stores, including relational databases, NoSQL data stores, and cloud-based data services. The goal of Spring Data is to simplify data access in Spring applications by providing a consistent, high-level repository programming model across different data stores and data access technologies. This can help developers write less boilerplate code and focus on business logic, while still being able to take advantage of the full power of the underlying data store.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Data",
"url": "https://spring.io/projects/spring-data",
"type": "article"
},
{
"title": "Spring Data – One API To Rule Them All?",
"url": "https://www.infoq.com/articles/spring-data-intro/",
"type": "article"
},
{
"title": "What is JPA, Spring Data and Spring Data JPA",
"url": "https://www.amitph.com/jpa-and-spring-data-jpa/",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"6u08QN-pUeFm3o0h5Scfm": {
"title": "Spring Data JPA",
"description": "Spring Data JPA is a library that makes it easy to implement Java Persistence API (JPA) based repositories (a fancy word for \"DAO\") for Spring applications. It's an abstraction on top of JPA that allows you to use a simpler and more convenient API for performing CRUD (Create, Read, Update, Delete) operations on databases. Spring Data JPA also provides additional functionality such as pagination, dynamic query generation, and more.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Data JPA",
"url": "https://spring.io/projects/spring-data-jpa",
"type": "article"
},
{
"title": "Introduction to Spring Data JPA",
"url": "https://www.baeldung.com/the-persistence-layer-with-spring-data-jpa",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"fy-TphbqkLpR1zvFcr7dg": {
"title": "Spring Data MongoDB",
"description": "Spring Data for MongoDB is part of the umbrella Spring Data project which aims to provide a familiar and consistent Spring-based programming model for new datastores while retaining store-specific features and capabilities\n\nThe Spring Data MongoDB project provides integration with the MongoDB document database. Key functional areas of Spring Data MongoDB are a POJO centric model for interacting with a MongoDB DBCollection and easily writing a Repository style data access layer.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Data MongoDB",
"url": "https://spring.io/projects/spring-data-mongodb",
"type": "article"
},
{
"title": "Introduction to Spring Data MongoDB",
"url": "https://www.baeldung.com/spring-data-mongodb-tutorial",
"type": "article"
},
{
"title": "Spring Boot Integration with MongoDB Tutorial",
"url": "https://www.mongodb.com/compatibility/spring-boot",
"type": "article"
},
{
"title": "Explore top posts about MongoDB",
"url": "https://app.daily.dev/tags/mongodb?ref=roadmapsh",
"type": "article"
}
]
},
"dd1A-MyzBs_kNOtVG7f1D": {
"title": "Spring Data JDBC",
"description": "Spring Data JDBC is a part of the Spring Data project that provides support for using JDBC (Java Database Connectivity) to interact with relational databases. It is designed to provide a simple and consistent programming model for interacting with databases using JDBC, while still allowing for the full power of JDBC to be used if needed. Spring Data JDBC provides a set of abstraction and utility classes that simplify the task of working with databases, such as a simple template class for executing SQL queries, a repository abstraction for implementing data access objects (DAOs), and support for pagination and sorting of query results. It works with both Java and Kotlin.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Data JDBC",
"url": "https://spring.io/projects/spring-data-jdbc",
"type": "article"
},
{
"title": "Spring Data JDBC - Reference Documentation",
"url": "https://docs.spring.io/spring-data/jdbc/docs/current/reference/html/",
"type": "article"
},
{
"title": "Introduction to Spring Data JDBC",
"url": "https://www.baeldung.com/spring-data-jdbc-intro",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"jU_KHoPUSU_HoIKk0ZpRF": {
"title": "Microservices",
"description": "Spring Microservices is a framework that makes it easier to build and manage microservices-based applications using the Spring Framework. Microservices is an architectural style in which a large application is built as a collection of small, independently deployable services. Each service has a narrowly defined responsibility and communicates with other services through APIs.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Microservices with Spring",
"url": "https://spring.io/microservices",
"type": "article"
},
{
"title": "Microservices with Spring Boot ",
"url": "https://medium.com/omarelgabrys-blog/microservices-with-spring-boot-intro-to-microservices-part-1-c0d24cd422c3",
"type": "article"
},
{
"title": "Explore top posts about Microservices",
"url": "https://app.daily.dev/tags/microservices?ref=roadmapsh",
"type": "article"
}
]
},
"VWNDYSw83Vzi2UPQprJ5z": {
"title": "Spring Cloud",
"description": "Spring Cloud is a collection of libraries and tools for building cloud-native applications using the Spring Framework. It provides a set of abstractions and implementations for common patterns and best practices used in cloud-based applications, such as service discovery, configuration management, and circuit breaker patterns, among others.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Cloud",
"url": "https://spring.io/projects/spring-cloud",
"type": "article"
},
{
"title": "Spring Cloud – Bootstrapping",
"url": "https://www.baeldung.com/spring-cloud-bootstrapping",
"type": "article"
},
{
"title": "Explore top posts about Cloud",
"url": "https://app.daily.dev/tags/cloud?ref=roadmapsh",
"type": "article"
}
]
},
"f-i0NX2KOzCh3JwkaSPFo": {
"title": "Spring Cloud Gateway",
"description": "Spring Cloud Gateway is a Spring Framework library for building API gateways. An API gateway is a service that acts as an intermediary between an application and a set of microservices. The API gateway is responsible for request routing, composition, and protocol translation, among other things. It can also perform tasks such as authentication, rate limiting, and caching.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Cloud Gateway",
"url": "https://spring.io/projects/spring-cloud-gateway",
"type": "article"
},
{
"title": "What is Spring Cloud Gateway?",
"url": "https://tanzu.vmware.com/developer/guides/scg-what-is/",
"type": "article"
},
{
"title": "Exploring the New Spring Cloud Gateway",
"url": "https://www.baeldung.com/spring-cloud-gateway",
"type": "article"
},
{
"title": "Explore top posts about Cloud",
"url": "https://app.daily.dev/tags/cloud?ref=roadmapsh",
"type": "article"
}
]
},
"9hG3CB8r41bUb_s8-0u73": {
"title": "Cloud Config",
"description": "Spring Cloud Config is a library for managing configuration properties for distributed applications. It allows developers to externalize configuration properties for an application, so that they can be easily changed without modifying the application's code. It also provides a centralized server for storing and managing configuration properties for multiple applications, making it easy to update and rollback configurations across different environments.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Cloud Config",
"url": "https://spring.io/projects/spring-cloud-config",
"type": "article"
},
{
"title": "Quick Intro to Spring Cloud Configuration",
"url": "https://www.baeldung.com/spring-cloud-configuration",
"type": "article"
},
{
"title": "Spring Boot - Cloud Configuration Server",
"url": "https://www.tutorialspoint.com/spring_boot/spring_boot_cloud_configuration_server.htm",
"type": "article"
},
{
"title": "Explore top posts about Cloud",
"url": "https://app.daily.dev/tags/cloud?ref=roadmapsh",
"type": "article"
}
]
},
"kqpSlO--X9-xYxfq1KFVe": {
"title": "Spring Cloud Circuit Breaker",
"description": "Spring Cloud Circuit Breaker is a library for managing the fault tolerance of microservices-based applications using the Circuit Breaker pattern. The Circuit Breaker pattern is a design pattern that helps to prevent cascading failures and improve the resilience of distributed systems. It does this by introducing a \"circuit breaker\" proxy in front of a service that can detect when the service is unresponsive or has failed, and stop routing traffic to it temporarily, in order to allow the service to recover.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Cloud Circuit Breaker",
"url": "https://spring.io/projects/spring-cloud-circuitbreaker",
"type": "article"
},
{
"title": "Quick Guide to Spring Cloud Circuit Breaker",
"url": "https://www.baeldung.com/spring-cloud-circuit-breaker",
"type": "article"
},
{
"title": "Spring Cloud - Circuit Breaker using Hystrix",
"url": "https://www.tutorialspoint.com/spring_cloud/spring_cloud_circuit_breaker_using_hystrix.htm",
"type": "article"
},
{
"title": "Explore top posts about Cloud",
"url": "https://app.daily.dev/tags/cloud?ref=roadmapsh",
"type": "article"
}
]
},
"EKSXTMSN2xdaleJ4wOV1A": {
"title": "Spring Cloud Open Feign",
"description": "Spring Cloud OpenFeign is a library for creating declarative REST clients in Spring applications. It allows developers to easily make HTTP requests to other microservices or remote services, without having to manually write the low-level code to handle the requests and responses. OpenFeign is built on top of the OpenFeign declarative HTTP client, which is a simple, lightweight library for creating HTTP clients in Java.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Introduction to Spring Cloud OpenFeign",
"url": "https://www.baeldung.com/spring-cloud-openfeign",
"type": "article"
},
{
"title": "Spring Cloud OpenFeign",
"url": "https://spring.io/projects/spring-cloud-openfeign",
"type": "article"
},
{
"title": "Simple Implementation of Spring Cloud OpenFeign",
"url": "https://medium.com/javarevisited/simple-implementation-of-spring-cloud-openfeign-7f022630d01d",
"type": "article"
},
{
"title": "Explore top posts about Cloud",
"url": "https://app.daily.dev/tags/cloud?ref=roadmapsh",
"type": "article"
}
]
},
"GsmBGRohWbJ6XOaALFZ8o": {
"title": "Micrometer",
"description": "",
"links": []
},
"6sLE6gb5Y477SmO2GhQIG": {
"title": "Eurkea",
"description": "Spring Cloud Eureka is a library for service discovery in a microservices-based architecture. Service discovery is a technique that allows services to find and communicate with each other, without having to hardcode their addresses.\n\nEureka is a service registry that allows service instances to register themselves and to discover other services by name. It provides a simple, consistent way for services to find and communicate with each other, and it integrates with other Spring Cloud libraries such as Ribbon and Feign to provide load balancing and declarative REST clients.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Introduction to Spring Cloud Netflix – Eureka",
"url": "https://www.baeldung.com/spring-cloud-netflix-eureka",
"type": "article"
},
{
"title": "Spring Boot - Eureka Server",
"url": "https://www.tutorialspoint.com/spring_boot/spring_boot_eureka_server.htm",
"type": "article"
},
{
"title": "Explore top posts about Backend Development",
"url": "https://app.daily.dev/tags/backend?ref=roadmapsh",
"type": "article"
},
{
"title": "Introducing Spring Cloud EUREKA",
"url": "https://www.youtube.com/watch?v=1uNo1NrqsX4",
"type": "video"
}
]
},
"S-BbOoRD7anvoJrprjoKF": {
"title": "Spring MVC",
"description": "Spring MVC is a web application framework that is part of the Spring Framework. It is designed to make it easy to build web applications using the Model-View-Controller (MVC) design pattern.\n\nIn Spring MVC, the application is divided into three main components: the Model, the View, and the Controller. The Model represents the data and the business logic of the application, the View is responsible for generating the HTML that is sent to the client's web browser, and the Controller acts as an intermediary between the Model and the View, handling incoming HTTP requests and generating the appropriate response.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring - MVC Framework",
"url": "https://www.tutorialspoint.com/spring/spring_web_mvc_framework.htm",
"type": "article"
},
{
"title": "Spring MVC Tutorial – Everything You Need To Know",
"url": "https://www.edureka.co/blog/spring-mvc-tutorial/",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"35NTx2eO1j02sjy4m6DPq": {
"title": "Servlet",
"description": "A Spring servlet is a Java class that serves as the central point for handling requests and managing the lifecycle of the Spring IoC container. The Spring Framework provides a class called DispatcherServlet, which acts as the front controller in a Spring-based web application. When a user makes a request to a Spring web application, the DispatcherServlet is responsible for handling the request, delegating responsibility to other components, and ultimately returning a response to the user. The DispatcherServlet also manages the lifecycle of the Spring IoC container, including creating and initializing the container and making its beans available for use by other components in the application.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "The DispatcherServlet",
"url": "https://docs.spring.io/spring-framework/docs/3.0.0.M4/spring-framework-reference/html/ch15s02.html",
"type": "article"
},
{
"title": "DispatcherServlet and web.xml in Spring Boot",
"url": "https://www.baeldung.com/spring-boot-dispatcherservlet-web-xml",
"type": "article"
}
]
},
"Lz0GPMiYzb30iFJdv1dL6": {
"title": "JSP Files",
"description": "JSP (JavaServer Pages) is a technology for building dynamic web pages using Java.\n\nIn a Spring MVC application that uses JSPs, the view component of the MVC pattern is implemented using JSP files. The JSP files contain the presentation logic for the application and are responsible for generating the HTML that is sent to the client's web browser. When a user makes a request to a Spring MVC application, the DispatcherServlet, which acts as the front controller, handles the request and delegates responsibility for generating the response to the appropriate JSP file.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring Boot With JavaServer Pages (JSP)",
"url": "https://www.baeldung.com/spring-boot-jsp",
"type": "article"
},
{
"title": "Spring MVC: from JSP and Tiles to Thymeleaf",
"url": "https://spring.io/blog/2012/10/30/spring-mvc-from-jsp-and-tiles-to-thymeleaf/",
"type": "article"
}
]
},
"_vS_zdJZegZS6MIKAFyg8": {
"title": "Architecture",
"description": "The Spring MVC (Model-View-Controller) is a web application framework that is part of the Spring Framework. It is designed to make it easy to build web applications using the MVC design pattern.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Overview of Spring MVC Architecture",
"url": "https://terasolunaorg.github.io/guideline/1.0.1.RELEASE/en/Overview/SpringMVCOverview.html",
"type": "article"
},
{
"title": "Explore top posts about Architecture",
"url": "https://app.daily.dev/tags/architecture?ref=roadmapsh",
"type": "article"
}
]
},
"sgA06Tu9Y4cEHtfI8CyLL": {
"title": "Components",
"description": "The Spring MVC (Model-View-Controller) framework has several key components that work together to handle the requests and generate the appropriate responses in a web application.\n\nThere are other supporting components that are used to manage the lifecycle of the application's objects, such as the Spring IoC container and different interceptors that provides additional functionality, such as caching and security.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Web MVC Framework",
"url": "https://docs.spring.io/spring-framework/docs/3.2.x/spring-framework-reference/html/mvc.html",
"type": "article"
}
]
},
"7Qqrh_Rz_7uAD49g9sDzi": {
"title": "Testing",
"description": "Spring provides a set of testing utilities that make it easy to test the various components of a Spring application, including controllers, services, repositories, and other components. It has a rich set of testing annotations, utility classes and other features to aid in unit testing, integration testing and more.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "What Is Spring Testing?",
"url": "https://www.developer.com/design/what-is-spring-testing/",
"type": "article"
},
{
"title": "Complete Guide To Spring Testing",
"url": "https://www.lambdatest.com/blog/spring-testing/",
"type": "article"
},
{
"title": "Explore top posts about Testing",
"url": "https://app.daily.dev/tags/testing?ref=roadmapsh",
"type": "article"
}
]
},
"Nhx2QiSD_4pVWD17lsCbu": {
"title": "JPA Test",
"description": "Spring JPA (Java Persistence API) is a library that makes it easy to work with databases and other data stores in a Spring application. Spring JPA uses the Java Persistence API (JPA) to interact with databases and provides an abstraction layer to work with different data stores.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Testing JPA Queries with Spring Boot and @DataJpaTest",
"url": "https://reflectoring.io/spring-boot-data-jpa-test/",
"type": "article"
},
{
"title": "@DataJpaTest example for Spring Data Repository Unit Test",
"url": "https://www.bezkoder.com/spring-boot-unit-test-jpa-repo-datajpatest/",
"type": "article"
},
{
"title": "Testing in Spring Boot",
"url": "https://www.baeldung.com/spring-boot-testing",
"type": "article"
},
{
"title": "Explore top posts about Java",
"url": "https://app.daily.dev/tags/java?ref=roadmapsh",
"type": "article"
}
]
},
"5d1BERqTKNJMKiBcqa8Ie": {
"title": "Mock MVC",
"description": "Spring's MockMvc is a class that allows you to test Spring MVC controllers without the need for an actual web server. It is part of the Spring Test module, which provides a set of testing utilities for Spring applications.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Spring MockMVC tutorial",
"url": "https://zetcode.com/spring/mockmvc/",
"type": "article"
},
{
"title": "Spring Boot MockMVC Example",
"url": "https://howtodoinjava.com/spring-boot2/testing/spring-boot-mockmvc-example/",
"type": "article"
},
{
"title": "Integration Testing in Spring",
"url": "https://baeldung.com/integration-testing-in-spring",
"type": "article"
}
]
},
"p91CaVPh5GMzFU0yEU_hl": {
"title": "@SpringBootTest Annotation",
"description": "`@SpringBootTest` This annotation is used to create a fully-configured instance of the Spring ApplicationContext for testing. It can be used to test the application's components, including controllers, services, and repositories, in a real application environment.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Testing with Spring Boot and @SpringBootTest",
"url": "https://reflectoring.io/spring-boot-test/",
"type": "article"
},
{
"title": "Annotation Interface SpringBootTest",
"url": "https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/context/SpringBootTest.html",
"type": "article"
},
{
"title": "Testing in Spring Boot",
"url": "https://www.baeldung.com/spring-boot-testing",
"type": "article"
},
{
"title": "Explore top posts about Spring Framework",
"url": "https://app.daily.dev/tags/spring?ref=roadmapsh",
"type": "article"
}
]
},
"i77NTa0hpGGBjmql9u_CT": {
"title": "@MockBean Annotation",
"description": "`MockBean` is a Spring annotation that can be used to create a mock implementation of a bean in the Spring application context. When a test is annotated with MockBean, Spring creates a mock implementation of the specified bean and adds it to the application context. The mock bean can then be used to replace the real bean during testing.\n\nVisit the following resources to learn more:",
"links": [
{
"title": "Annotation Interface MockBean",
"url": "https://docs.spring.io/spring-boot/docs/current/api/org/springframework/boot/test/mock/mockito/MockBean.html",
"type": "article"
},
{
"title": "Mockito.mock() vs @Mock vs @MockBean",
"url": "https://www.baeldung.com/java-spring-mockito-mock-mockbean",
"type": "article"
},
{
"title": "Spring Boot @MockBean Example",
"url": "https://howtodoinjava.com/spring-boot2/testing/spring-mockbean-annotation/",
"type": "article"
}
]
}
}

186
public/roadmap-content/sql.json
View File

@@ -39,11 +39,6 @@
"title": "SQL Tutorial",
"url": "https://www.sqltutorial.org/",
"type": "article"
},
{
"title": "SQL Tutorial - W3Schools",
"url": "https://www.w3schools.com/sql/default.asp",
"type": "article"
}
]
},
@@ -76,11 +71,6 @@
"title": "SQL Tutorial",
"url": "https://www.sqltutorial.org/",
"type": "article"
},
{
"title": "SQL Tutorial - W3Schools",
"url": "https://www.w3schools.com/sql/default.asp",
"type": "article"
}
]
},
@@ -88,11 +78,6 @@
"title": "SQL Keywords",
"description": "SQL keywords are reserved words that have special meanings within SQL statements. These include commands (like `SELECT`, `INSERT`, `UPDATE`), clauses (such as `WHERE`, `GROUP BY`, `HAVING`), and other syntax elements that form the structure of SQL queries. Understanding SQL keywords is fundamental to writing correct and effective database queries. Keywords are typically case-insensitive but are often written in uppercase by convention for better readability.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL Keywords Reference",
"url": "https://www.w3schools.com/sql/sql_ref_keywords.asp",
"type": "article"
},
{
"title": "SQL Keywords, Operators and Statements",
"url": "https://blog.hubspot.com/website/sql-keywords-operators-statements",
@@ -120,11 +105,6 @@
"title": "Operators",
"description": "SQL operators are symbols or keywords used to perform operations on data within a database. They are essential for constructing queries that filter, compare, and manipulate data. Common types of operators include arithmetic operators (e.g., `+`, `-`, `*`, `/`), which perform mathematical calculations; comparison operators (e.g., `=`, `!=`, `<`, `>`), used to compare values; logical operators (e.g., `AND`, `OR`, `NOT`), which combine multiple conditions in a query; and set operators (e.g., `UNION`, `INTERSECT`, `EXCEPT`), which combine results from multiple queries. These operators enable precise control over data retrieval and modification.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL Operators",
"url": "https://www.w3schools.com/sql/sql_operators.asp",
"type": "article"
},
{
"title": "SQL Operators: 6 Different Types",
"url": "https://www.dataquest.io/blog/sql-operators/",
@@ -135,23 +115,12 @@
"rmqXH29n1oXtZ8tvmcRFn": {
"title": "SELECT",
"description": "SELECT is one of the most fundamental SQL commands, used to retrieve data from one or more tables in a database. It allows you to specify which columns to fetch, apply filtering conditions, sort results, and perform various operations on the data. The SELECT statement is versatile, supporting joins, subqueries, aggregations, and more, making it essential for data querying and analysis in relational databases.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL_Select",
"url": "https://www.w3schools.com/sql/sql_select.asp",
"type": "article"
}
]
"links": []
},
"mPj6BiK5FKKkIQ9WsWEo6": {
"title": "INSERT",
"description": "The \"INSERT\" statement is used to add new rows of data to a table in a database. There are two main forms of the INSERT command: `INSERT INTO` which, if columns are not named, expects a full set of columns, and `INSERT INTO table_name (column1, column2, ...)` where only named columns will be filled with data.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL INSERT",
"url": "https://www.w3schools.com/sql/sql_insert.asp",
"type": "article"
},
{
"title": "SQL INSERT Statement",
"url": "https://www.youtube.com/watch?v=Yp1MKeIG-M4",
@@ -163,11 +132,6 @@
"title": "UPDATE",
"description": "The UPDATE statement in SQL is used to modify existing records in a table. It allows you to change the values of one or more columns based on specified conditions. The basic syntax includes specifying the table name, the columns to be updated with their new values, and optionally, a WHERE clause to filter which rows should be affected. UPDATE can be used in conjunction with subqueries, joins, and CTEs (Common Table Expressions) for more complex data modifications. It's important to use UPDATE carefully, especially with the WHERE clause, to avoid unintended changes to data. In transactional databases, UPDATE operations can be rolled back if they're part of a transaction that hasn't been committed.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL UPDATE Statement",
"url": "https://www.w3schools.com/sql/sql_update.asp",
"type": "article"
},
{
"title": "Efficient column updates in SQL",
"url": "https://www.atlassian.com/data/sql/how-to-update-a-column-based-on-a-filter-of-another-column",
@@ -254,11 +218,6 @@
"title": "Drop Table",
"description": "The `DROP TABLE` statement is a Data Definition Language (DDL) operation that is used to **completely remove** a table from the database. This operation deletes the table structure along with **all the data in** it, effectively removing the table from the database system.\n\nWhen you execute the `DROP TABLE` statement, it eliminates both the table and its data, as well as any associated indexes, constraints, and triggers. Unlike the `TRUNCATE TABLE` statement, which only removes data but keeps the table structure, `DROP TABLE` removes everything associated with the table.\n\nLearn more from the following resources:",
"links": [
{
"title": "DROP TABLE",
"url": "https://www.w3schools.com/sql/sql_drop_table.asp",
"type": "article"
},
{
"title": "Drop a Table",
"url": "https://www.coginiti.co/tutorials/beginner/drop-a-table/",
@@ -290,23 +249,12 @@
"i8u8E_sne6XiKJo2FXDog": {
"title": "Select",
"description": "SELECT is one of the most fundamental SQL commands, used to retrieve data from one or more tables in a database. It allows you to specify which columns to fetch, apply filtering conditions, sort results, and perform various operations on the data. The SELECT statement is versatile, supporting joins, subqueries, aggregations, and more, making it essential for data querying and analysis in relational databases.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL_Select",
"url": "https://www.w3schools.com/sql/sql_select.asp",
"type": "article"
}
]
"links": []
},
"N1Racr3ZpU320gS545We8": {
"title": "FROM",
"description": "The `FROM` clause in SQL specifies the tables from which the retrieval should be made. It is an integral part of `SELECT` statements and variants of `SELECT` like `SELECT INTO` and `SELECT WHERE`. `FROM` can be used to join tables as well.\n\nTypically, `FROM` is followed by space delimited list of tables in which the SELECT operation is to be executed. If you need to pull data from multiple tables, you would separate each table with a comma.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL FROM Keyword",
"url": "https://www.w3schools.com/sql/sql_ref_from.asp",
"type": "article"
},
{
"title": "How to write basic SQL",
"url": "https://www.youtube.com/watch?v=YfTDBA45PHk",
@@ -334,11 +282,6 @@
"title": "ORDER BY",
"description": "The `ORDER BY` clause in SQL is used to sort the result set of a query by one or more columns. By default, the sorting is in ascending order, but you can specify descending order using the `DESC` keyword. The clause can sort by numeric, date, or text values, and multiple columns can be sorted by listing them in the `ORDER BY` clause, each with its own sorting direction. This clause is crucial for organizing data in a meaningful sequence, such as ordering by a timestamp to show the most recent records first, or alphabetically by name.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL ORDER BY Keyword",
"url": "https://www.w3schools.com/sql/sql_orderby.asp",
"type": "article"
},
{
"title": "SQL ORDER BY Sorting Clause",
"url": "https://www.youtube.com/watch?v=h_HHTNjAgS8",
@@ -398,11 +341,6 @@
"title": "INSERT",
"description": "The \"INSERT\" statement is used to add new rows of data to a table in a database. There are two main forms of the INSERT command: `INSERT INTO` which, if columns are not named, expects a full set of columns, and `INSERT INTO table_name (column1, column2, ...)` where only named columns will be filled with data.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL INSERT",
"url": "https://www.w3schools.com/sql/sql_insert.asp",
"type": "article"
},
{
"title": "SQL INSERT Statement",
"url": "https://www.youtube.com/watch?v=Yp1MKeIG-M4",
@@ -414,11 +352,6 @@
"title": "UPDATE",
"description": "The UPDATE statement in SQL is used to modify existing records in a table. It allows you to change the values of one or more columns based on specified conditions. The basic syntax includes specifying the table name, the columns to be updated with their new values, and optionally, a WHERE clause to filter which rows should be affected. UPDATE can be used in conjunction with subqueries, joins, and CTEs (Common Table Expressions) for more complex data modifications. It's important to use UPDATE carefully, especially with the WHERE clause, to avoid unintended changes to data. In transactional databases, UPDATE operations can be rolled back if they're part of a transaction that hasn't been committed.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL UPDATE Statement",
"url": "https://www.w3schools.com/sql/sql_update.asp",
"type": "article"
},
{
"title": "Efficient column updates in SQL",
"url": "https://www.atlassian.com/data/sql/how-to-update-a-column-based-on-a-filter-of-another-column",
@@ -446,11 +379,6 @@
"title": "SUM",
"description": "SUM is an aggregate function in SQL used to calculate the total of a set of values. It's commonly used with numeric columns in combination with GROUP BY clauses to compute totals for different categories or groups within the data. SUM is essential for financial calculations, statistical analysis, and generating summary reports from database tables. It ignores NULL values and can be used in conjunction with other aggregate functions for complex data analysis.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL SUM Function",
"url": "https://www.w3schools.com/sql/sql_sum.asp",
"type": "article"
},
{
"title": "SQL SUM",
"url": "https://www.studysmarter.co.uk/explanations/computer-science/databases/sql-sum/",
@@ -462,11 +390,6 @@
"title": "COUNT",
"description": "`COUNT` is an SQL aggregate function that returns the number of rows that match the specified criteria. It can be used to count all rows in a table, non-null values in a specific column, or rows that meet certain conditions when combined with a `WHERE` clause. `COUNT` is often used in data analysis, reporting, and performance optimization queries to determine the size of datasets or the frequency of particular values.\n\nLearn more from the following resources:",
"links": [
{
"title": "COUNT",
"url": "https://www.w3schools.com/sql/sql_count.asp",
"type": "article"
},
{
"title": "COUNT SQL Function",
"url": "https://www.datacamp.com/tutorial/count-sql-function",
@@ -558,11 +481,6 @@
"title": "Data Constraints",
"description": "Data constraints in SQL are rules applied to columns or tables to enforce data integrity and consistency. They include primary key, foreign key, unique, check, and not null constraints. These constraints define limitations on the data that can be inserted, updated, or deleted in a database, ensuring that the data meets specific criteria and maintains relationships between tables. By implementing data constraints, database designers can prevent invalid data entry, maintain referential integrity, and enforce business rules directly at the database level.\n\nLearn more from the following resources:",
"links": [
{
"title": "Data Constraints",
"url": "https://www.w3schools.com/sql/sql_constraints.asp",
"type": "article"
},
{
"title": "SQL Constraints",
"url": "https://www.programiz.com/sql/constraints",
@@ -574,11 +492,6 @@
"title": "Primary Key",
"description": "A primary key in SQL is a unique identifier for each record in a database table. It ensures that each row in the table is uniquely identifiable, meaning no two rows can have the same primary key value. A primary key is composed of one or more columns, and it must contain unique values without any `NULL` entries. The primary key enforces entity integrity by preventing duplicate records and ensuring that each record can be precisely located and referenced, often through foreign key relationships in other tables. Using a primary key is fundamental for establishing relationships between tables and maintaining the integrity of the data model.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL PRIMARY KEY Constraint",
"url": "https://www.w3schools.com/sql/sql_primarykey.ASP",
"type": "article"
},
{
"title": "SQL Primary Key",
"url": "https://www.tutorialspoint.com/sql/sql-primary-key.htm",
@@ -633,11 +546,6 @@
"title": "CHECK",
"description": "A `CHECK` constraint in SQL is used to enforce data integrity by specifying a condition that must be true for each row in a table. It allows you to define custom rules or restrictions on the values that can be inserted or updated in one or more columns. `CHECK` constraints help maintain data quality by preventing invalid or inconsistent data from being added to the database, ensuring that only data meeting specified criteria is accepted.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL CHECK Constraint",
"url": "https://www.w3schools.com/sql/sql_check.asp",
"type": "article"
},
{
"title": "CHECK Constraint",
"url": "https://www.youtube.com/watch?v=EeG2boJCXbc",
@@ -665,11 +573,6 @@
"title": "INNER JOIN",
"description": "An `INNER JOIN` in SQL is a type of join that returns the records with matching values in both tables. This operation compares each row of the first table with each row of the second table to find all pairs of rows that satisfy the join predicate.\n\nFew things to consider in case of `INNER JOIN`:\n\n* It is a default join in SQL. If you mention `JOIN` in your query without specifying the type, SQL considers it as an `INNER JOIN`.\n* It returns only the matching rows from both the tables.\n* If there is no match, the returned is an empty result.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL INNER JOIN",
"url": "https://www.w3schools.com/sql/sql_join_inner.asp",
"type": "article"
},
{
"title": "SQL INNER JOIN Clause",
"url": "https://www.programiz.com/sql/inner-join",
@@ -681,11 +584,6 @@
"title": "LEFT JOIN",
"description": "A `LEFT JOIN` in SQL returns all rows from the left (first) table and the matching rows from the right (second) table. If there's no match in the right table, `NULL` values are returned for those columns. This join type is useful when you want to see all records from one table, regardless of whether they have corresponding entries in another table. `LEFT JOIN`s are commonly used for finding missing relationships, creating reports that include all primary records, or when working with data where not all entries have corresponding matches in related tables.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL LEFT JOIN",
"url": "https://www.w3schools.com/sql/sql_join_left.asp",
"type": "article"
},
{
"title": "SQL LEFT JOIN - SQL Tutorial",
"url": "https://www.youtube.com/watch?v=giKwmtsz1U8",
@@ -697,11 +595,6 @@
"title": "RIGHT JOIN",
"description": "A `RIGHT JOIN` in SQL is a type of outer join that returns all rows from the right (second) table and the matching rows from the left (first) table. If there's no match in the left table, `NULL` values are returned for the left table's columns. This join type is less commonly used than LEFT JOIN but is particularly useful when you want to ensure all records from the second table are included in the result set, regardless of whether they have corresponding matches in the first table. `RIGHT JOIN` is often used to identify missing relationships or to include all possible values from a lookup table.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL RIGHT JOIN",
"url": "https://www.w3schools.com/sql/sql_join_right.asp",
"type": "article"
},
{
"title": "SQL RIGHT JOIN With Examples",
"url": "https://www.programiz.com/sql/right-join",
@@ -713,11 +606,6 @@
"title": "FULL OUTER JOIN",
"description": "A `FULL OUTER JOIN` in SQL combines the results of both `LEFT` and `RIGHT OUTER JOIN`s. It returns all rows from both tables, matching records where the join condition is met and including unmatched rows from both tables with `NULL` values in place of missing data. This join type is useful when you need to see all data from both tables, regardless of whether there are matching rows, and is particularly valuable for identifying missing relationships or performing data reconciliation between two tables.\n\nLearn more from the following resources:",
"links": [
{
"title": "FULL OUTER JOIN",
"url": "https://www.w3schools.com/sql/sql_join_full.asp",
"type": "article"
},
{
"title": "SQL FULL OUTER JOIN",
"url": "https://www.youtube.com/watch?v=XpBkXo3DCEg",
@@ -745,11 +633,6 @@
"title": "Cross Join",
"description": "The cross join in SQL is used to combine every row of the first table with every row of the second table. It's also known as the Cartesian product of the two tables. The most important aspect of performing a cross join is that it does not require any condition to join.\n\nThe issue with cross join is it returns the Cartesian product of the two tables, which can result in large numbers of rows and heavy resource usage. It's hence critical to use them wisely and only when necessary.\n\nLearn more from the following resources:",
"links": [
{
"title": "CROSS JOIN",
"url": "https://www.w3schools.com/mysql/mysql_join_cross.asp",
"type": "article"
},
{
"title": "SQL CROSS JOIN With Examples",
"url": "https://www.sqlshack.com/sql-cross-join-with-examples/",
@@ -793,11 +676,6 @@
"title": "Column",
"description": "In SQL, columns are used to categorize the data in a table. A column serves as a structure that stores a specific type of data (ints, str, bool, etc.) in a table. Each column in a table is designed with a type, which configures the data that it can hold. Using the right column types and size can help to maintain data integrity and optimize performance.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL Column",
"url": "https://www.w3schools.com/sql/sql_ref_column.asp",
"type": "article"
},
{
"title": "Column Types - PostgreSQL",
"url": "https://www.postgresqltutorial.com/postgresql-tutorial/postgresql-data-types/",
@@ -878,11 +756,6 @@
"title": "FLOOR",
"description": "The SQL `FLOOR` function is used to round down any specific decimal or numeric value to its nearest whole integer. The returned number will be less than or equal to the number given as an argument.\n\nOne important aspect to note is that the `FLOOR` function's argument must be a number and it always returns an integer.\n\nLearn more from the following resources:",
"links": [
{
"title": "FLOOR",
"url": "https://www.w3schools.com/sql/func_sqlserver_floor.asp",
"type": "article"
},
{
"title": "How to Round in SQL",
"url": "https://www.youtube.com/watch?v=AUXw2JRwCFY",
@@ -910,11 +783,6 @@
"title": "MOD",
"description": "The `MOD` function in SQL calculates the remainder when one number is divided by another. It takes two arguments: the dividend and the divisor. `MOD` returns the remainder of the division operation, which is useful for various mathematical operations, including checking for odd/even numbers, implementing cyclic behaviors, or distributing data evenly. The syntax and exact behavior may vary slightly between different database systems, with some using the % operator instead of the `MOD` keyword.\n\nLearn more from the following resources:",
"links": [
{
"title": "MOD",
"url": "https://www.w3schools.com/sql/func_mysql_mod.asp",
"type": "article"
},
{
"title": "MOD Function in SQL",
"url": "https://www.youtube.com/watch?v=f1Rqf7CwjE0",
@@ -926,11 +794,6 @@
"title": "ROUND",
"description": "The `ROUND` function in SQL is used to round a numeric value to a specified number of decimal places. It takes two arguments: the number to be rounded and the number of decimal places to round to. If the second argument is omitted, the function rounds the number to the nearest whole number. For positive values of the second argument, the number is rounded to the specified decimal places; for negative values, it rounds to the nearest ten, hundred, thousand, etc. The `ROUND` function is useful for formatting numerical data for reporting or ensuring consistent precision in calculations.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL ROUND",
"url": "https://www.w3schools.com/sql/func_sqlserver_round.asp",
"type": "article"
},
{
"title": "What is the SQL ROUND Function and how does it work?",
"url": "https://www.datacamp.com/tutorial/mastering-sql-round",
@@ -957,11 +820,6 @@
"title": "An overview of the CONCAT function in SQL",
"url": "https://www.sqlshack.com/an-overview-of-the-concat-function-in-sql-with-examples/",
"type": "article"
},
{
"title": "SQL Server CONCAT",
"url": "https://www.w3schools.com/sql/func_sqlserver_concat.asp",
"type": "article"
}
]
},
@@ -1001,11 +859,6 @@
"title": "REPLACE",
"description": "The `REPLACE` function in SQL is used to substitute all occurrences of a specified substring within a string with a new substring. It takes three arguments: the original string, the substring to be replaced, and the substring to replace it with. If the specified substring is found in the original string, `REPLACE` returns the modified string with all instances of the old substring replaced by the new one. If the substring is not found, the original string is returned unchanged. This function is particularly useful for data cleaning tasks, such as correcting typos, standardizing formats, or replacing obsolete data.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL REPLACE Function",
"url": "https://www.w3schools.com/sql/func_sqlserver_replace.asp",
"type": "article"
},
{
"title": "How to use the SQL REPLACE Function",
"url": "https://www.datacamp.com/tutorial/sql-replace",
@@ -1017,11 +870,6 @@
"title": "UPPER",
"description": "UPPER() is a string function in SQL used to convert all characters in a specified string to uppercase. This function is particularly useful for data normalization, case-insensitive comparisons, or formatting output. UPPER() typically works on alphabetic characters and leaves non-alphabetic characters unchanged. It's often used in SELECT statements to display data, in WHERE clauses for case-insensitive searches, or in data manipulation operations. Most SQL databases also provide a complementary LOWER() function for converting to lowercase. When working with international character sets, it's important to be aware of potential locale-specific behavior of UPPER().\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL Server UPPER Function",
"url": "https://www.w3schools.com/sql/func_sqlserver_upper.asp",
"type": "article"
},
{
"title": "How to Convert a String to Uppercase in SQL",
"url": "https://learnsql.com/cookbook/how-to-convert-a-string-to-uppercase-in-sql/",
@@ -1049,11 +897,6 @@
"title": "CASE",
"description": "The CASE statement in SQL is used to create conditional logic within a query, allowing you to perform different actions based on specific conditions. It operates like an if-else statement, returning different values depending on the outcome of each condition. The syntax typically involves specifying one or more WHEN conditions, followed by the result for each condition, and an optional ELSE clause for a default outcome if none of the conditions are met.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL CASE Expression",
"url": "https://www.w3schools.com/sql/sql_case.asp",
"type": "article"
},
{
"title": "SQL CASE - Intermediate SQL",
"url": "https://mode.com/sql-tutorial/sql-case",
@@ -1065,11 +908,6 @@
"title": "NULLIF",
"description": "`NULLIF` is an SQL function that compares two expressions and returns NULL if they are equal, otherwise it returns the first expression. It's particularly useful for avoiding division by zero errors or for treating specific values as `NULL` in calculations or comparisons. `NULLIF` takes two arguments and is often used in combination with aggregate functions or in `CASE` statements to handle special cases in data processing or reporting.\n\nLearn more from the following resources:",
"links": [
{
"title": "NULLIF",
"url": "https://www.w3schools.com/sql/func_sqlserver_nullif.asp",
"type": "article"
},
{
"title": "What is NULLIF in SQL?",
"url": "https://www.youtube.com/watch?v=Jaw53T__RRY",
@@ -1097,11 +935,6 @@
"title": "DATE",
"description": "The DATE data type in SQL is used to store calendar dates (typically in the format YYYY-MM-DD). It represents a specific day without any time information. DATE columns are commonly used for storing birthdates, event dates, or any other data that requires only day-level precision. SQL provides various functions to manipulate and format DATE values, allowing for date arithmetic, extraction of date components, and comparison between dates. The exact range of valid dates may vary depending on the specific database management system being used.\n\nLearn more from the following resources:",
"links": [
{
"title": "SQL DATE",
"url": "https://www.w3schools.com/sql/sql_dates.asp",
"type": "article"
},
{
"title": "Working with Dates",
"url": "https://www.youtube.com/watch?v=XyZ9HwXoR7o",
@@ -1118,11 +951,6 @@
"title": "TIMESTAMP",
"description": "SQL `TIMESTAMP` is a data type that allows you to store both date and time. It is typically used to track updates and changes made to a record, providing a chronological time of happenings.\n\nDepending on the SQL platform, the format and storage size can slightly vary. For instance, MySQL uses the 'YYYY-MM-DD HH:MI:SS' format and in PostgreSQL, it's stored as a 'YYYY-MM-DD HH:MI:SS' format but it additionally can store microseconds.\n\nLearn more from the following resources:",
"links": [
{
"title": "MYSQL TIMESTAMP function",
"url": "https://www.w3schools.com/mysql/func_mysql_timestamp.asp",
"type": "article"
},
{
"title": "Different SQL TimeStamp functions in SQL Server",
"url": "https://www.sqlshack.com/different-sql-timestamp-functions-in-sql-server/",
@@ -1134,11 +962,6 @@
"title": "DATEPART",
"description": "`DATEPART` is a useful function in SQL that allows you to extract a specific part of a date or time field. You can use it to get the year, quarter, month, day of the year, day, week, weekday, hour, minute, second, or millisecond from any date or time expression.\n\nLearn more from the following resources:",
"links": [
{
"title": "DATEPART",
"url": "https://www.w3schools.com/sql/func_sqlserver_datepart.asp",
"type": "article"
},
{
"title": "SQL DATEPART",
"url": "https://hightouch.com/sql-dictionary/sql-datepart",
@@ -1230,11 +1053,6 @@
"title": "Indexes",
"description": "Indexes in SQL are database objects that improve the speed of data retrieval operations on database tables. They work similarly to book indexes, providing a quick lookup mechanism for finding rows with specific column values. Indexes create a separate data structure that allows the database engine to locate data without scanning the entire table. While they speed up `SELECT` queries, indexes can slow down `INSERT`, `UPDATE`, and `DELETE` operations because the index structure must be updated. Proper index design is crucial for optimizing database performance, especially for large tables or frequently queried columns.\n\nLearn more from the following resources:",
"links": [
{
"title": "Create SQL Index Statement",
"url": "https://www.w3schools.com/sql/sql_create_index.asp",
"type": "article"
},
{
"title": "SQL Indexing Best Practices",
"url": "https://www.youtube.com/watch?v=BIlFTFrEFOI",

10
public/roadmap-content/vue.json
View File

@@ -383,11 +383,6 @@
"title": "v-on Documentation",
"url": "https://vuejs.org/api/built-in-directives.html#v-on",
"type": "article"
},
{
"title": "v-on Directive",
"url": "https://www.w3schools.com/vue/ref_v-on.php",
"type": "article"
}
]
},
@@ -1258,11 +1253,6 @@
"url": "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch",
"type": "article"
},
{
"title": "Fetch W3school Docs",
"url": "https://www.w3schools.com/jsref/api_fetch.asp",
"type": "article"
},
{
"title": "Network Request - Fetch",
"url": "https://javascript.info/fetch",