From a290cafa352b1de68067d74f7e583fc321cc10d1 Mon Sep 17 00:00:00 2001 From: "github-actions[bot]" <41898282+github-actions[bot]@users.noreply.github.com> Date: Tue, 24 Jun 2025 15:49:43 +0600 Subject: [PATCH] chore: update roadmap content json (#8823) Co-authored-by: kamranahmedse <4921183+kamranahmedse@users.noreply.github.com> --- public/roadmap-content/ai-agents.json | 5 + public/roadmap-content/cpp.json | 2 +- public/roadmap-content/cyber-security.json | 7 +- public/roadmap-content/data-analyst.json | 17 +- .../datastructures-and-algorithms.json | 30 +- public/roadmap-content/graphql.json | 845 +++++++++ public/roadmap-content/linux.json | 12 +- public/roadmap-content/nodejs.json | 2 +- public/roadmap-content/react-native.json | 1272 +++++++++++++ public/roadmap-content/rust.json | 1586 ++++++++++++++--- .../software-design-architecture.json | 12 +- 11 files changed, 3558 insertions(+), 232 deletions(-) create mode 100644 public/roadmap-content/graphql.json create mode 100644 public/roadmap-content/react-native.json diff --git a/public/roadmap-content/ai-agents.json b/public/roadmap-content/ai-agents.json index a6712faa4..319a22ea7 100644 --- a/public/roadmap-content/ai-agents.json +++ b/public/roadmap-content/ai-agents.json @@ -1134,6 +1134,11 @@ "title": "Model Context Protocol (MCP)", "description": "Model Context Protocol (MCP) is a rulebook that tells an AI agent how to pack background information before it sends a prompt to a language model. It lists what pieces go into the prompt—things like the system role, the user’s request, past memory, tool calls, or code snippets—and fixes their order. Clear tags mark each piece, so both humans and machines can see where one part ends and the next begins. Keeping the format steady cuts confusion, lets different tools work together, and makes it easier to test or swap models later. When agents follow MCP, the model gets a clean, complete prompt and can give better answers.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "MCP: Build Rich-Context AI Apps with Anthropic", + "url": "https://www.deeplearning.ai/short-courses/mcp-build-rich-context-ai-apps-with-anthropic/", + "type": "course" + }, { "title": "Model Context Protocol", "url": "https://github.com/modelcontextprotocol/modelcontextprotocol", diff --git a/public/roadmap-content/cpp.json b/public/roadmap-content/cpp.json index 39a89c0d3..1cdb975aa 100644 --- a/public/roadmap-content/cpp.json +++ b/public/roadmap-content/cpp.json @@ -273,7 +273,7 @@ }, "uUzRKa9wGzdUwwmAg3FWr": { "title": "References", - "description": "A reference can be considered as a constant pointer (not to be confused with a pointer to a constant value) which always points to (references) the same object. They are declared using the `&` (ampersand) symbol.\n\nDeclaration and Initialization\n------------------------------\n\nTo declare a reference, use the `&` symbol followed by the variable type and the reference's name. Note that you must initialize a reference when you declare it.\n\n int var = 10; // Declare an integer variable\n int& ref = var; // Declare a reference that \"points to\" var\n \n\nUsage\n-----\n\nYou can use the reference just like you'd use the original variable. When you change the value of the reference, the value of the original variable also changes, because they both share the same memory location.\n\n var = 20; // Sets the value of var to 20\n std::cout << ref << '\\n'; // Outputs 20\n \n ref = 30; // Sets the value of ref to 30\n std::cout << var << '\\n'; // Outputs 30\n \n\nFunction Parameters\n-------------------\n\nYou can use references as function parameters to create an alias for an argument. This is commonly done when you need to modify the original variable or when passing an object of considerable size to avoid the cost of copying.\n\n void swap(int& a, int& b) {\n int temp = a;\n a = b;\n b = temp;\n }\n \n int main() {\n int x = 5, y = 10;\n std::cout << \"Before Swap: x = \" << x << \" y = \" << y << '\\n'; // Outputs 5 10\n \n swap(x, y);\n std::cout << \"After Swap: x = \" << x << \" y = \" << y << '\\n'; // Outputs 10 5\n }", + "description": "A reference can be considered as a constant pointer (not to be confused with a pointer to a constant value) which always points to (references) the same object. They are declared using the `&` (ampersand) symbol.\n\nDeclaration and Initialization\n------------------------------\n\nTo declare a reference, use the variable type followed by the `&` symbol and the reference's name. Note that you must initialize a reference when you declare it.\n\n int var = 10; // Declare an integer variable\n int& ref = var; // Declare a reference that \"points to\" var\n \n\nUsage\n-----\n\nYou can use the reference just like you'd use the original variable. When you change the value of the reference, the value of the original variable also changes, because they both share the same memory location.\n\n var = 20; // Sets the value of var to 20\n std::cout << ref << '\\n'; // Outputs 20\n \n ref = 30; // Sets the value of ref to 30\n std::cout << var << '\\n'; // Outputs 30\n \n\nFunction Parameters\n-------------------\n\nYou can use references as function parameters to create an alias for an argument. This is commonly done when you need to modify the original variable or when passing an object of considerable size to avoid the cost of copying.\n\n void swap(int& a, int& b) {\n int temp = a;\n a = b;\n b = temp;\n }\n \n int main() {\n int x = 5, y = 10;\n std::cout << \"Before Swap: x = \" << x << \" y = \" << y << '\\n'; // Outputs 5 10\n \n swap(x, y);\n std::cout << \"After Swap: x = \" << x << \" y = \" << y << '\\n'; // Outputs 10 5\n }", "links": [] }, "mSFwsTYvmg-GwG4_DEIEf": { diff --git a/public/roadmap-content/cyber-security.json b/public/roadmap-content/cyber-security.json index 7595bb3fa..632c940a3 100644 --- a/public/roadmap-content/cyber-security.json +++ b/public/roadmap-content/cyber-security.json @@ -54,6 +54,11 @@ "title": "How bluetooth works", "url": "https://electronics.howstuffworks.com/bluetooth.htm", "type": "article" + }, + { + "title": "video@How bluetooth works", + "url": "https://www.youtube.com/watch?v=1I1vxu5qIUM", + "type": "article" } ] }, @@ -5169,7 +5174,7 @@ }, "Rnpx7VkhrBkSQTni6UuTR": { "title": "WADCOMS", - "description": "WADcoms (Web Application Dangerous Commands) is a comprehensive database of dangerous web application commands and patterns that can be exploited to compromise web security. It offers a catalog of potentially harmful commands and their contexts, helping security professionals identify and mitigate risks associated with web applications by understanding how these commands can be misused for attacks like SQL injection, cross-site scripting (XSS), and remote code execution (RCE).\n\nLearn more from the following resources:", + "description": "WADcoms (Windows/Active Directory Commands) is an interactive cheat sheet, containing a curated list of offensive security tools and their respective commands, to be used against Windows/AD environments. Just select what information you currently have related to the Windows machine (passwords, usernames, services, etc.), and it will display a list of tools you can try against the machine, along with a template command for easy copy/pasting\n\nLearn more from the following resources:", "links": [ { "title": "WADComs/WADComs.github.io", diff --git a/public/roadmap-content/data-analyst.json b/public/roadmap-content/data-analyst.json index 38cf20ee6..892617242 100644 --- a/public/roadmap-content/data-analyst.json +++ b/public/roadmap-content/data-analyst.json @@ -201,10 +201,21 @@ } ] }, - "analysis--reporting-with-excel@sgXIjVTbwdwdYoaxN3XBM.md": { + "sgXIjVTbwdwdYoaxN3XBM": { "title": "Analysis / Reporting with Excel", - "description": "", - "links": [] + "description": "Excel is a powerful tool utilized by data analysts worldwide to store, manipulate, and analyze data. It offers a vast array of features such as pivot tables, graphs and a powerful suite of formulas and functions to help sift through large sets of data. A data analyst uses Excel to perform a wide range of tasks, from simple data entry and cleaning, to more complex statistical analysis and predictive modeling. Proficiency in Excel is often a key requirement for a data analyst, as its versatility and ubiquity make it an indispensable tool in the field of data analysis.\n\nLearn more from the following resources:", + "links": [ + { + "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" + } + ] }, "wME4MSldOWlMB54ekpReS": { "title": "IF", diff --git a/public/roadmap-content/datastructures-and-algorithms.json b/public/roadmap-content/datastructures-and-algorithms.json index 7d98b910c..990db7af4 100644 --- a/public/roadmap-content/datastructures-and-algorithms.json +++ b/public/roadmap-content/datastructures-and-algorithms.json @@ -907,8 +907,14 @@ }, "NrPO7vF8Z1WzmA9Ca3Y_E": { "title": "Depth First Search", - "description": "**Depth-First Search (DFS)** is an algorithm used for traversing or searching tree or graph data structures. The process starts at the root node (selecting some arbitrary node as the root in the case of a graph), and explores as far as possible along each branch before backtracking. It uses a last in, first out (LIFO) stack to remember to get the next vertex to start a search when a dead end occurs in any iteration. DFS has been used in a variety of applications including finding connected components, topological sorting, and finding articulation points (or cut vertices) in a graph.", - "links": [] + "description": "**Depth-First Search (DFS)** is an algorithm used for traversing or searching tree or graph data structures. The process starts at the root node (selecting some arbitrary node as the root in the case of a graph), and explores as far as possible along each branch before backtracking. It uses a last in, first out (LIFO) stack to remember to get the next vertex to start a search when a dead end occurs in any iteration. DFS has been used in a variety of applications including finding connected components, topological sorting, and finding articulation points (or cut vertices) in a graph.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Learn Depth First Search in 7 minutes", + "url": "https://youtu.be/by93qH4ACxo?si=FXcUfuwB5atV5SIY", + "type": "video" + } + ] }, "N-qvYirxpORcaTslvlOL0": { "title": "Shortest Path Algorithms", @@ -1214,8 +1220,24 @@ }, "R3Coq0TG1_cSOXzXWgpuI": { "title": "Heap", - "description": "", - "links": [] + "description": "A heap is a type of data structure in computer science that is like a tree, where each parent node is always bigger (in a max heap) or smaller (in a min heap) than its child nodes.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Heap Data Structure", + "url": "https://www.programiz.com/dsa/heap-data-structure", + "type": "article" + }, + { + "title": "Heap Data Structure", + "url": "https://www.youtube.com/watch?v=t0Cq6tVNRBA", + "type": "video" + }, + { + "title": "Heaps and Priority Queues", + "url": "https://www.youtube.com/watch?v=B7hVxCmfPtM", + "type": "video" + } + ] }, "AabJqPUwFVBVS02YPDPvL": { "title": "A* Algorithm", diff --git a/public/roadmap-content/graphql.json b/public/roadmap-content/graphql.json new file mode 100644 index 000000000..d1d69d179 --- /dev/null +++ b/public/roadmap-content/graphql.json @@ -0,0 +1,845 @@ +{ + "JfXwzkN29UGz17FYHHE3A": { + "title": "Introduction", + "description": "GraphQL is a query language and runtime for APIs that enables clients to request exactly the data they need in a single call. It provides a predictable format, reducing multiple API calls and eliminating over-fetching, making data retrieval more efficient than traditional REST APIs.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Introduction to GraphQL", + "url": "https://graphql.org/learn/", + "type": "article" + }, + { + "title": "Getting started with GraphQL", + "url": "https://graphql.org/", + "type": "article" + }, + { + "title": "Explore top posts about GraphQL", + "url": "https://app.daily.dev/tags/graphql?ref=roadmapsh", + "type": "article" + } + ] + }, + "cMfsRtvzvDZZJ0TqeUOxm": { + "title": "What is GraphQL", + "description": "GraphQL is a query language for APIs and server-side runtime that lets clients request exactly the data they need. Unlike REST, it uses a type system to define data structure and allows fetching multiple resources in a single request, reducing over-fetching and under-fetching problems.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Introduction to graphQL", + "url": "https://graphql.org/learn/", + "type": "article" + }, + { + "title": "Tutorial - What is graphQL?", + "url": "https://www.howtographql.com/basics/0-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about GraphQL", + "url": "https://app.daily.dev/tags/graphql?ref=roadmapsh", + "type": "article" + } + ] + }, + "2rlmLn_yQQV-7DpX1qT98": { + "title": "Problems GraphQL Solves", + "description": "GraphQL solves major API problems including over-fetching (getting unnecessary data), under-fetching (multiple requests needed), inefficient versioning, and lack of flexibility. It enables precise data requests, single queries for multiple resources, seamless versioning through schema evolution, and microservice communication through federation.", + "links": [] + }, + "J5mU0v491qrm-mr1W3Msd": { + "title": "Thinking in Graphs", + "description": "\"Thinking in Graphs\" is a GraphQL mindset where data is organized as a graph with nodes (objects) and edges (relationships). This approach allows flexible and intuitive querying by following relationships between connected data points, making complex data retrieval more natural and efficient.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL - Thinking in Graphs", + "url": "https://graphql.org/learn/thinking-in-graphs/", + "type": "article" + } + ] + }, + "W_Lg8086ZhrIqtck1sgnb": { + "title": "GraphQL Queries", + "description": "GraphQL queries are client requests to retrieve specific data from a server. They specify exactly which fields should be returned, using a hierarchical structure that matches the data requirements. Queries are written in GraphQL syntax and executed by the server to fetch the requested data.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "What are GraphQL Queries?", + "url": "https://graphql.org/learn/queries/", + "type": "article" + }, + { + "title": "Explore top posts about GraphQL", + "url": "https://app.daily.dev/tags/graphql?ref=roadmapsh", + "type": "article" + } + ] + }, + "6r9XbwlBtHmJrhviG2cTD": { + "title": "GraphQL on Frontend", + "description": "GraphQL on the frontend enables efficient data fetching with clients like Apollo, URQL, or Relay. It provides declarative data requirements, intelligent caching, real-time subscriptions, and type safety, allowing frontend applications to request exactly the data they need in a single query.\n\nLearn more from following links:", + "links": [ + { + "title": "Get started with GraphQL on the frontend", + "url": "https://www.howtographql.com/react-apollo/0-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about Frontend Development", + "url": "https://app.daily.dev/tags/frontend?ref=roadmapsh", + "type": "article" + } + ] + }, + "ODQ8zrHc2rsc8PN-APKvz": { + "title": "GraphQL on Backend", + "description": "GraphQL on the backend involves implementing servers that execute GraphQL queries, mutations, and subscriptions. It includes defining schemas, writing resolvers, handling data sources, implementing authentication/authorization, and optimizing performance through caching and batching strategies.\n\nLearn more from the following links:", + "links": [ + { + "title": "How to use GraphQL in Backend?", + "url": "https://www.howtographql.com/", + "type": "article" + }, + { + "title": "Explore top posts about Backend Development", + "url": "https://app.daily.dev/tags/backend?ref=roadmapsh", + "type": "article" + } + ] + }, + "2SU4dcaz7zwGsF7g8FjmI": { + "title": "What are Queries?", + "description": "In GraphQL, queries are client requests to retrieve data from the server. They're structured as hierarchical trees of fields that correspond to the properties of the requested data, allowing clients to specify exactly what data they need in a predictable format.\n\nLearn more from following links:", + "links": [ + { + "title": "Introduction of GraphQL - Query", + "url": "https://graphql.org/learn/queries/", + "type": "article" + } + ] + }, + "Pc9H7AcoqJQkWnuhbytyD": { + "title": "Fields", + "description": "Fields in GraphQL are individual pieces of data that can be queried or modified, representing properties of the requested data. They're defined in the GraphQL schema and serve as building blocks for queries and mutations, specifying what data is available for each type.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL: Types and Fields", + "url": "https://graphql.org/learn/queries/#fields", + "type": "article" + } + ] + }, + "B77yLU4SuRChSjEbmYwc-": { + "title": "Aliases", + "description": "Aliases in GraphQL rename fields in query responses, useful when requesting the same field multiple times with different arguments or when field names aren't suitable for client usage. They distinguish fields in responses and improve query readability and usability.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "What are GraphQL Aliases?", + "url": "https://graphql.org/learn/queries/#aliases", + "type": "article" + } + ] + }, + "hrpb108R8Gyu3hhzkMYzL": { + "title": "Arguments", + "description": "Arguments in GraphQL are values passed to fields or directives to specify execution details like filtering, sorting, pagination, or configuration options. They're passed as key-value pairs, can be defined as variables, and may be optional or required depending on the field definition.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL - Arguments", + "url": "https://graphql.org/learn/queries/#arguments", + "type": "article" + } + ] + }, + "MnmwccPahqPCzOhqjfbsY": { + "title": "Directives", + "description": "Directives in GraphQL modify query execution by adding behavior or validation to fields, operations, and fragments. They can take arguments to configure behavior and include built-in directives like @include and @skip, or custom ones defined by developers for specific functionality.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Directives in GraphQL", + "url": "https://graphql.org/learn/queries/#directives", + "type": "article" + } + ] + }, + "YZaFEK547FYricfOuANvH": { + "title": "Variables", + "description": "Variables in GraphQL pass dynamic values to queries and mutations, making them flexible and reusable. Defined with the $ symbol and a type, their values are passed in a separate JSON object. Variables are type-safe, ensuring values match the defined types.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "GraphQL Variables", + "url": "https://dgraph.io/docs/graphql/api/variables/", + "type": "article" + }, + { + "title": "Intro to Variables in GraphQL", + "url": "https://graphql.org/learn/queries/#variables", + "type": "article" + } + ] + }, + "CehwjrCG_wbUU-TFNCuJn": { + "title": "Fragments", + "description": "Fragments in GraphQL are reusable pieces of queries that retrieve specific fields from one or more types. Defined with the \"fragment\" keyword, they promote code reuse, reduce duplication, and make complex queries more maintainable by separating common field selections.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Intro to Fragments in GraphQL", + "url": "https://graphql.org/learn/queries/#fragments", + "type": "article" + } + ] + }, + "jy_91mhFWbpR6sYVbuX1x": { + "title": "Mutations", + "description": "Mutations in GraphQL are used to modify data on the server, including creating, updating, or deleting records. They're structured like queries but use the \"mutation\" field at the top level and include fields specifying the data to be changed and the operation type.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Getting started with Mutations", + "url": "https://graphql.org/learn/queries/#mutations", + "type": "article" + } + ] + }, + "9Q2pGidY-rfkltHq3vChp": { + "title": "What are Mutations?", + "description": "Mutations in GraphQL are operations used to modify data on the server - creating, updating, or deleting records. They're structured like queries but use the \"mutation\" field at the top level and include fields specifying the data to be changed and the operation type.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Get started with Mutations", + "url": "https://graphql.org/learn/mutations/", + "type": "article" + } + ] + }, + "AySlY8AyI6jE-cy-qKKOU": { + "title": "Multiple Fields in Mutation", + "description": "GraphQL allows multiple mutations in a single query by including multiple mutation fields, called batching or chaining mutations. This enables performing several data modifications atomically, improving efficiency and ensuring consistent state changes across related operations.\n\nLearn more from the following links:", + "links": [ + { + "title": "Guide to Multiple fields in mutations", + "url": "https://graphql.org/learn/queries/#multiple-fields-in-mutations", + "type": "article" + } + ] + }, + "q9TYEygvUyHourdZIvk8G": { + "title": "Operation Name", + "description": "Operation names are optional identifiers for GraphQL queries and mutations that help uniquely identify operations in documents with multiple operations. They provide meaningful names for operations, improve debugging, and make error identification easier in complex applications.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Intro to Operation Name", + "url": "https://graphql.org/learn/queries/#operation-name", + "type": "article" + } + ] + }, + "IbEqXlGjsyNLKE9dZrPPk": { + "title": "Subscriptions", + "description": "Subscriptions in GraphQL enable real-time updates by allowing clients to subscribe to specific events or data changes on the server. The server maintains an open connection and pushes updates to subscribed clients as soon as events occur or data changes.\n\nLearn more from following links:", + "links": [ + { + "title": "Subscriptions and Live Queries - Real Time with GraphQL", + "url": "https://the-guild.dev/blog/subscriptions-and-live-queries-real-time-with-graphql", + "type": "article" + } + ] + }, + "RlBc-hWEUOPaEQLTgJa-K": { + "title": "What are Subscriptions", + "description": "Subscriptions in GraphQL enable real-time updates by allowing clients to subscribe to specific events or data changes on the server. They're structured like queries with a \"subscription\" field at the top level and push updates to clients as soon as events occur.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "How GraphQL Subscriptions Work?", + "url": "https://the-guild.dev/blog/subscriptions-and-live-queries-real-time-with-graphql", + "type": "article" + } + ] + }, + "kJMyRhasBKfBypent3GxK": { + "title": "Event Based Subscriptions", + "description": "Event-based subscriptions in GraphQL provide real-time updates by subscribing to specific events or data changes. Clients maintain persistent connections through WebSockets to receive live updates when subscribed events occur, enabling reactive applications with real-time functionality.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Subscriptions", + "url": "https://the-guild.dev/blog/subscriptions-and-live-queries-real-time-with-graphql", + "type": "article" + }, + { + "title": "GraphQL Subscriptions Documentation", + "url": "https://graphql.org/blog/subscriptions-in-graphql-and-relay/", + "type": "article" + } + ] + }, + "CHdzww8_TNfeM6Bp1oTPI": { + "title": "Live Queries", + "description": "Live Queries automatically update query results when underlying data changes, providing real-time synchronization without manual subscription management. This advanced feature simplifies building reactive applications by maintaining fresh data automatically, though it requires specialized GraphQL implementations.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Live Queries", + "url": "https://the-guild.dev/blog/collecting-graphql-live-query-resource-identifier-with-graphql-tools", + "type": "article" + } + ] + }, + "t6XxFB_lx27kS4FE2_GMH": { + "title": "@defer / @stream directives", + "description": "Defer and Stream directives are experimental GraphQL features for incremental data delivery. @defer postpones non-critical fields to improve initial response times, while @stream sends list items progressively, enabling better user experiences with large datasets and slow-loading fields.\n\nLearn more from the following links:", + "links": [ + { + "title": "Defer and Stream in GraphQL", + "url": "https://the-guild.dev/graphql/yoga-server/docs/features/defer-stream", + "type": "article" + } + ] + }, + "lj1WEh4WbfBsoZFYsi1Yz": { + "title": "Schema", + "description": "A GraphQL schema defines the structure and capabilities of a GraphQL API using Schema Definition Language (SDL). It specifies types, fields, arguments, relationships, and root operations (Query, Mutation, Subscription) that serve as entry points, acting as a contract between client and server.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "What is Schema?", + "url": "https://graphql.org/learn/schema/", + "type": "article" + } + ] + }, + "jpu0_FAlxtD-H80mPcod5": { + "title": "Type System", + "description": "GraphQL is strongly typed with a type system that defines data types available in applications. It includes Scalar, Object, Query, Mutation, and Enum types. The type system defines the schema, acting as a contract between client and server for predictable API interactions.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Type system", + "url": "https://graphql.org/learn/schema/#type-system", + "type": "article" + } + ] + }, + "HPdntdgTar1T34CZX8Y6y": { + "title": "Fields", + "description": "Fields in GraphQL are units of data that can be queried or manipulated. Each field has a name, type, and optional description, and can return scalar values or objects, enabling complex nested data structures and taking arguments for filtering.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL: Types and Fields", + "url": "https://graphql.org/learn/queries/#fields", + "type": "article" + } + ] + }, + "U-tLelmNQtR-pUq-sxU_2": { + "title": "Scalars", + "description": "Scalars are \"leaf\" values in GraphQL representing primitive data types. Built-in scalars include String, Int, Float, Boolean, and ID for unique identifiers. Custom scalars can be defined for specific needs like dates, JSON, or large integers, extending the type system beyond basic primitives.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Scalars in GraphQL", + "url": "https://graphql.org/learn/schema/#scalar-types", + "type": "article" + } + ] + }, + "wfOsfb0zSAIdNkwFHfBcw": { + "title": "Enums", + "description": "Enums (enumeration types) are special scalars restricted to a particular set of allowed values. They validate arguments against allowed values and communicate through the type system that fields will always be one of a finite set of predefined options.\n\nLearn more from the following links:", + "links": [ + { + "title": "What are Enums?", + "url": "https://graphql.org/learn/schema/#enumeration-types", + "type": "article" + } + ] + }, + "tc_rjJZrr2x3bp8mcoQ0F": { + "title": "Interfaces", + "description": "Interfaces in GraphQL define a set of fields that implementing types must include. They enable polymorphism by allowing common field querying across different types that implement the same interface, promoting code reuse and consistent API design.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Interfaces", + "url": "https://graphql.org/learn/schema/#interfaces", + "type": "article" + } + ] + }, + "d2ikbo4sZq7PmaCi5znkd": { + "title": "Lists", + "description": "Lists in GraphQL represent ordered collections of items, defined using square brackets around the item type. They can contain scalars, objects, or other lists, enabling complex nested data structures and array-based field returns in schemas.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Lists", + "url": "https://graphql.org/learn/schema/#lists-and-non-null", + "type": "article" + } + ] + }, + "LX9vZpx7yKlf0iR6AtBWz": { + "title": "Objects", + "description": "Objects in GraphQL are types that represent groups of fields, defining the structure of queries and mutations. Each field can return scalar values or other objects, enabling complex nested data structures. Objects are defined using the \"type\" keyword followed by the name and field definitions.\n\nTo learn more, visit the following:", + "links": [ + { + "title": "Object Types and Fields", + "url": "https://graphql.org/learn/schema/#object-types-and-fields", + "type": "article" + }, + { + "title": "Object Types", + "url": "https://graphql.org/graphql-js/object-types/", + "type": "article" + } + ] + }, + "59COH3rerJJzKr6vrj4bF": { + "title": "Unions", + "description": "Unions allow fields to return multiple types, enabling different handling for various types in clients. They provide schema flexibility by grouping types together, though they don't allow common field querying across types like interfaces do.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Union in GraphQL", + "url": "https://graphql.org/learn/schema/#union-types", + "type": "article" + } + ] + }, + "A54vi3Ao7fBHyTuqoH_it": { + "title": "Arguments", + "description": "Arguments in GraphQL are values passed to fields in queries and mutations to filter or modify returned data. They're defined in the schema with a name, type, and optional default value, enabling dynamic data retrieval.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Get started with Arguments in GraphQL", + "url": "https://graphql.org/learn/schema/#arguments", + "type": "article" + } + ] + }, + "iYkHCKTsjtvo40f3eZoet": { + "title": "Validation", + "description": "Validation in GraphQL ensures queries and mutations conform to schema rules and constraints. It checks for required fields, correct argument types, and value ranges before execution, preventing invalid operations and improving API reliability.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Validation in GraphQL", + "url": "https://graphql.org/learn/validation/", + "type": "article" + } + ] + }, + "72wGg6yP8WnEdmkeKL9vh": { + "title": "Execution", + "description": "Execution in GraphQL is the process of running queries or mutations and returning results to clients. The GraphQL engine performs parsing, validation, and data retrieval steps to produce the final response, coordinating resolver functions to fetch data from various sources.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Execution in GraphQL", + "url": "https://graphql.org/learn/execution/", + "type": "article" + }, + { + "title": "Intro to Execution", + "url": "https://graphql.org/graphql-js/execution/", + "type": "article" + } + ] + }, + "AlJlHZD3_SPoLNaqdM-pB": { + "title": "Root Fields", + "description": "Root fields are the top-level fields available to clients in GraphQL queries and mutations. They serve as entry points for client requests, with Query fields for retrieving data and Mutation fields for modifying data on the server.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Root Feilds", + "url": "https://graphql.org/learn/execution/#root-fields-resolvers", + "type": "article" + } + ] + }, + "VDur5xYBC0LJtQgDrSEyj": { + "title": "Resolvers", + "description": "Resolvers are functions responsible for fetching data for each field in GraphQL queries and mutations. Defined in the schema and executed by the GraphQL server, they retrieve data from databases, APIs, or other sources and return it to clients.\n\nLearn more from the following links:", + "links": [ + { + "title": "Guide to Resolver", + "url": "https://the-guild.dev/blog/better-type-safety-for-resolvers-with-graphql-codegen", + "type": "article" + } + ] + }, + "uPpsj2kCdgKsJpmTaw86u": { + "title": "Synchronous", + "description": "Synchronous resolvers in GraphQL execute immediately and return their results directly without waiting for external operations. They complete their execution before returning any value, making them simpler but potentially blocking if they perform complex computations.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Execution", + "url": "https://graphql.org/learn/execution/", + "type": "article" + }, + { + "title": "Understanding Resolvers", + "url": "https://www.apollographql.com/docs/apollo-server/data/resolvers/", + "type": "article" + } + ] + }, + "tbDvQBtLRAcD-xYX9V7Va": { + "title": "Asynchronous", + "description": "Asynchronous resolvers in GraphQL are functions that return promises instead of immediate values. They allow resolvers to wait for external operations like database queries or API calls to complete before returning results, enabling non-blocking execution.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Asynchronous", + "url": "https://graphql.org/learn/execution/#asynchronous-resolvers", + "type": "article" + } + ] + }, + "QFUOmJlPkkjpcl1vJxg9h": { + "title": "Scalar Coercion", + "description": "Scalar coercion in GraphQL converts input values from one type to another when they don't match the expected type but can be successfully converted. This process is implemented using custom scalar types with coerce functions that handle the type conversion.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Scalar coercion", + "url": "https://graphql.org/learn/execution/#scalar-coercion", + "type": "article" + } + ] + }, + "sJ1_c3e08aehiqNMbIEEP": { + "title": "Lists", + "description": "Lists in GraphQL represent ordered collections of items and can be used as return types for fields. They can contain any type of items including scalars and objects, with resolver functions typically returning data as arrays from databases or APIs.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Lists and Non-Null", + "url": "https://graphql.org/learn/schema/#lists-and-non-null", + "type": "article" + } + ] + }, + "I4wNBXV4xEZ0LWBhv5FwF": { + "title": "Validation", + "description": "Validation in GraphQL ensures queries and mutations adhere to schema rules by verifying field access, type correctness, and input constraints. GraphQL servers validate all incoming operations before execution, returning errors for invalid queries with specific details about violations.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Validation in GraphQL", + "url": "https://graphql.org/learn/validation/", + "type": "article" + } + ] + }, + "zQHifboRreE4OgJ7GnUlp": { + "title": "Producing the Result", + "description": "Producing the result in GraphQL involves generating the final response to queries and mutations. This process includes parsing the request, validating against the schema, executing resolvers to fetch data, and formatting the response according to the query requirements.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with GraphQL", + "url": "https://graphql.org/learn/", + "type": "article" + } + ] + }, + "inhjhH-7xJyX8o4DQqErF": { + "title": "Serving over Internet", + "description": "Serving GraphQL over the internet involves making a GraphQL server accessible to clients through a public IP address or domain name. This can be done using reverse proxies, cloud services, or serverless functions to expose the GraphQL endpoint publicly.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Introduction to Serving over HTTPs", + "url": "https://graphql.org/learn/serving-over-http/", + "type": "article" + } + ] + }, + "V3bgswBFr1xames3F8S_V": { + "title": "GraphQL Over HTTP Spec", + "description": "The GraphQL over HTTP specification defines standard practices for serving GraphQL over HTTP, including request/response formats, status codes, and content types. It ensures interoperability between different GraphQL implementations and provides guidance for consistent API behavior across platforms.", + "links": [] + }, + "UYwuUVTeurwODV4_Kdt_W": { + "title": "Caching", + "description": "Caching in GraphQL improves performance by storing query results for reuse. Strategies include HTTP caching, response caching, dataloader for batching requests, and normalized caching at the client level to reduce redundant API calls and improve user experience.\n\nThere are several types of caching that can be used in GraphQL:\n\n* Client-side caching\n* Server-side caching\n* CDN caching\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Caching", + "url": "https://graphql.org/learn/caching/", + "type": "article" + } + ] + }, + "v9gVexHfDkpG9z3NL5S-9": { + "title": "Batching", + "description": "Batching in GraphQL combines multiple queries into a single request to reduce network overhead and improve performance. DataLoader is a common pattern that batches and caches database requests, preventing N+1 query problems and optimizing data fetching efficiency.\n\nLearn more from the following links:", + "links": [ + { + "title": "DataLoader", + "url": "https://github.com/graphql/dataloader", + "type": "opensource" + }, + { + "title": "Solving the N+1 Problem", + "url": "https://shopify.engineering/solving-the-n-1-problem-for-graphql-through-batching", + "type": "article" + } + ] + }, + "i-zcfN6RNXhA_sb7DcIon": { + "title": "Authorization", + "description": "Authorization in GraphQL refers to the process of controlling access to specific fields, types, or operations in a GraphQL schema based on user roles or permissions. It allows you to restrict access to certain data or functionality in your application based on the user's role or permissions.\n\nThere are several ways to implement authorization in GraphQL:\n\n* Using middleware\n* Using schema directives\n* Using a data source layer\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Get Started with Authorization", + "url": "https://graphql.org/learn/authorization/", + "type": "article" + }, + { + "title": "Explore top posts about Authorization", + "url": "https://app.daily.dev/tags/authorization?ref=roadmapsh", + "type": "article" + } + ] + }, + "A-PQ3_FVuCK3Eud75hsdj": { + "title": "Specification", + "description": "The GraphQL specification is the official standard that defines the GraphQL query language, type system, execution algorithm, and validation rules. It ensures consistency across different GraphQL implementations and serves as the authoritative reference for developers building GraphQL services and tools.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Specification", + "url": "https://spec.graphql.org/", + "type": "article" + }, + { + "title": "GraphQL Foundation", + "url": "https://foundation.graphql.org/", + "type": "article" + } + ] + }, + "2YLm_S1j_832pb1OGSNaM": { + "title": "Realtime", + "description": "Realtime GraphQL enables live data updates through subscriptions, allowing clients to receive instant notifications when data changes. Implemented using WebSockets, Server-Sent Events, or polling, it's essential for chat applications, live feeds, and collaborative tools requiring immediate data synchronization.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with Real Time with GraphQL", + "url": "https://the-guild.dev/blog/subscriptions-and-live-queries-real-time-with-graphql", + "type": "article" + } + ] + }, + "GzwPvLybxTJM96fUhQUOi": { + "title": "Authorization", + "description": "Authorization in GraphQL refers to the process of controlling access to specific fields, types, or operations in a GraphQL schema based on user roles or permissions. It allows you to restrict access to certain data or functionality in your application based on the user's role or permissions.\n\nThere are several ways to implement authorization in GraphQL:\n\n* Using middleware\n* Using schema directives\n* Using a data source layer\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Get Started with Authorization", + "url": "https://graphql.org/learn/authorization/", + "type": "article" + }, + { + "title": "Explore top posts about Authorization", + "url": "https://app.daily.dev/tags/authorization?ref=roadmapsh", + "type": "article" + } + ] + }, + "O8k-m6s9B_uXkLsXKVFnL": { + "title": "Specification", + "description": "The GraphQL specification defines the core language, type system, execution model, and validation rules for GraphQL. Maintained by the GraphQL Foundation, it provides the technical foundation that all GraphQL implementations must follow to ensure interoperability and consistency across platforms.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Specification", + "url": "https://spec.graphql.org/", + "type": "article" + }, + { + "title": "GraphQL Foundation", + "url": "https://foundation.graphql.org/", + "type": "article" + } + ] + }, + "G50ZMlmP7Ru5LcFne5Rhu": { + "title": "Authorization", + "description": "Authorization in GraphQL controls access to data and operations based on user permissions and roles. It can be implemented at the schema level, field level, or within resolvers, ensuring users only access data they're permitted to see through various authentication and permission strategies.\n\nThere are several ways to implement authorization in GraphQL:\n\n* Using middleware\n* Using schema directives\n* Using a data source layer\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Get Started with Authorization", + "url": "https://graphql.org/learn/authorization/", + "type": "article" + }, + { + "title": "Explore top posts about Authorization", + "url": "https://app.daily.dev/tags/authorization?ref=roadmapsh", + "type": "article" + } + ] + }, + "Uf8XxJPs7RzKVhlxiQdbB": { + "title": "Pagination", + "description": "Pagination in GraphQL handles large datasets by breaking them into smaller chunks. Common approaches include cursor-based pagination (using cursors for stable pagination) and offset-based pagination (using skip/take), with cursor-based being preferred for performance and consistency.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Get Started with Pagination", + "url": "https://graphql.org/learn/pagination/", + "type": "article" + } + ] + }, + "jCzrMElTo-c9xGcpPOOPl": { + "title": "GraphQL.js", + "description": "GraphQL.js is the reference implementation of GraphQL for JavaScript and Node.js. It provides the core functionality for parsing, validating, and executing GraphQL queries, serving as the foundation for many other GraphQL tools and libraries in the JavaScript ecosystem.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL.js Repository", + "url": "https://github.com/graphql/graphql-js", + "type": "article" + }, + { + "title": "GraphQL.js Documentation", + "url": "https://graphql.org/graphql-js/", + "type": "article" + } + ] + }, + "9nVo95gRNGHGIbaJQPH1x": { + "title": "GraphQL Go", + "description": "GraphQL Go refers to implementing GraphQL servers and clients using the Go programming language. Popular libraries include graphql-go/graphql for schema-first development and 99designs/gqlgen for code-first generation. Go's strong typing and performance make it excellent for building scalable GraphQL APIs.\n\nLearn more from the following links:", + "links": [ + { + "title": "graphql-go/graphql", + "url": "https://github.com/graphql-go/graphql", + "type": "opensource" + }, + { + "title": "99designs/gqlgen", + "url": "https://github.com/99designs/gqlgen", + "type": "opensource" + } + ] + }, + "7szipojhVb2VoL3VcS619": { + "title": "GraphQL Java", + "description": "GraphQL Java is a popular library for implementing GraphQL APIs in Java applications. It provides schema-first development capabilities, runtime query execution, and integrates well with Spring Boot and other Java frameworks, making it a solid choice for enterprise GraphQL implementations.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Java Repository", + "url": "https://github.com/graphql-java/graphql-java", + "type": "article" + }, + { + "title": "GraphQL Java Documentation", + "url": "https://www.graphql-java.com/", + "type": "article" + } + ] + }, + "N-vsu-wvOikuoTbzdgX3X": { + "title": "graphql-http", + "description": "GraphQL over HTTP is a specification that defines how GraphQL queries and mutations should be transported over HTTP. It standardizes request/response formats, HTTP methods, status codes, and headers, ensuring consistent GraphQL API communication across different implementations.\n\nLearn more from the following links:", + "links": [ + { + "title": "graphql-http Library", + "url": "https://github.com/graphql/graphql-http", + "type": "opensource" + }, + { + "title": "GraphQL over HTTP Specification", + "url": "https://graphql.github.io/graphql-over-http/", + "type": "article" + } + ] + }, + "Gotb1xtxySCVC5MrnkPSs": { + "title": "GraphQL Yoga", + "description": "GraphQL Yoga is an open-source GraphQL server library for Node.js built on Express.js. It provides minimal boilerplate setup with built-in authentication, authorization, data validation, and subscription support for real-time updates, making GraphQL server development streamlined.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Armor - for Yoga Server 2", + "url": "https://the-guild.dev/blog/improved-security-with-graphql-armor-support-for-yoga-server-2", + "type": "article" + }, + { + "title": "Explore top posts about GraphQL", + "url": "https://app.daily.dev/tags/graphql?ref=roadmapsh", + "type": "article" + } + ] + }, + "o_VkyoN6DmUUkfl0u0cro": { + "title": "Apollo Server", + "description": "Apollo Server is a popular open-source library for building GraphQL servers in JavaScript. It provides tools for parsing, validating, executing resolvers, and formatting responses with built-in features for authentication, authorization, data validation, and real-time subscriptions.\n\nLearn more from the following links:", + "links": [ + { + "title": "Apollo Tutorial - Introduction", + "url": "https://www.howtographql.com/react-apollo/0-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about Apollo", + "url": "https://app.daily.dev/tags/apollo?ref=roadmapsh", + "type": "article" + } + ] + }, + "iTV2H8clmRTOksul4v38p": { + "title": "mercurius", + "description": "Mercurius is a high-performance GraphQL server library for Fastify, offering excellent performance and minimal memory usage. It provides schema-first development, built-in caching, subscriptions support, and integration with Fastify's ecosystem for building fast, scalable GraphQL APIs.\n\nLearn more from the following links:", + "links": [ + { + "title": "Mercurius Repository", + "url": "https://github.com/mercurius-js/mercurius", + "type": "opensource" + }, + { + "title": "Mercurius Documentation", + "url": "https://mercurius.dev/", + "type": "article" + } + ] + }, + "datKo3vPDwXoyVskcrdkc": { + "title": "graphql-http", + "description": "GraphQL HTTP is a specification for serving GraphQL over HTTP protocol. It defines standard methods for sending queries and mutations, primarily using POST requests with JSON payloads in the request body, and receiving results in the response body.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of GraphQL HTTP", + "url": "https://graphql.org/graphql-js/express-graphql/#graphqlhttp", + "type": "article" + }, + { + "title": "Get Started with GraphQL HTTP", + "url": "https://graphql.org/learn/serving-over-http/", + "type": "article" + }, + { + "title": "Explore top posts about GraphQL", + "url": "https://app.daily.dev/tags/graphql?ref=roadmapsh", + "type": "article" + } + ] + }, + "Ab_ngkf6bmejvcp9okuw6": { + "title": "Relay", + "description": "Relay is Facebook's GraphQL client designed for React applications, emphasizing performance and data consistency. It uses a declarative approach with fragments, automatic query optimization, pagination handling, and strict conventions for building scalable, efficient GraphQL applications.\n\nLearn more from the following links:", + "links": [ + { + "title": "GraphQL Code Generator & Relay Compiler", + "url": "https://the-guild.dev/blog/graphql-codegen-relay-compiler", + "type": "article" + } + ] + }, + "D5O7ky5eXwm_Ys1IcFNaq": { + "title": "Apollo Client", + "description": "Apollo Client is a popular GraphQL client library for JavaScript that provides data fetching, caching, and state management. It offers declarative data fetching with React hooks, intelligent caching, optimistic UI updates, and error handling for building efficient GraphQL-powered applications.\n\nLearn more from the following links:", + "links": [ + { + "title": "Why Apollo Client - Frontend?", + "url": "https://www.howtographql.com/react-apollo/0-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about Apollo", + "url": "https://app.daily.dev/tags/apollo?ref=roadmapsh", + "type": "article" + } + ] + }, + "WP0Oo_YMfLBlXqDQQtKes": { + "title": "Urql", + "description": "URQL is a lightweight, highly customizable GraphQL client for React, Vue, and Svelte. It provides caching, real-time subscriptions, offline support, and a modular architecture with exchanges for extending functionality, offering an alternative to Apollo Client with better performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "urql - Formidable Labs", + "url": "https://formidable.com/open-source/urql/", + "type": "article" + } + ] + } +} \ No newline at end of file diff --git a/public/roadmap-content/linux.json b/public/roadmap-content/linux.json index 17713e63d..c10feef59 100644 --- a/public/roadmap-content/linux.json +++ b/public/roadmap-content/linux.json @@ -974,6 +974,11 @@ "title": "Process Signals", "description": "Process signals are communication mechanisms in Linux that notify processes of synchronous or asynchronous events. Common signals include SIGINT, SIGSTOP, SIGKILL for interrupting, pausing, or terminating processes. Example: `kill -SIGSTOP 12345` suspends process with PID 12345 until `SIGCONT` is received. Essential for comprehensive process management and resource allocation.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Process signals", + "url": "https://linuxjourney.com/lesson/process-signals", + "type": "article" + }, { "title": "Understanding Linux Process Signals", "url": "https://www.ceos3c.com/linux/understanding-linux-process-signals-a-complete/", @@ -990,6 +995,11 @@ "title": "Killing Processes", "description": "The `kill` command terminates processes in Linux by sending signals to specific Process IDs (PIDs). Use `kill [signal] PID` to terminate processes manually. Different signals provide various termination methods - SIGTERM for graceful shutdown, SIGKILL for forced termination. Process termination is essential for managing unresponsive or unwanted processes.\n\nLearn more from the following resources:", "links": [ + { + "title": "Killing Processes", + "url": "https://linuxjourney.com/lesson/killing-processes", + "type": "article" + }, { "title": "Using Kill Command in Linux", "url": "https://linuxhandbook.com/kill-command/", @@ -1004,7 +1014,7 @@ }, "5anSYRhaKIs3dCLWlvZfT": { "title": "Process Priorities", - "description": "Linux assigns priority levels to processes for efficient resource utilization and execution timing. Priority values (\"nice\" values) range from -20 (highest) to +19 (lowest priority). View priorities with `ps -eo pid,pri,user,comm`. Change priorities using `renice -5 -p [PID]`. Essential for system performance optimization and CPU resource management.\n\nVisit the following resources to learn more:", + "description": "Linux assigns priority levels to processes, affecting execution timing and resource allocation. Process priorities use \"nice\" values ranging from -20 (highest priority) to +19 (lowest priority) and only root can set negative nive value. The `/proc` filesystem contains process information including priorities. You can view priorities with `ps -eo pid,pri,user,comm` and modify them using `renice` command.\n\nVisit the following resource to learn more:", "links": [ { "title": "Understanding Process Thread Priorities in Linux", diff --git a/public/roadmap-content/nodejs.json b/public/roadmap-content/nodejs.json index 999975db9..582093ff6 100644 --- a/public/roadmap-content/nodejs.json +++ b/public/roadmap-content/nodejs.json @@ -376,7 +376,7 @@ }, { "title": "Getting Started with Npm Workspaces", - "url": "https://ruanmartinelli.com/posts/npm-7-workspaces-1", + "url": "https://ruanmartinelli.com/blog/npm-7-workspaces-1/", "type": "article" }, { diff --git a/public/roadmap-content/react-native.json b/public/roadmap-content/react-native.json new file mode 100644 index 000000000..4609991aa --- /dev/null +++ b/public/roadmap-content/react-native.json @@ -0,0 +1,1272 @@ +{ + "JfXwzkN29UGz17FYHHE3A": { + "title": "Introduction", + "description": "React Native is an open-source framework developed by Facebook that allows developers to build mobile applications using JavaScript (or TypeScript) and React. It enables building apps for both iOS and Android platforms by offering a shared codebase, which significantly reduces development time and effort.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Native", + "url": "https://reactnative.dev/", + "type": "article" + }, + { + "title": "Getting Started with React Native", + "url": "https://reactnative.dev/docs/getting-started", + "type": "article" + }, + { + "title": "React Native Course for Beginners in 2025 | Build a Full Stack React Native App", + "url": "https://www.youtube.com/watch?v=f8Z9JyB2EIE", + "type": "video" + } + ] + }, + "cMfsRtvzvDZZJ0TqeUOxm": { + "title": "What is React Native?", + "description": "React Native is a popular open-source framework developed by Facebook for building mobile applications using JavaScript (or TypeScript) and React. It enables developers to build native mobile apps for iOS and Android platforms using a single codebase, which significantly speeds up development without compromising on the performance and usability of the apps.\n\nWith React Native, you write components with JSX, a syntax that combines JavaScript and XML. These components can map to native UI elements like views, text, images, and more.\n\nVisit the following resources to learn more:\n\n* [@official@Getting Started with React Native](https://reactnative.dev/docs/getting-started))", + "links": [] + }, + "2rlmLn_yQQV-7DpX1qT98": { + "title": "Why use React Native?", + "description": "React Native is a popular framework for developing native mobile applications using JavaScript (or TypeScript) and React, offering several compelling advantages for mobile app development. Key benefits include **code reusability**, allowing developers to share a significant portion of the codebase between iOS and Android, which reduces development time and simplifies maintenance. It leverages **familiar React concepts**, making it accessible for those already experienced with ReactJS, as it applies similar principles of components and state management. React Native provides **near-native performance** by directly interacting with native components, avoiding intermediaries like WebView. The framework benefits from a **vast ecosystem** and community support, with numerous libraries and tools that enhance the development process, bolstered by contributions from major companies like Facebook. Additionally, **hot reloading** enables developers to see code changes in real-time on devices or emulators, streamlining the development workflow. Finally, React Native can be **integrated into existing applications**, allowing for flexible enhancements to specific parts of an app.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Why You Should Choose React Native?", + "url": "https://www.geeksforgeeks.org/why-you-should-choose-react-native/", + "type": "article" + }, + { + "title": "React Native: What is it? and, Why is it used?", + "url": "https://medium.com/@thinkwik/react-native-what-is-it-and-why-is-it-used-b132c3581df", + "type": "article" + } + ] + }, + "ODQ8zrHc2rsc8PN-APKvz": { + "title": "React Native Alternatives", + "description": "React Native is a popular choice for cross-platform application development, but there are other options available. Some of the common alternatives to React Native are Flutter, Ionic and Xamarin. Flutter being the most popular alternative to React Native.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flutter", + "url": "https://flutter.dev/", + "type": "article" + }, + { + "title": "Ionic", + "url": "https://ionicframework.com/", + "type": "article" + }, + { + "title": "Xamarin", + "url": "https://dotnet.microsoft.com/apps/xamarin", + "type": "article" + }, + { + "title": "Explore top posts about React", + "url": "https://app.daily.dev/tags/react?ref=roadmapsh", + "type": "article" + } + ] + }, + "cSXsu17F1Oy34Wp6J-N3C": { + "title": "Learn the Pre-requisites", + "description": "Before you start learning React Native, you should have a basic knowledge of JavaScript and React. You don't need to fully master these topics, but you should be familiar with them. Learn the basics of JavaScript (e.g. topics marked for beginners in JavaScript Roadmap and continue with React Native.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Native Basics", + "url": "https://reactnative.dev/docs/getting-started", + "type": "article" + }, + { + "title": "Visit Dedicated JavaScript Roadmap", + "url": "https://roadmap.sh/javascript", + "type": "article" + }, + { + "title": "Visit Dedicated React Roadmap", + "url": "https://roadmap.sh/react", + "type": "article" + } + ] + }, + "1oUJXtHGQ29ZZU9sxwGo2": { + "title": "JavaScript Basics", + "description": "JavaScript is a very flexible and versatile programming language, considered as a core technology for web development. This is because it is the only language natively supported by all browsers, allowing developers to add dynamic behavior and create complex user experiences with this language.\n\nThere's a lot more to learn in JavaScript but my recommendation is to learn the basics and then learn as you go. You'll learn a lot more by building things than by reading about them.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Visit Dedicated JavaScript Roadmap", + "url": "https://roadmap.sh/javascript", + "type": "article" + }, + { + "title": "Explore top posts about JavaScript", + "url": "https://app.daily.dev/tags/javascript?ref=roadmapsh", + "type": "article" + } + ] + }, + "SnF3xtzBh-x4Z_qUQUg7H": { + "title": "CSS Basics", + "description": "CSS is a stylesheet language used for describing the look and formatting of a document written in HTML or XML. It is primarily used for styling web pages and user interfaces written in HTML and XHTML. React native uses CSS to style its components. You can learn some CSS basics to get started with React Native and learn more as you go.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "CSS - W3.org", + "url": "https://www.w3.org/Style/CSS/Overview.en.html", + "type": "article" + }, + { + "title": "CSS - MDN", + "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", + "type": "article" + } + ] + }, + "k9_hVOBd9ZmC4HLuAf46v": { + "title": "Components", + "description": "React components are the building blocks of the user interface (UI) in a React application. They are used to break down the UI into reusable, isolated, and manageable pieces. Components handle rendering the UI and managing the logic and behavior.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Components", + "url": "https://react.dev/learn/your-first-component", + "type": "article" + }, + { + "title": "Props", + "url": "https://react.dev/learn/passing-props-to-a-component", + "type": "article" + } + ] + }, + "V7r1Hqk9IXTfjkjAg7-BT": { + "title": "State", + "description": "State is an object that holds data managed within a React component. It allows components to become dynamic and interactive by keeping track of its data changes. When the state of a component changes, React re-renders the component and updates the DOM accordingly.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Component State", + "url": "https://react.dev/learn/managing-state", + "type": "article" + } + ] + }, + "s5YKenJY2Xv_PZBSxegEm": { + "title": "JSX", + "description": "JSX is a syntax extension for JavaScript that allows you to write HTML-like code within your JavaScript code. It was developed to be used with React and has become an integral part of working with React.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Components", + "url": "https://react.dev/learn/your-first-component", + "type": "article" + }, + { + "title": "Writing Markup with JSX", + "url": "https://react.dev/learn/writing-markup-with-jsx", + "type": "article" + }, + { + "title": "JavaScript in JSX with Curly Braces", + "url": "https://react.dev/learn/javascript-in-jsx-with-curly-braces", + "type": "article" + }, + { + "title": "Explore top posts about JSX", + "url": "https://app.daily.dev/tags/jsx?ref=roadmapsh", + "type": "article" + } + ] + }, + "0gH7vI_Hy7s9hO2TF6hR3": { + "title": "Props", + "description": "In React, **props** are short for _properties_ and are used to pass data from a parent component to a child component. They are similar to function arguments, and they help make components reusable and maintainable.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Components", + "url": "https://react.dev/learn/your-first-component", + "type": "article" + }, + { + "title": "Props", + "url": "https://react.dev/learn/passing-props-to-a-component", + "type": "article" + } + ] + }, + "lNmddXrT8IHVtWobh3-oq": { + "title": "Environment Setup", + "description": "In React Native, setting up the development environment is a crucial step. The environment setup process includes installing and configuring various tools and packages required for developing, building, and launching a React Native application. There are two main approaches when setting up your React Native development environment:\n\nExpo CLI\n--------\n\nExpo CLI is a command-line tool built for creating and managing React Native projects easily. It streamlines your development process by providing an entire development environment, including building and deploying your app to both iOS and Android platforms.\n\nReact Native CLI\n----------------\n\nReact Native CLI is the official command-line interface for building native mobile apps using React Native. This method requires you to manually set up the native development environment and tools needed for iOS and Android app development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Native CLI", + "url": "https://reactnative.dev/docs/environment-setup?guide=native", + "type": "article" + }, + { + "title": "Expo CLI Quickstart", + "url": "https://docs.expo.dev/get-started/create-a-project", + "type": "article" + } + ] + }, + "yW7nDDJbjmm8XKJI0hq3Q": { + "title": "Expo", + "description": "", + "links": [] + }, + "uLH9eo2G09wGO80XtFI5x": { + "title": "create-expo-app", + "description": "`create-expo-app` is a command line tool that generates a React Native project that works out of the box with Expo. It is the easiest way to get started building a new React Native application.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Create Expo App", + "url": "https://docs.expo.dev/tutorial/create-your-first-app/", + "type": "article" + } + ] + }, + "9eOwhh2k59nvH-ztuDNjg": { + "title": "Expo Snack", + "description": "Expo Snack is an online playground and development environment for creating and testing React Native projects. With Snack, you can easily edit and preview your code changes directly in your browser or on a mobile device using the Expo Go app. It offers a fast, easy, and convenient way to develop, test, and share your projects without needing to set up a local development environment.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Expo Snack", + "url": "https://snack.expo.dev/", + "type": "article" + } + ] + }, + "zzOyoDcAQYkNNv07TIKeZ": { + "title": "Expo Tradeoffs", + "description": "Expo is a powerful tool that simplifies the React Native development process, but it has some tradeoffs to consider. One limitation is the availability of native modules; while Expo provides a set of pre-built modules, it may not cover all functionalities needed for specific apps, requiring developers to eject from the managed workflow for custom solutions. Performance can also be an issue, as the additional layer Expo adds may lead to slower apps, especially for larger projects, whereas the bare workflow offers more control and potentially better performance. Additionally, Expo apps tend to have a larger size due to the inclusion of the entire Expo SDK, which can be inefficient compared to non-Expo apps that only include necessary modules. Developers relying on Expo must also wait for their release cycle for updates, which can delay access to new React Native features or bug fixes. Ejecting from Expo can present challenges, as it may require significant code adjustments and dependency migrations. Lastly, Expo's abstraction limits customizability, meaning that for advanced customizations, developers may need to switch to a bare workflow. Overall, while Expo provides great tooling and simplifies development, its limitations should be carefully weighed before choosing it for app development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Should you use Expo or Bare React Native?", + "url": "https://medium.com/@andrew.chester/should-you-use-expo-or-bare-react-native-8dd400f4a468/", + "type": "article" + } + ] + }, + "bxWLf0RDAl9Zaczkon9Rl": { + "title": "React Native CLI", + "description": "React Native CLI is the official command-line interface for building native mobile apps using React Native. This method requires you to manually set up the native development environment and tools needed for iOS and Android app development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Native CLI", + "url": "https://reactnative.dev/docs/environment-setup?guide=native", + "type": "article" + } + ] + }, + "VhSEH_RoWFt1z2lial7xZ": { + "title": "Metro Bundler", + "description": "Metro Bundler is the default bundler for React Native applications. It's a JavaScript module bundler that takes all your application code and dependencies, and bundles them together into a single JavaScript file or multiple files (based on platform).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Metro Bundler", + "url": "https://facebook.github.io/metro/", + "type": "article" + } + ] + }, + "T4AhL9Zls2iNZMituGdtl": { + "title": "Development Workflow", + "description": "React native has a decent guide on how to get started with development workflow.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Continuous Integration and Deployment for React Native Apps", + "url": "https://dev.to/medaimane/continuous-integration-and-deployment-for-react-native-apps-streamlining-development-workflow-4i04", + "type": "article" + }, + { + "title": "Running on Device", + "url": "https://reactnative.dev/docs/running-on-device", + "type": "article" + } + ] + }, + "KyKMZ8Aa5XUAIWelGTiSt": { + "title": "Running on Device", + "description": "It's always a good idea to test your app on an actual device before releasing it to your users.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Running on Device", + "url": "https://reactnative.dev/docs/running-on-device", + "type": "article" + } + ] + }, + "tOt_vvmnBtOUbgokmVa5P": { + "title": "In-App Developer Menu", + "description": "React Native provides an in-app developer menu which offers several debugging options. You can access the Dev Menu by shaking your device or via keyboard shortcuts:\n\n* Android: `Cmd + M` or `Ctrl + M`\n* iOS: `Cmd + D` or `Ctrl + D`\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Debugging", + "url": "https://reactnative.dev/docs/debugging", + "type": "article" + } + ] + }, + "wWwaEdnvBsvj6jD9LJ4Jj": { + "title": "Enabling Fast Refresh", + "description": "Fast Refresh is a React Native feature that allows you to get near-instant feedback while making changes in your code. It achieves this by reloading only the portion of the app that was changed, without losing the current state. This makes the development process a lot smoother as you don't have to wait for the entire app to rebuild after making a change.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fast Refresh", + "url": "https://reactnative.dev/docs/fast-refresh", + "type": "article" + } + ] + }, + "Tz-bRjQVkZedphelhAlWM": { + "title": "LogBox", + "description": "LogBox is a new feature added to React Native to improve how logs are displayed and managed in your development environment. It provides better visualization and organization of logs, warnings, and errors, making it easier for developers to address issues in their code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Debugging LogBox", + "url": "https://reactnative.dev/docs/debugging#logbox", + "type": "article" + } + ] + }, + "Dq490IqEJXoFZRnBFJI8N": { + "title": "Sourcemaps", + "description": "Sourcemaps are files that map the original source code of a project to its minified or transpiled version. This is especially useful in environments, like React Native, where the code may be transformed before being executed in the device/emulator. Sourcemaps help developers to debug their code more easily by mapping errors in the transformed code back to their original location in the source code.\n\nThere are various types of sourcemaps which give different levels of detail to the debugging process:\n\n* `eval`: Uses `eval` function to generate the sourcemaps. This is faster but provides less detailed information than other options.\n* `cheap-source-map`: Simple line-to-line mapping without column information. Faster than `source-map` but less accurate.\n* `cheap-module-source-map`: Similar to `cheap-source-map` but with support for modules.\n* `source-map`: Full source mapping with both line and column information. It is accurate, though slower compared to other options.\n\nAfter generating sourcemaps, you can use them to debug errors more efficiently, as they will reference the original locations in the source code. The browser's developer tools, like Google Chrome, have built-in support for sourcemaps, providing the ability to navigate and debug errors with ease.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "SourceMaps", + "url": "https://reactnative.dev/docs/0.71/sourcemaps", + "type": "article" + } + ] + }, + "HHx3VSfV7xf6RqACrxjBf": { + "title": "DevTools", + "description": "React Native DevTools are essential tools that help developers debug and optimize their applications during the development process.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Devtools", + "url": "https://reactnative.dev/docs/react-devtools", + "type": "article" + } + ] + }, + "fnujIq6QAFB6bmTisuZ3T": { + "title": "Core Components", + "description": "Core components are the essential building blocks provided by React Native to create a user interface for mobile applications. They are platform-agnostic, meaning they work across both iOS and Android devices. Some of the common core components include:\n\n* `View` is a fundamental component for constructing the user interface. It is equivalent to a `div` in HTML and can be used as a container for other components.\n* `Text` is used to display text content in your app. It is similar to the `p` or `span` elements in HTML.\n* `TextInput` is a basic input field that allows users to type text into your app. It is similar to the `input` element in HTML.\n* `TouchableOpacity` is a wrapper for making elements like `View` and `Text` respond properly to touch events. It provides feedback by reducing the opacity of the wrapped component when pressed.\n* `ScrollView` is a scrollable container that allows users to scroll through its content. It is useful when you have content that exceeds the available screen size.\n* `FlatList` is used to render a list of items using a performant approach. It only renders items that are currently visible on the screen and removes others to save memory.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Core Components and APIs", + "url": "https://reactnative.dev/docs/components-and-apis", + "type": "article" + }, + { + "title": "Core Components and Native Components", + "url": "https://reactnative.dev/docs/intro-react-native-components", + "type": "article" + } + ] + }, + "OFhyYyxtrCBy_UUb5YBv5": { + "title": "Text", + "description": "The `Text` component is a basic element in React Native used to display text content on the screen. While it has some basic styling properties, you usually nest it inside other components (e.g., `View`) to create more complex UIs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Text", + "url": "https://reactnative.dev/docs/text", + "type": "article" + } + ] + }, + "Frz1RYp3y9OwRb-3t2e85": { + "title": "Text Input", + "description": "`TextInput` is a core component in React Native that allows the user to enter text. It is commonly used to collect user data, like emails or passwords. You can customize the appearance of `TextInput` by using various props such as `placeholder`, `multiline`, `maxLength`, and more.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Text Input", + "url": "https://reactnative.dev/docs/textinput", + "type": "article" + } + ] + }, + "kkH9H9Qh1FD7sLItoWw69": { + "title": "Button", + "description": "A `Button` is a built-in React Native component used to create clickable buttons. It is a simple, customizable and easy-to-use component that captures touches and triggers an `onPress` event when pressed.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Button", + "url": "https://reactnative.dev/docs/button", + "type": "article" + } + ] + }, + "E7N8tSg2amZW-vc-X46JU": { + "title": "Image", + "description": "The `Image` component is used to display images in a React Native application. It allows you to load and display local as well as remote images, providing essential props and methods for better image handling and customization.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Image", + "url": "https://reactnative.dev/docs/image", + "type": "article" + } + ] + }, + "GFGhnx5xUer2DdRI-SO4D": { + "title": "ImageBackground", + "description": "`ImageBackground` is a React Native core component that allows you to display an image as a background while still being able to place content inside the component. This helps in creating beautiful layouts with images and text or other content on top.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Image Background", + "url": "https://reactnative.dev/docs/imagebackground", + "type": "article" + } + ] + }, + "ouNTekf4VpZv-Vja8_bfM": { + "title": "Switch", + "description": "A `Switch` is a core component in React Native used to implement a \"toggle\" or \"on-off\" input. It provides a UI for the user to switch between two different states, typically true or false. The primary use case is to enable or disable a feature or setting within an application.\n\n`Switch` component has a boolean `value` prop (true for on, false for off) and an `onValueChange` event handler, which is triggered whenever the user toggles the switch.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Switch", + "url": "https://reactnative.dev/docs/switch", + "type": "article" + } + ] + }, + "QOOZs9qtz49agfZwi6k1B": { + "title": "StatusBar", + "description": "The `StatusBar` component is used to control the appearance of the status bar on the top of the screen. It may strike as a bit unusual since, unlike other React Native components, it doesn't render any visible content. Instead, it sets some native properties that can help customize the look of status bars on Android, iOS, or other platforms.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "StatusBar", + "url": "https://reactnative.dev/docs/statusbar", + "type": "article" + } + ] + }, + "hHFR59RrdMIWxcQe72qCs": { + "title": "ActivityIndicator", + "description": "The `ActivityIndicator` is a core component in React Native that provides a simple visual indication of some ongoing activity or loading state within your application. It shows a spinning animation, which gives the user feedback that something is happening in the background. This component is particularly useful when fetching data from an external source, like a server, or while performing time-consuming operations.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Activity Indicator", + "url": "https://reactnative.dev/docs/activityindicator", + "type": "article" + } + ] + }, + "V34mZCkpoT49o-74XoATS": { + "title": "Modal", + "description": "A `Modal` is a component that displays content on top of the current view, creating an overlay that can be used for various purposes, such as displaying additional information, confirmation messages, or a selection menu.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Modal", + "url": "https://reactnative.dev/docs/modal", + "type": "article" + } + ] + }, + "4BgVq-cZYEXgqktvlNnet": { + "title": "Pressable", + "description": "Pressable is a core component in React Native that makes any view respond properly to touch or press events. It provides a wide range of event handlers for managing user interactions, such as onPress, onPressIn, onPressOut, and onLongPress. With Pressable, you can create custom buttons, cards, or any touchable elements within your app.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pressable", + "url": "https://reactnative.dev/docs/pressable", + "type": "article" + } + ] + }, + "GrFL32pZ_eOmdJRzSlH8b": { + "title": "View", + "description": "", + "links": [] + }, + "UqCpoPzYio3ng3RFlbvZ7": { + "title": "SafeAreaView", + "description": "`SafeAreaView` is a React Native core component that helps to adjust your app's UI elements and layout to accommodate the notches, curved edges, or home indicator on iOS devices. It is particularly useful for the iPhone X and newer iPhone models, as it ensures that content is rendered within the visible portion of the screen.\n\nKeep in mind that `SafeAreaView` only works on iOS devices, and has no effect on Android devices. To handle such cases, you can use platform-specific styles or libraries like `react-native-safe-area-context` which provide more control and customization options for additional platforms.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "SafeAreaView", + "url": "https://reactnative.dev/docs/safeareaview", + "type": "article" + } + ] + }, + "8bn1PFd9h0ek6_T-cl1cS": { + "title": "KeyboardAvoidingView", + "description": "`KeyboardAvoidingView` is a built-in React Native component that automatically adjusts its children components' position when the keyboard opens, preventing them from being obscured by the on-screen keyboard. It's a useful component, particularly for forms and input fields where the user needs to see the text they're typing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "KeyboardAvoidingView", + "url": "https://reactnative.dev/docs/keyboardavoidingview", + "type": "article" + } + ] + }, + "x-OZCZcX6uhN3Yr5BAATn": { + "title": "Listings", + "description": "", + "links": [] + }, + "yN283SRWoALOEZh9iTn-L": { + "title": "ScrollView", + "description": "In React Native, the `ScrollView` is a generic scrolling container used to provide a scrollable view to its child components. It is useful when you need to display scrollable content larger than the screen, such as lists, images, or text. A `ScrollView` must have a bounded height in order to properly work.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "ScrollView", + "url": "https://reactnative.dev/docs/ScrollView", + "type": "article" + } + ] + }, + "h3ypxGxeHDCTxURHg6D2d": { + "title": "ListViews", + "description": "", + "links": [] + }, + "CYqLNGyOe9f9hVhbyUnTX": { + "title": "FlatList", + "description": "`FlatList` is a `React Native` core component that displays a scrolling list of changing, but similarly structured, data. It is an efficient list component that makes use of a limited scrolling `renderWindow`, reducing the memory footprint and creating smooth scrolling. Additionally, `FlatList` supports-Headers, Footers, Pull-to-refresh, and Horizontal scrolling, among other things.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "FlatList", + "url": "https://reactnative.dev/docs/flatlist", + "type": "article" + } + ] + }, + "gLJMD9X7chy8OxdALht8g": { + "title": "SectionList", + "description": "`SectionList` is a component used to render sections and headers in a scroll view. It helps to manage and optimize a large list of items divided into categories. It is one of the List View components provided by React Native along with FlatList.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "SectionList", + "url": "https://reactnative.dev/docs/sectionlist", + "type": "article" + } + ] + }, + "m8Nu71Y61Ha_fLxdtWTkn": { + "title": "RefreshControl", + "description": "`RefreshControl` is a component in React Native that is used to provide pull-to-refresh functionality for scrollable components like `ScrollView`, `ListView`, and `FlatList`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Refresh Control", + "url": "https://reactnative.dev/docs/refreshcontrol", + "type": "article" + }, + { + "title": "ScrollView", + "url": "https://reactnative.dev/docs/ScrollView", + "type": "article" + }, + { + "title": "FlatList", + "url": "https://reactnative.dev/docs/FlatList", + "type": "article" + } + ] + }, + "HiUbRfOv8OttFd85pDUHN": { + "title": "Writing Platform Specific Code", + "description": "In React Native, managing platform-specific code for iOS and Android is essential for addressing differences in application behavior and appearance. This can be achieved in two primary ways: using the `Platform` module, which allows developers to detect the current platform and apply conditional styles or logic accordingly, as demonstrated by using `Platform.select` to set different background colors for iOS and Android; and utilizing file extensions like `.ios.js` and `.android.js`, which enables React Native to automatically load the appropriate file based on the platform. For instance, if you have `Header.ios.js` and `Header.android.js`, importing the `Header` component will automatically reference the correct file for the running platform, streamlining the development process.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Platform-Specific Code", + "url": "https://reactnative.dev/docs/platform-specific-code", + "type": "article" + }, + { + "title": "App Extensions", + "url": "https://reactnative.dev/docs/app-extensions", + "type": "article" + } + ] + }, + "KZIrRSYq_I-YzpFaYLuWi": { + "title": "Platform Module", + "description": "The Platform module, as the name suggests, is a part of React Native that detects the platform on which the app is running. This enables you to have specific code for either Android or iOS, allowing you to account for platform-specific differences in design or behavior.\n\nTo utilize the Platform module, you need to import it and then access the `OS` property. This property returns a string, which denotes the platform — either `'ios'` or `'android'`.\n\nWith the Platform module, you can easily create platform-specific code, enabling you to have the best user experience for each platform. Just remember to import the module and use the provided properties and methods.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Platform", + "url": "https://reactnative.dev/docs/platform", + "type": "article" + }, + { + "title": "Platform-Specific Code", + "url": "https://reactnative.dev/docs/platform-specific-code", + "type": "article" + } + ] + }, + "LLANnVosxOUCPTtuBfNgu": { + "title": "File Extensions", + "description": "In React Native, you can write platform-specific code by using specific file extensions, such as appending `.android.` or `.ios.` to your file names, allowing React Native to automatically load the appropriate file based on the platform. This approach is useful in two main scenarios: creating separate files for platform-specific components, like `Header.ios.js` and `Header.android.js`, which can have different implementations and styles for iOS and Android, and using the `Platform` module within a single file to conditionally render platform-specific code. By leveraging these techniques, developers can create tailored components and features for each platform while keeping their codebase organized and maintainable.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Platform-Specific Code", + "url": "https://reactnative.dev/docs/platform-specific-code", + "type": "article" + }, + { + "title": "App Extensions", + "url": "https://reactnative.dev/docs/app-extensions", + "type": "article" + } + ] + }, + "UQpyXrC2cs_jDXxVTlQOu": { + "title": "react-native-web", + "description": "React Native Web is an extension of React Native which allows you to run your React Native apps not only on iOS and Android devices, but also on the web. It uses the same components and APIs you're familiar with in React Native, but renders them into the DOM of a webpage instead of native UI elements.\n\nThe main goal of React Native Web is to provide a consistent developer experience across platforms, reducing the effort needed to build and maintain multi-platform apps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "react-native-web - npm", + "url": "https://www.npmjs.com/package/react-native-web", + "type": "article" + }, + { + "title": "Complete Guide to React Native for Web", + "url": "https://blog.logrocket.com/complete-guide-react-native-web/", + "type": "article" + } + ] + }, + "ervpuL89myBW3oR9r-4lH": { + "title": "Styling", + "description": "Styling in React Native is accomplished through JavaScript and uses a subset of CSS properties. Unlike CSS in web development, React Native has its own set of components and styling rules. The main components used for styling are `StyleSheet`, `View`, and `Text`.\n\n`StyleSheet` is a module provided by React Native to manage and optimize styles. It is similar to a CSS stylesheet and helps in creating and working with multiple styles efficiently.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Styling", + "url": "https://reactnative.dev/docs/style", + "type": "article" + } + ] + }, + "wB0D9koC6jpt1rzX8F07F": { + "title": "Stylesheets", + "description": "In React Native, stylesheets are objects that define the appearance of components. They provide a way to separate styling from the component's logic. Stylesheets are created using `StyleSheet.create` method, which ensures a standardized and efficient way to manage styles for your components.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Stylesheets", + "url": "https://reactnative.dev/docs/stylesheet", + "type": "article" + } + ] + }, + "e-r3tuRZ3PzhFegES0oOm": { + "title": "Layouts & Flexbox", + "description": "In React Native, layouts are primarily managed using the Flexbox styling system. Flexbox is a powerful and flexible layout system that allows you to create responsive and complex UIs using a set of simple rules.\n\nYou can use these styles in various combinations to create flexible layouts in React Native. Flexbox makes it easy to create responsive UIs that adapt to changes in screen size or orientation. Note that some of these styles might not work as expected in React Native compared to in CSS for the web, but the overall concepts remain the same.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flexbox", + "url": "https://reactnative.dev/docs/flexbox", + "type": "article" + }, + { + "title": "Layout Props", + "url": "https://reactnative.dev/docs/layout-props", + "type": "article" + } + ] + }, + "KoXTwQUqPt_ZhOFuaelny": { + "title": "Accessibility", + "description": "Accessibility (often abbreviated as a11y) in React Native is a crucial aspect of application development that ensures your applications are usable by everyone, including individuals with disabilities. This commitment to inclusivity is not just a legal requirement in many jurisdictions but also a moral imperative that enhances the user experience for all. React Native provides a comprehensive set of accessibility features, attributes, and APIs that allow developers to create applications that cater to diverse user needs. By implementing these features, developers can ensure that their applications are navigable and usable by individuals with visual, auditory, motor, or cognitive impairments.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Accessibility", + "url": "https://reactnative.dev/docs/accessibility", + "type": "article" + } + ] + }, + "7GBV5sfOaGxHwpkNUvFWE": { + "title": "Networking", + "description": "React Native facilitates network requests and data management from remote sources through various techniques. The primary method is the `fetch` function, a promise-based API that allows developers to make HTTP requests and retrieve resources, typically in JSON format, from a specified URL. For example, a simple fetch request can be made as follows:\n\n fetch('https://jsonplaceholder.typicode.com/todos/1')\n .then((response) => response.json())\n .then((json) => console.log(json))\n .catch((error) => console.error(error));\n \n\nAnother popular option is Axios, a widely-used library that simplifies HTTP requests in JavaScript applications. Like fetch, Axios is promise-based and offers a user-friendly API, making it a preferred choice for many developers when handling network requests in React Native.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Networking", + "url": "https://reactnative.dev/docs/network", + "type": "article" + }, + { + "title": "Fetch API", + "url": "https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API", + "type": "article" + }, + { + "title": "Axios", + "url": "https://axios-http.com/docs/intro", + "type": "article" + }, + { + "title": "Managing network connection status in React Native", + "url": "https://blog.logrocket.com/managing-network-connection-status-in-react-native/", + "type": "article" + } + ] + }, + "k7uVPyhbPgvO6HxAfxxYZ": { + "title": "Connectivity Status", + "description": "Connectivity refers to the mechanisms that allow data transfer between your React Native app and external resources through various means of communication. It is essential to ensure efficient communication with APIs, servers, and external systems, to update your app's data, fetching content or enabling real-time interactions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Managing network connection status in React Native", + "url": "https://blog.logrocket.com/managing-network-connection-status-in-react-native/", + "type": "article" + } + ] + }, + "aSCgax1M4wlmzkJSZV_fv": { + "title": "WebSockets", + "description": "WebSockets are a protocol that allows full-duplex communication between a client and a server over a single, long-lived connection. They are useful when real-time communication is needed, such as in chat applications, online gaming, or financial trading platforms.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "The WebSocket API (WebSockets) - Web APIs", + "url": "https://developer.mozilla.org/en-US/docs/Web/API/WebSockets_API", + "type": "article" + } + ] + }, + "f7KFPFS2-EA90pumYHM9T": { + "title": "Fetch", + "description": "_Fetch_ is a JavaScript function available in React Native that is used to make network requests, similar to XMLHttpRequest in web applications. It allows you to handle requests and retrieve data from APIs or other sources. The Fetch API is built on Promises, making it simple to handle success and error cases.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Managing network connection status in React Native", + "url": "https://blog.logrocket.com/managing-network-connection-status-in-react-native/", + "type": "article" + } + ] + }, + "CAQJaGs24wx1SqKOU44aB": { + "title": "Push Notifications", + "description": "", + "links": [] + }, + "GYdz9a1yLiewAeMRSyfLr": { + "title": "Interactions", + "description": "Interaction in React Native means dealing with how the user can interact with your application. This typically involves handling touch events, gestures, and animations to provide a more engaging and dynamic user experience. There are several built-in components and libraries available in React Native to help you build interactive elements in your app.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Animations", + "url": "https://reactnative.dev/docs/animations", + "type": "article" + }, + { + "title": "LayoutAnimations", + "url": "https://reactnative.dev/docs/layoutanimation", + "type": "article" + } + ] + }, + "A7ZIe8nlQnHU5g3LM3Eif": { + "title": "Touchables", + "description": "In React Native, `Touchable` components are used to handle user interactions like taps, long presses, and double-taps on the appropriate elements. Each of these components is from the `react-native` package, except `TouchableScale` which is from `react-native-touchable-scale`. They can be used interchangeably depending on the type of interaction you want to provide. The main `props` used with these components are `onPress`, `onLongPress`, and some component-specific ones like `underlayColor` for `TouchableHighlight`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Handling Touches", + "url": "https://reactnative.dev/docs/handling-touches", + "type": "article" + }, + { + "title": "TouchableOpacity", + "url": "https://reactnative.dev/docs/touchableopacity", + "type": "article" + } + ] + }, + "xf7L5J42yQq3LE7lG2plp": { + "title": "Gesture Handling", + "description": "Gesture handling is an essential and powerful feature in React Native that helps create interactive and responsive user interfaces. React Native provides several built-in components and libraries to recognize and respond to different types of user gestures. Some of the common gestures include tapping, swiping, dragging, and pinching.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Animations", + "url": "https://reactnative.dev/docs/animations", + "type": "article" + }, + { + "title": "LayoutAnimations", + "url": "https://reactnative.dev/docs/layoutanimation", + "type": "article" + }, + { + "title": "Animated", + "url": "https://reactnative.dev/docs/animated", + "type": "article" + } + ] + }, + "nk6zdVNRz_xE71mVUOFsi": { + "title": "Scrolling & Swiping", + "description": "In React Native, scrolling and swiping interactions can be defined and customized with a set of built-in components. These components are efficient and provide fluid navigation through the elements inside them.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Handling Touches", + "url": "https://reactnative.dev/docs/handling-touches", + "type": "article" + }, + { + "title": "Using a ScrollView", + "url": "https://reactnative.dev/docs/using-a-scrollview", + "type": "article" + }, + { + "title": "React Native Gesture Handler: Swipe, long-press, and more", + "url": "https://blog.logrocket.com/react-native-gesture-handler-tutorial-examples/", + "type": "article" + } + ] + }, + "Jr2iuQqyCbx6CyTJj4Qz2": { + "title": "Screen Navigation", + "description": "In React Native, navigating from one screen to another is a crucial aspect of app development. The most commonly used navigation libraries are React Navigation and React Native Navigation.\n\nLearn more from the following resources:", + "links": [ + { + "title": "React Navigation", + "url": "https://reactnavigation.org/", + "type": "article" + } + ] + }, + "3NLcPO-hqQV1EacoPLVrv": { + "title": "Animations", + "description": "React Native supports two types of animations: `Animated` and `LayoutAnimation`. The `Animated` API provides a basic set of methods for creating and managing animations, while the `LayoutAnimation` API provides a way to animate changes from one layout to another.\n\n`Animated` is a declarative API that focuses on handling animation-related calculations. It allows you to create and combine animations with fine-grained control over the specific properties that are being animated. You can use this API to create a variety of effects, such as fading, scaling, and translating components on the screen.\n\n`LayoutAnimation` is a higher-level abstraction for animating changes to the layout. Instead of animating individual properties, you define how the changes should occur and React Native takes care of updating the layout accordingly. This is particularly useful for animating multiple components or modifying the layout in response to user interaction, such as adding/removing/reordering items in a list.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Animations", + "url": "https://reactnative.dev/docs/animations", + "type": "article" + }, + { + "title": "LayoutAnimations", + "url": "https://reactnative.dev/docs/layoutanimation", + "type": "article" + }, + { + "title": "Animated", + "url": "https://reactnative.dev/docs/animated", + "type": "article" + } + ] + }, + "dckRzKDKj-mLB3-OxwjPh": { + "title": "DeepLinking", + "description": "", + "links": [] + }, + "CGtVwhVGc8Vea5RfzJvQG": { + "title": "Security", + "description": "Security is a vital consideration in React Native application development, as it helps protect user data and sensitive information. Key best practices include using secure storage solutions for sensitive data, such as authentication tokens and user credentials, with libraries like `react-native-keychain` and `react-native-encrypted-storage`. For secure communication, always use HTTPS for API interactions to ensure that data exchanged between the client and server is encrypted. Additionally, minimize permissions by requesting only those necessary for the app's functionality, ideally at runtime, using libraries like `react-native-permissions`.\n\nValidating and sanitizing user input is crucial to prevent threats like SQL injection and cross-site scripting (XSS), which can be achieved with validation libraries such as `Yup`. Lastly, keeping dependencies up to date is essential to avoid known security vulnerabilities; tools like `npm audit` and Dependabot can assist in this process. By adhering to these best practices, developers can enhance the security of their React Native applications, safeguarding both application data and user information.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Security", + "url": "https://reactnative.dev/docs/security", + "type": "article" + }, + { + "title": "Secure Authentication and Authorization in React Native", + "url": "https://medium.com/@christopherobocha/secure-authentication-and-authorisation-in-react-native-a260f1787a89", + "type": "article" + } + ] + }, + "LRBHwYiT0Yyi18PwR49rc": { + "title": "Authentication", + "description": "Authentication is a crucial aspect of securing your React Native application. It enables you to verify the identity of users and give access to protected resources and features. Here are the common methods used for authentication in React Native:\n\n* JWT Authentication\n* OAuth\n* Simple Token Authentication\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Authentication and Deep Linking", + "url": "https://reactnative.dev/docs/security#authentication-and-deep-linking", + "type": "article" + }, + { + "title": "Explore top posts about Authentication", + "url": "https://app.daily.dev/tags/authentication?ref=roadmapsh", + "type": "article" + } + ] + }, + "ee4QqFTosXNcTgoQIok8i": { + "title": "Networking", + "description": "Networking in React Native primarily uses the Fetch API and XMLHttpRequest for making network requests. These APIs allow you to retrieve data from remote servers and handle asynchronous operations easily. React Native offers various ways to handle networking tasks like making API calls, sending/receiving data from remote servers, and handling different network protocols.\n\n* Fetch\n* HTTP Call Libraries\n* Web Sockets\n\nThese are the major ways to handle networking tasks in React Native. Choose the method that best suits your specific use case and allows you to take full advantage of the features offered.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Networking", + "url": "https://reactnative.dev/docs/network", + "type": "article" + }, + { + "title": "Efficient Network Communication", + "url": "https://medium.com/@Blochware/efficient-network-communication-best-practices-for-handling-api-calls-in-react-native-b5bebbc8ba71", + "type": "article" + } + ] + }, + "NdjmP1bZNYriV08vb-iRw": { + "title": "Storage", + "description": "React Native provides a few ways to persist data locally in the app. Here's a brief summary of the storage options available:\n\n* Async Storage\n* Expo Secure Store\n* Expo File System\n* Expo SQLite\n\nChoose the storage option that best fits your app's requirements and use cases. Keep in mind that AsyncStorage and SecureStorage are more suited for small-scale data storage, while Realm and SQLite support more complex storage and querying needs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "AsyncStorage", + "url": "https://reactnative.dev/docs/asyncstorage", + "type": "article" + }, + { + "title": "Best Data Storage Option for React Native Apps", + "url": "https://dev.to/ammarahmed/best-data-storage-option-for-react-native-apps-42k", + "type": "article" + } + ] + }, + "w0WW1kg_0BEMeLa1l2gb5": { + "title": "Storage", + "description": "React Native offers several methods for persisting data locally within applications, each catering to different storage needs and use cases. The primary options include Async Storage, which provides a simple key-value storage system suitable for small-scale data; Expo Secure Store, designed for securely storing sensitive information; Expo File System, which allows for file management and storage; and Expo SQLite, which supports more complex data storage and querying capabilities. When selecting a storage option, it's essential to consider the specific requirements of your app.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Best Data Storage Option for React Native Apps", + "url": "https://dev.to/ammarahmed/best-data-storage-option-for-react-native-apps-42k", + "type": "article" + } + ] + }, + "WsJGiMjHSQ6MpPd5wuP9h": { + "title": "react-native-async-storage", + "description": "React Native AsyncStorage is an unencrypted, asynchronous, persistent key-value storage system that allows developers to store data globally within their applications. It is primarily used for persisting data offline, making it suitable for scenarios like saving user preferences or session data.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Async Storage - Github", + "url": "https://github.com/react-native-async-storage/async-storage", + "type": "opensource" + }, + { + "title": "Async Storage", + "url": "https://reactnative.dev/docs/asyncstorage", + "type": "article" + } + ] + }, + "JgBfwmOgcVi_a96L5NGwr": { + "title": "expo-secure-store", + "description": "Expo Secure Store is a built-in package provided by the Expo SDK to store encrypted data securely on users' devices. It is a key-value storage system, but it is not designed to store larger amounts of data such as app databases or complex data structures. It is most appropriate for storing secret keys, access tokens, and small user preferences.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "expo-secure-store package", + "url": "https://www.npmjs.com/package/expo-secure-store?activeTab=readme", + "type": "opensource" + }, + { + "title": "secure-store", + "url": "https://docs.expo.dev/versions/latest/sdk/securestore/", + "type": "article" + } + ] + }, + "9pvrXH5Drdsa1cr93UBdc": { + "title": "expo-file-system", + "description": "Expo File System is a universal module that provides access to the file system on the device. Using this module, you can perform various file operations like reading, writing, copying, moving, and deleting files and folders. It also supports reading file metadata and querying file URI.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Expo File System", + "url": "https://docs.expo.dev/versions/latest/sdk/filesystem/", + "type": "article" + } + ] + }, + "oK8z23a_CjcDjBJ843_Jn": { + "title": "expo-sqlite", + "description": "Expo SQLite is a powerful tool for handling local SQLite databases in your React Native application. By using this API, you can create, read, update, and delete data as needed, without writing native code. Expo SQLite is available as part of the expo-sqlite package, which provides an easy-to-use interface for SQLite functionalities.\n\nWith Expo SQLite, you can efficiently manage SQLite databases within your React Native applications. It enables you to perform various database operations without the need for writing native code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "expo-sqlite", + "url": "https://docs.expo.dev/versions/latest/sdk/sqlite/", + "type": "article" + } + ] + }, + "vZMsm-MtsqmQMD-MG6zJY": { + "title": "Other Storage Options", + "description": "Besides AsyncStorage, there are other options available for handling data storage in React Native applications. This guide will briefly cover some popular options: Realm, Firebase Realtime Database, and SQLite.\n\nThese are just a few examples of additional storage options for React Native. Depending on your requirements, you may choose the one that best fits your project.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Realm - Github", + "url": "https://github.com/realm/realm-js", + "type": "opensource" + }, + { + "title": "Async Storage", + "url": "https://reactnative.dev/docs/asyncstorage", + "type": "article" + }, + { + "title": "Firebase Realtime Database", + "url": "https://firebase.google.com/docs/database", + "type": "article" + }, + { + "title": "Explore top posts about Storage", + "url": "https://app.daily.dev/tags/storage?ref=roadmapsh", + "type": "article" + } + ] + }, + "G15Aey-Spax_iUHpm1v38": { + "title": "Testing", + "description": "When it comes to testing, you can use a combination of Jest, React Test Renderer, React Native Testing Library, Detox and Appium for all sorts of API needs.", + "links": [] + }, + "06gsRokwjxVa2xyLY4qAb": { + "title": "Jest", + "description": "Jest is a delightful JavaScript Testing Framework with a focus on simplicity. It works with projects using: Babel, TypeScript, Node, React, Angular, Vue and more!\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Jest", + "url": "https://jestjs.io/", + "type": "article" + }, + { + "title": "Jest Documentation", + "url": "https://jestjs.io/docs/getting-started", + "type": "article" + }, + { + "title": "Explore top posts about Jest", + "url": "https://app.daily.dev/tags/jest?ref=roadmapsh", + "type": "article" + }, + { + "title": "Jest Crash Course - Unit Testing in JavaScript", + "url": "https://www.youtube.com/watch?v=7r4xVDI2vho", + "type": "video" + } + ] + }, + "81tmis0km2h1zsjS2HsP5": { + "title": "React Test Renderer", + "description": "React Test Renderer is a library provided by the React team that allows you to render React components as JavaScript objects without depending on the DOM or a native mobile environment. It can be used to test components in Node.js environments where the actual rendering is not required.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Test Renderer", + "url": "https://jestjs.io/docs/tutorial-react", + "type": "article" + }, + { + "title": "Explore top posts about React", + "url": "https://app.daily.dev/tags/react?ref=roadmapsh", + "type": "article" + } + ] + }, + "-b4LfjCjkSZ6ZsSv3eFm6": { + "title": "React Native Testing Library", + "description": "React Native Testing Library (RNTL) is a collection of tools and utilities to test React Native components. It is built on top of the Testing Library ecosystem, designed to work seamlessly with Jest and other testing frameworks. Its primary goal is to enable efficient and effective testing by providing simple and intuitive APIs that promote best practices, like testing UI components in isolation and promoting accessibility checks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "React Native Testing Library", + "url": "https://callstack.github.io/react-native-testing-library/", + "type": "article" + }, + { + "title": "React Native Testing Library (Docs)", + "url": "https://testing-library.com/docs/react-native-testing-library/intro/", + "type": "article" + }, + { + "title": "Explore top posts about React", + "url": "https://app.daily.dev/tags/react?ref=roadmapsh", + "type": "article" + } + ] + }, + "3m7ANLJvtx3zie4y86MNU": { + "title": "Detox", + "description": "Detox is an end-to-end testing framework for React Native applications. It enables you to run tests on an actual device or in a simulator/emulator environment. The goal of Detox is to maintain a high level of confidence in your application's behavior while allowing for quick test runs and easy debugging.\n\nLearn more from the following links:", + "links": [ + { + "title": "Detox Documentation", + "url": "https://wix.github.io/Detox/", + "type": "article" + } + ] + }, + "spTzJMS7cE0cNa7tVQhVQ": { + "title": "Appium", + "description": "Appium is an open-source test automation framework for mobile devices, targeting native, hybrid, or mobile-web apps for iOS, Android, and Windows platforms. Appium works with multiple programming languages, including JavaScript, Ruby, Python, Java, and C#. Appium uses the WebDriver protocol, which allows you to write tests that can interact with your app through a series of commands. The WebDriver protocol interprets these commands into actions that are then performed on the app.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Appium Documentation", + "url": "https://appium.io/docs/en/latest/", + "type": "article" + } + ] + }, + "NIJzKzWlsciAjxUpm4K2v": { + "title": "Performance", + "description": "Performance is a crucial aspect of any application, and React Native is no exception. Optimizing performance in your React Native apps will not only lead to a better user experience but also lessen the load on device resources.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Performance", + "url": "https://reactnative.dev/docs/performance", + "type": "article" + } + ] + }, + "1U3AiCDWEVEKsofWtqavi": { + "title": "Understand Frame Rates", + "description": "Frame rates represent the number of frames (or images) displayed per second in an animation or video. The performance of a React Native application can be highly impacted by the frame rate, so it is important to optimize your application for the best possible user experience. Higher frame rates provide smoother animations, but may require more system resources. To achieve the desired frame rate, the application should ensure that each frame is computed and rendered within the time budget.\n\nTo achieve high frame rates and smooth animations, developers can utilize the `Animated` library, which offers methods and components for efficient animation management. For instance, the library allows for declarative animation definitions, minimizes unnecessary render cycles, and enables the use of the native driver to offload animations from the JavaScript thread. By adhering to best practices and leveraging the `Animated` library, developers can enhance their React Native applications' performance and deliver high-quality animations.", + "links": [] + }, + "afwB90L-q2hIwrA0LtWbG": { + "title": "Common Problem Sources", + "description": "In React Native, several common issues can impact application performance. Excessive console logs can slow down the app, particularly in debug mode, so it's advisable to minimize their use and remove unnecessary logs before release. Heavy and unoptimized images can also cause performance problems; therefore, it's important to optimize image size and resolution and use the `resizeMode` prop on the `Image` component for better rendering. Additionally, inline functions and styles can lead to unnecessary re-renders, so defining them outside the component's render method is recommended. While using `React.PureComponent` or `React.memo()` can enhance performance, they should be applied judiciously to avoid unnecessary re-renders. For handling large lists, replacing `ListView` with `FlatList` or `SectionList` is crucial for better performance. Lastly, blocking the JavaScript thread with heavy synchronous computations can degrade performance, so it's essential to handle such tasks asynchronously or offload them to native modules. Following these guidelines can help maintain optimal performance in React Native applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Performance Problems", + "url": "https://reactnative.dev/docs/performance#common-sources-of-performance-problems", + "type": "article" + } + ] + }, + "LL2ZkB7BuELyY2mPQhkAj": { + "title": "Speeding up Builds", + "description": "Building your React Native app could be expensive and take several minutes of developers time. This can be problematic as your project grows and generally in bigger organizations with multiple React Native developers.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Speeding up your Build phase", + "url": "https://reactnative.dev/docs/build-speed", + "type": "article" + } + ] + }, + "PyPjHnKIWpnFHal8RuSmX": { + "title": "Optimizing Flatlist Config", + "description": "In React Native, the FlatList component is essential for efficiently displaying large lists of items, and optimizing its configuration is crucial for enhancing performance. Here are key tips for optimizing FlatList:\n\n1. **Set `windowSize`**: Adjust the `windowSize` prop, which determines the number of pages rendered above and below the current view. Reducing this value from the default of 21 can decrease off-screen component rendering.\n \n2. **Enable `removeClippedSubviews`**: This prop unmounts components that are off-screen, helping to free up resources.\n \n3. **Adjust `maxToRenderPerBatch`**: Control the number of items rendered per batch with this prop, which defaults to 10. Tailor this value to fit your list's needs.\n \n4. **Set `initialNumToRender`**: This prop defines how many items to render initially, helping to prevent blank screens during loading.\n \n5. **Use `getItemLayout`**: By specifying the exact dimensions of each item with this prop, you can avoid dynamic measurements, leading to better performance.\n \n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Optimizing Flatlist Configuration", + "url": "https://reactnative.dev/docs/optimizing-flatlist-configuration", + "type": "article" + } + ] + }, + "u5I-EOnA_yt6AQsRX-qr0": { + "title": "RAM Bundles + Inline Requires", + "description": "If you have a large app you may want to consider the Random Access Modules (RAM) bundle format, and using inline requires. This is useful for apps that have a large number of screens which may not ever be opened during a typical usage of the app. Generally it is useful to apps that have large amounts of code that are not needed for a while after startup. For instance the app includes complicated profile screens or lesser used features, but most sessions only involve visiting the main screen of the app for updates. We can optimize the loading of the bundle by using the RAM format and requiring those features and screens inline (when they are actually used).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "RAM Bundles and Inline Requires", + "url": "https://reactnative.dev/docs/ram-bundles-inline-requires", + "type": "article" + } + ] + }, + "apXv-E6LvOuOMj3EpzwuA": { + "title": "Profiling", + "description": "Use the built-in profiler to get detailed information about work done in the JavaScript thread and main thread side-by-side. Access it by selecting Perf Monitor from the Debug menu.\n\nFor iOS, Instruments is an invaluable tool, and on Android you should learn to use `systrace`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Profiling React Native", + "url": "https://reactnative.dev/docs/profiling", + "type": "article" + } + ] + }, + "0BMpZDc-1rSvETwX82zON": { + "title": "Using Native Modules", + "description": "Sometimes a React Native app needs to access a native platform API that is not available by default in JavaScript, for example the native APIs to access Apple or Google Pay. Maybe you want to reuse some existing Objective-C, Swift, Java or C++ libraries without having to reimplement it in JavaScript, or write some high performance, multi-threaded code for things like image processing.\n\nThe NativeModule system exposes instances of Java/Objective-C/C++ (native) classes to JavaScript (JS) as JS objects, thereby allowing you to execute arbitrary native code from within JS. While we don't expect this feature to be part of the usual development process, it is essential that it exists. If React Native doesn't export a native API that your JS app needs you should be able to export it yourself!\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Native Modules Introduction", + "url": "https://reactnative.dev/docs/native-platform", + "type": "article" + } + ] + }, + "b-1-JcwLSGMyH3gXS59lY": { + "title": "For iOS", + "description": "iOS native modules in React Native allow developers to tap into the rich ecosystem of iOS features and functionalities that are not directly accessible through the standard React Native APIs. For instance, a Camera module can be implemented using the AVFoundation framework, enabling developers to capture photos and videos directly from their applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "iOS Native Modules", + "url": "https://reactnative.dev/docs/legacy/native-modules-ios", + "type": "article" + }, + { + "title": "Explore top posts about iOS", + "url": "https://app.daily.dev/tags/ios?ref=roadmapsh", + "type": "article" + } + ] + }, + "wMxTB8WgU6e-oYMtQFCDY": { + "title": "For Android", + "description": "Native modules in React Native provide a powerful way to access device-specific features and capabilities that are not available through the standard React Native APIs. For example, a Bluetooth module can be created using the Android Bluetooth API, allowing applications to scan for nearby Bluetooth devices, connect to them, and transfer data.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android Native Modules", + "url": "https://reactnative.dev/docs/legacy/native-modules-android", + "type": "article" + }, + { + "title": "Explore top posts about Android", + "url": "https://app.daily.dev/tags/android?ref=roadmapsh", + "type": "article" + } + ] + }, + "4U-HZQGH7kaWCB94Xy8Mh": { + "title": "Publishing Apps", + "description": "Publishing React Native apps is the process of deploying your application on various app stores so that users can download and use your app. The two most popular app stores for publishing are the Apple App Store (iOS) and the Google Play Store (Android).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Publishing to Apple App Store", + "url": "https://reactnative.dev/docs/publishing-to-app-store", + "type": "article" + }, + { + "title": "Publishing to Google Play Store", + "url": "https://reactnative.dev/docs/signed-apk-android", + "type": "article" + } + ] + }, + "1s9Y1dUtjpW9pu74ipX99": { + "title": "Apple App store", + "description": "The App Store is Apple's official platform for distributing iOS apps to users with iPhones, iPads, and iPod Touch devices. To publish an app on the App Store, you need to follow specific guidelines and use the necessary tools provided by Apple.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Publishing to Apple App Store", + "url": "https://reactnative.dev/docs/publishing-to-app-store", + "type": "article" + }, + { + "title": "Explore top posts about App Store", + "url": "https://app.daily.dev/tags/app-store?ref=roadmapsh", + "type": "article" + } + ] + }, + "D8T9cZ5zKi_KZDr9tDpCf": { + "title": "Google Play Store", + "description": "Publishing your React Native app on Google Store consists of several steps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Publishing to Google Play Store", + "url": "https://reactnative.dev/docs/signed-apk-android", + "type": "article" + }, + { + "title": "Explore top posts about Google", + "url": "https://app.daily.dev/tags/google?ref=roadmapsh", + "type": "article" + } + ] + } +} \ No newline at end of file diff --git a/public/roadmap-content/rust.json b/public/roadmap-content/rust.json index d85893480..b7a567832 100644 --- a/public/roadmap-content/rust.json +++ b/public/roadmap-content/rust.json @@ -1,7 +1,7 @@ { "4U-HZQGH7kaWCB94Xy8Mh": { "title": "Introduction", - "description": "Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance.", + "description": "Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance.\n\nVisit the following resources to learn more:", "links": [ { "title": "Rust Book", @@ -14,13 +14,13 @@ "type": "opensource" }, { - "title": "Rust by Example", - "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", + "title": "Rust Programming Language", + "url": "https://www.rust-lang.org/", "type": "article" }, { - "title": "Official Website", - "url": "https://www.rust-lang.org/", + "title": "Rust by Example", + "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", "type": "article" } ] @@ -30,13 +30,23 @@ "description": "Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Explore top posts about Rust", - "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", + "title": "Rust? What is it?", + "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", "type": "article" }, { - "title": "Rust by example", - "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", + "title": "Rust Programming Language", + "url": "https://www.rust-lang.org/", + "type": "article" + }, + { + "title": "What is Rust and why is it so popular?", + "url": "https://stackoverflow.blog/2020/01/20/what-is-rust-and-why-is-it-so-popular/", + "type": "article" + }, + { + "title": "Explore top posts about Rust", + "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", "type": "article" }, { @@ -48,13 +58,28 @@ }, "VhSEH_RoWFt1z2lial7xZ": { "title": "Why use Rust?", - "description": "Rust is a system programming language that aims to provide memory safety, concurrency, and performance with a focus on zero cost abstractions. It was originally created by Graydon Hoare at Mozilla Research, with contributions from Brendan Eich, the creator of JavaScript. Rust is appreciated for the solutions it provides to common programming language issues. Its emphasis on safety, speed, and support for concurrent programming, as well as its robust type system, are just a few reasons why developers choose Rust.", + "description": "Rust is a system programming language that aims to provide memory safety, concurrency, and performance with a focus on zero cost abstractions. It was originally created by Graydon Hoare at Mozilla Research, with contributions from Brendan Eich, the creator of JavaScript. Rust is appreciated for the solutions it provides to common programming language issues. Its emphasis on safety, speed, and support for concurrent programming, as well as its robust type system, are just a few reasons why developers choose Rust.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Rust? What is it?", + "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", + "type": "article" + }, + { + "title": "Rust Programming Language", + "url": "https://www.rust-lang.org/", + "type": "article" + }, { "title": "Explore top posts about Rust", "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", "type": "article" }, + { + "title": "What is Rust?", + "url": "https://www.youtube.com/watch?v=R33h77nrMqc", + "type": "video" + }, { "title": "Convince your boss to use Rust", "url": "https://www.youtube.com/playlist?list=PLZaoyhMXgBzqkaLKR8HHWZaASMvW4gRtZ", @@ -69,36 +94,125 @@ }, "-IqA02ObYvXPW1ot6t_b9": { "title": "Installing Rust and Cargo", - "description": "To install Rust, navigate to the official website at [https://www.rust-lang.org](https://www.rust-lang.org) and download the appropriate installation file (or run the appropriate terminal command) for your operating system. You'll be installing `rustup`, which is the preferred tool for installing, updating, and managing your core Rust tooling. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with an '.exe' installer which you need to execute. Further instructions can be found on the download page of the website.\n\nKeep in mind that for the compiler to create executables, you'll also need a linker on your operating system, such as 'GCC'. Otherwise, you'll encounter errors when you try to run `rustc` or `cargo`. This is one necessary thing that `rustup` doesn't install for you. Such linker components are part of the C standard library, so they may or may not be partially or fully preinstalled on your system. For example, a common error when running `rustc` for the first time in a 64-bit Linux environment is that your system is missing 32-bit support for GCC, which can be solved by installing `gcc-multilib`.\n\nYou can update your Rust version at any time by running `rustup update` in the terminal.", - "links": [] + "description": "To install Rust, navigate to the rust official website and download the appropriate installation file (or run the appropriate terminal command) for your operating system. You'll be installing `rustup`, which is the preferred tool for installing, updating, and managing your core Rust tooling. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with an '.exe' installer which you need to execute. Further instructions can be found on the download page of the website.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Programming Language", + "url": "https://www.rust-lang.org", + "type": "article" + }, + { + "title": "Install Rust", + "url": "https://www.rust-lang.org/tools/install", + "type": "article" + }, + { + "title": "Installation - The Rust Programming Language", + "url": "https://doc.rust-lang.org/book/ch01-01-installation.html", + "type": "article" + } + ] }, "oyP1ZyOgDC4nYEQXHwdVQ": { "title": "IDEs and Rust Toolchains", - "description": "For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. [Visual Studio Code](https://code.visualstudio.com) is highly preferred among Rust developers due to its support for Rust via the \"Rust Language Server\" or \"rust-analyzer\" plugins. Another popular choice is [RustRover](https://www.jetbrains.com/rust/), a dedicated IDE for Rust development by JetBrains. Additionally, [Sublime Text](https://www.sublimetext.com) and [Atom](https://atom.io) with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, [Vim](https://www.vim.org) and [Emacs](https://www.gnu.org/software/emacs/) are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and debugging tools which prove useful for Rust programming.", - "links": [] + "description": "For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. Visual Studio Code is highly preferred among Rust developers due to its support for Rust via the \"Rust Language Server\" or \"rust-analyzer\" plugins. Another popular choice is RustRover, a dedicated IDE for Rust development by JetBrains. Additionally, Sublime Text and Atom with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, Vim and Emacs are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and debugging tools which prove useful for Rust programming.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Visual Studio Code", + "url": "https://code.visualstudio.com", + "type": "article" + }, + { + "title": "RustRover", + "url": "https://www.jetbrains.com/rust/", + "type": "article" + }, + { + "title": "Vim", + "url": "https://www.vim.org", + "type": "article" + }, + { + "title": "Emacs", + "url": "https://www.gnu.org/software/emacs/", + "type": "article" + }, + { + "title": "Atom", + "url": "https://atom.io", + "type": "article" + }, + { + "title": "Sublime Text", + "url": "https://www.sublimetext.com", + "type": "article" + } + ] }, "eYCNYtwXBjZwcPUe7QYZ-": { "title": "Rust REPL (Rust Playground)", - "description": "`Rust REPL` (Read-Eval-Print-Loop) is an interactive shell in which you can write and test Rust snippets in real-time. Unlike running a program normally in Rust where you have to manually compile and then run the program, REPL automatically evaluates your inputs, and the result is returned immediately after execution. This is helpful when experimenting with Rust code, learning the language, and debugging. REPL isn't built into Rust directly, but is available via third-party tools such as `evcxr_repl`.", - "links": [] + "description": "`Rust REPL` (Read-Eval-Print-Loop) is an interactive shell in which you can write and test Rust snippets in real-time. Unlike running a program normally in Rust where you have to manually compile and then run the program, REPL automatically evaluates your inputs, and the result is returned immediately after execution. This is helpful when experimenting with Rust code, learning the language, and debugging. REPL isn't built into Rust directly, but is available via third-party tools such as `evcxr_repl`.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Playground", + "url": "https://play.rust-lang.org/", + "type": "article" + }, + { + "title": "Debugging Rust apps with GDB", + "url": "https://blog.logrocket.com/debugging-rust-apps-with-gdb/", + "type": "article" + }, + { + "title": "Debugging Rust with rust-lldb", + "url": "https://dev.to/bmatcuk/debugging-rust-with-rust-lldb-j1f", + "type": "article" + }, + { + "title": "Interactive Rust in a REPL and Jupyter Notebook", + "url": "https://depth-first.com/articles/2020/09/21/interactive-rust-in-a-repl-and-jupyter-notebook-with-evcxr/", + "type": "article" + } + ] }, "6E4pGifNfSAq6SbzfzFNT": { "title": "Language Basics", - "description": "Rust language basics cover fundamental programming concepts including syntax and semantics, variables and data types, control flow (loops and conditionals), and functions. These elements form the foundation for writing effective Rust code and understanding how to structure and reuse code segments.", - "links": [] + "description": "Rust language basics cover fundamental programming concepts including syntax and semantics, variables and data types, control flow (loops and conditionals), and functions. These elements form the foundation for writing effective Rust code and understanding how to structure and reuse code segments.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Introduction - Rust By Example", + "url": "https://doc.rust-lang.org/stable/rust-by-example/", + "type": "article" + }, + { + "title": "How to Learn Rust in 2025: A Complete Beginner's Guide", + "url": "https://blog.jetbrains.com/rust/2024/09/20/how-to-learn-rust/", + "type": "article" + }, + { + "title": "Explore top posts about Rust", + "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", + "type": "article" + } + ] }, "Gw5E21W5zis-RUIgNSEV2": { "title": "Variables, DataTypes and Constants", - "description": "In Rust, variables are declared using the `let` keyword. All variables are immutable by default, which means once a value is bound to a variable, it cannot be changed. If you want to make a variable mutable, the `mut` keyword is used. So, if you wanted to declare a mutable variable `x` and assign it the value `5`, you would write `let mut x = 5;`. Variables can also be patterned. By default in Rust, variables are block-scoped. Rust also supports several types of variable attributes.\n\nLearn more from the following links:", + "description": "In Rust, variables are declared using the `let` keyword. All variables are immutable by default, which means once a value is bound to a variable, it cannot be changed. If you want to make a variable mutable, the `mut` keyword is used. So, if you wanted to declare a mutable variable `x` and assign it the value `5`, you would write `let mut x = 5;`. Variables can also be patterned. By default in Rust, variables are block-scoped. Rust also supports several types of variable attributes.\n\nVisit the following resources to learn more:", "links": [ { "title": "Variables and Mutability", - "url": "https://rust-book.cs.brown.edu/ch03-01-variables-and-mutability.html", + "url": "https://doc.rust-lang.org/book/ch03-01-variables-and-mutability.html", "type": "article" }, { "title": "Data Types", - "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html", + "url": "https://doc.rust-lang.org/book/ch03-02-data-types.html", + "type": "article" + }, + { + "title": "Constants", + "url": "https://doc.rust-lang.org/rust-by-example/custom_types/constants.html", "type": "article" } ] @@ -109,38 +223,58 @@ "links": [ { "title": "Control Flow", - "url": "https://rust-book.cs.brown.edu/ch03-05-control-flow.html", + "url": "https://doc.rust-lang.org/book/ch03-05-control-flow.html", "type": "article" }, { "title": "Concise Control Flow with if let", "url": "https://rust-book.cs.brown.edu/ch06-03-if-let.html", "type": "article" + }, + { + "title": "Mastering Control Flow in Rust", + "url": "https://dev.to/iamdipankarpaul/mastering-control-flow-in-rust-36fd", + "type": "article" } ] }, "5hKJaMKpeFEUi3S1Hpiyk": { "title": "Functions and Method Syntax", - "description": "In Rust, functions are declared using the `fn` keyword. Each function can take a set of input variables with their specified types, and may return data of a specified type. The body of a function is contained within curly braces `{}`. Unlike other languages, in Rust, you don't need to end the last statement in a block with a semicolon; omitting the last semicolon of a block in this way turns the last statement into an expression, and the result of this expression becomes the implicit return value of the block. In other words, if we want to return a value, we simply write the expression we want to return.\n\nAn example of a function that returns implicitly in Rust is `fn add(one: i32, two: i32) -> i32 { one + two }`, where `one` and `two` are parameters of type `i32`. This function returns an integer of type `i32`, which is the result of `one + two`. Rust also has an explicit `return` keyword to exit a function with a given value, like so: `fn add(one: i32, two: i32) -> i32 { return one + two; }`. Using a `return` statement versus the implicit return syntax is mostly a matter of preference.\n\nLearn more from the following links:", + "description": "In Rust, functions are declared using the `fn` keyword. Each function can take a set of input variables with their specified types, and may return data of a specified type. The body of a function is contained within curly braces `{}`. Unlike other languages, in Rust, you don't need to end the last statement in a block with a semicolon; omitting the last semicolon of a block in this way turns the last statement into an expression, and the result of this expression becomes the implicit return value of the block.\n\nVisit the following resources to learn more:", "links": [ { "title": "Functions", - "url": "https://rust-book.cs.brown.edu/ch03-03-how-functions-work.html", + "url": "https://doc.rust-lang.org/book/ch03-03-how-functions-work.html", + "type": "article" + }, + { + "title": "Rust Functions Explained with Examples", + "url": "https://boxoflearn.com/rust-functions-complete-guide/", "type": "article" } ] }, "yqp3UePmSlGyOYpxITis4": { "title": "Pattern Matching & Destructuring", - "description": "In Rust, \"pattern matching\" is a robust tool that allows you to destructure data types and perform conditional checks in a succinct and clear way. The main structures used for pattern matching are `match` and `if let`. The `match` keyword can be used to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The `if let` structure allows you to combine `if` and `let` into a less verbose way of handling values that match one specific pattern, rather than a series of patterns. It's basically a nice syntax sugar over a `match` statement.\n\nLearn more from the following links:", + "description": "In Rust, \"pattern matching\" is a robust tool that allows you to destructure data types and perform conditional checks in a succinct and clear way. The main structures used for pattern matching are `match` and `if let`. The `match` keyword can be used to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The `if let` structure allows you to combine `if` and `let` into a less verbose way of handling values that match one specific pattern, rather than a series of patterns. It's basically a nice syntax sugar over a `match` statement.\n\nVisit the following resources to learn more:", "links": [ { - "title": "The match Control Flow Construct", - "url": "https://rust-book.cs.brown.edu/ch06-02-match.html", + "title": "Patterns and Matching", + "url": "https://doc.rust-lang.org/book/ch19-00-patterns.html", "type": "article" }, { - "title": "Concise Control Flow with if let", + "title": "Destructuring", + "url": "https://doc.rust-lang.org/rust-by-example/flow_control/match/destructuring.html", + "type": "article" + }, + { + "title": "Matching", + "url": "https://doc.rust-lang.org/rust-by-example/flow_control/match.html", + "type": "article" + }, + { + "title": "Control Flow with if let", "url": "https://rust-book.cs.brown.edu/ch06-03-if-let.html", "type": "article" } @@ -148,52 +282,92 @@ }, "FswpjWqqt8-BzUTsDDjel": { "title": "Enums", - "description": "An enum, short for enumeration, is a custom data type that allows you to define a type by enumerating (listing out one-by-one) all of its possible variants. In Rust, if something is one of a given set of possibilities (e.g., `Rock` or `Paper` or `Scissors`), it's probably appropriate to represent that data with an enum, like so: `enum RpsChoice { Rock, Paper, Scissors }`.\n\nAn instance of an `enum` can be one and only one of the enum's declared variants at any given time. Unlike enumerations in some other languages, variants in Rust are not restricted to a singular data type. When you define an `enum`, you can decide for each of its possible variants whether or not that variant will hold additional embedded data; each variant of the enum is also allowed to hold data of completely different types and amounts. You can even embed structs and other enums in a variant, making enums incredibly versatile.\n\nEnums in Rust are one way to enable simple pattern matching for a value, which allows you to compare the interior structure of a value to a series of patterns using a `match` block. For example, you can execute different branches of code based on whether an `RpsChoice` value is `Rock`, `Paper`, or `Scissors` without a verbose tree of `if`/`else` blocks. You can also handle whatever data might be embedded within that instance of the enum variant, as you will do frequently with Rust's standard `Option` and `Result` enums.\n\nLearn more from the following links:", + "description": "An enum, short for enumeration, is a custom data type that allows you to define a type by enumerating (listing out one-by-one) all of its possible variants. In Rust, if something is one of a given set of possibilities (e.g., `Rock` or `Paper` or `Scissors`), it's probably appropriate to represent that data with an enum, like so: `enum RpsChoice { Rock, Paper, Scissors }`.\n\nAn instance of an `enum` can be one and only one of the enum's declared variants at any given time. Unlike enumerations in some other languages, variants in Rust are not restricted to a singular data type. When you define an `enum`, you can decide for each of its possible variants whether or not that variant will hold additional embedded data; each variant of the enum is also allowed to hold data of completely different types and amounts.\n\nLearn more from the following resources:", "links": [ { "title": "Defining an Enum", - "url": "https://rust-book.cs.brown.edu/ch06-01-defining-an-enum.html", + "url": "https://doc.rust-lang.org/book/ch06-01-defining-an-enum.html", + "type": "article" + }, + { + "title": "Understanding and Implementing Enums in Rust", + "url": "https://towardsdev.com/understanding-and-implementing-enums-in-rust-6eae37b6b5e3", "type": "article" } ] }, "Mi9mQ-8gyDPd8Mbu1zuHt": { "title": "Structs", - "description": "In Rust, a struct is a custom data type used for grouping related values together into one entity. Structs are similar to classes in other programming languages. Essentially, each `struct` creates a new type that we can use to streamline complex data handling.\n\nThere are three types of `struct` in Rust: classic 'C' structs, tuple structs, and unit structs.\n\n* **Classic 'C' structs** are named-field structs and are the most commonly used.\n* **Tuple structs**, while not being common, are useful when you want to couple together just a few data points that don't need field names.\n* **Unit structs** are useful in situations where you want to implement a **trait** on some type, but don't have any data that you want to store in the type itself.\n\nLearn more from the following links:", + "description": "In Rust, a struct is a custom data type used for grouping related values together into one entity. Structs are similar to classes in other programming languages. Essentially, each `struct` creates a new type that we can use to streamline complex data handling.\n\nVisit the following resources to learn more:", "links": [ { "title": "Defining and Instantiating Structs", - "url": "https://rust-book.cs.brown.edu/ch05-01-defining-structs.html", + "url": "https://doc.rust-lang.org/book/ch05-01-defining-structs.html", + "type": "article" + }, + { + "title": "Understanding Structs in Rust: A Complete Guide with Examples", + "url": "https://medium.com/@er.pwndhull07/understanding-structs-in-rust-a-complete-guide-with-examples-621bf9753b88", "type": "article" } ] }, "SJMuIEuHp8X6nfLb0k0TU": { "title": "Traits", - "description": "Traits in Rust define behaviors that are shared among different data types. Implementing traits for data types is a great way to group method signatures together and define a set of behaviors your types require. Essentially, anything with a certain `trait` applied to it will \"inherit\" the behavior of that trait's methods, but this is not the same thing as inheritance found in object-oriented programming languages.\n\nTraits are abstract; it's not possible to create instances of traits. However, we can define pointers of trait types, and these can hold any data type that implements the `trait`. A `trait` is **implemented** for something else with the syntax `impl TraitAbc for Xyz {...}`, which can be a concrete type or another trait.\n\nYou should read carefully about traits in Rust and understand how some common traits, like `Copy`, are already implemented for various primitive types and how this could affect your program.\n\nLearn more from the following links:", + "description": "Traits in Rust define behaviors that are shared among different data types. Implementing traits for data types is a great way to group method signatures together and define a set of behaviors your types require. Essentially, anything with a certain `trait` applied to it will \"inherit\" the behavior of that trait's methods, but this is not the same thing as inheritance found in object-oriented programming languages.\n\nTraits are abstract; it's not possible to create instances of traits. However, we can define pointers of trait types, and these can hold any data type that implements the `trait`. A `trait` is **implemented** for something else with the syntax `impl TraitAbc for Xyz {...}`, which can be a concrete type or another trait.\n\nVisit the following resources to learn more:", "links": [ { "title": "Traits: Defining Shared Behaviour", "url": "https://doc.rust-lang.org/book/ch10-02-traits.html", "type": "article" + }, + { + "title": "Understanding Traits and Trait Bounds in Rust", + "url": "https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649", + "type": "article" } ] }, "HzWHDQZjA9OgVZEWrmhKf": { "title": "Impl Blocks", - "description": "Impl blocks use the `impl` keyword, and are used to **implement** behavior in the form of **methods** for a `struct`, `enum`, or `trait`. If you want your data type or trait to have methods, you need a corresponding `impl` block containing functions for the type or trait.\n\nNote that `self` and `Self` have different meanings in the context of an `impl` block's functions. `self` represents the specific value in your program that's calling the method and passing itself as an argument, while `Self` is syntax sugar for the `impl` block's data type, which is commonly used in constructor methods that return a new instance of the type.\n\nLearn more from the following links:", + "description": "Impl blocks use the `impl` keyword, and are used to **implement** behavior in the form of **methods** for a `struct`, `enum`, or `trait`. If you want your data type or trait to have methods, you need a corresponding `impl` block containing functions for the type or trait.\n\nNote that `self` and `Self` have different meanings in the context of an `impl` block's functions. `self` represents the specific value in your program that's calling the method and passing itself as an argument, while `Self` is syntax sugar for the `impl` block's data type, which is commonly used in constructor methods that return a new instance of the type.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Keyword impl", + "url": "https://doc.rust-lang.org/std/keyword.impl.html", + "type": "article" + }, { "title": "Method Syntax", "url": "https://rust-book.cs.brown.edu/ch05-03-method-syntax.html", "type": "article" + }, + { + "title": "Rust: Understanding Structs and impl Blocks with 10 Examples", + "url": "https://medium.com/@TechSavvyScribe/rust-understanding-structs-and-impl-blocks-with-10-examples-20371f90b1ed", + "type": "article" } ] }, "FHZSxSiOZYNBEz6tu8wuF": { "title": "Integers", - "description": "In Rust, integers are a primitive data type that hold whole number values, both positive and negative. Integer types in Rust can be divided into signed and unsigned ones:\n\n* Signed integers, denoted by \"i\", are those that can hold negative, zero, and positive values.\n* Unsigned integers, denoted by \"u\", only hold zero and positive values.\n\nEach denotation is followed by a number which represents the number of bits they occupy in memory. The available integer types are:\n\nType\n\nMinimum\n\nMaximum\n\ni8\n\n\\-(2^7)\n\n(2^7)-1\n\ni16\n\n\\-(2^15)\n\n(2^15)-1\n\ni32\n\n\\-(2^31)\n\n(2^31)-1\n\ni64\n\n\\-(2^63)\n\n(2^63)-1\n\ni128\n\n\\-(2^127)\n\n(2^127)-1)\n\nisize\n\n\\-(2^31) or -(2^63)\n\n(2^31)-1 or (2^63)-1\n\nThe unsigned integer types consist of:\n\nType\n\nMinimum\n\nMaximum\n\nu8\n\n0\n\n(2^8)-1\n\nu16\n\n0\n\n(2^16)-1\n\nu32\n\n0\n\n(2^32)-1\n\nu64\n\n0\n\n(2^64)-1\n\nu128\n\n0\n\n(2^128)-1\n\nusize\n\n0\n\n(2^32)-1 or (2^64)-1\n\nIn these types, the number after \"i\" or \"u\" denotes the size of the integer type in bits.\n\nThere's also the `isize` and `usize` integer types. The sizes of these primitive are taken from the computer architecture (32/64 bits). When one of these types is declared, the compiler calculates, so to speak, how many bytes it takes to reference any location in memory. For example, on a 32-bit target, this is 4 bytes, and on a 64-bit target, this is 8 bytes.\n\n* [@article@Integer Data Type in Rust](https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types)\n \n* [@article@Rust Data Types (With Examples)](https://www.programiz.com/rust/data-types#integer-type)\n \n* [@article@Machine-dependent Integer Types](https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types)\n \n\nLearn more from the following links:", + "description": "In Rust, integers are a primitive data type that hold whole number values, both positive and negative. Integer types in Rust can be divided into signed and unsigned ones:\n\n* Signed integers, denoted by \"i\", are those that can hold negative, zero, and positive values.\n* Unsigned integers, denoted by \"u\", only hold zero and positive values.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Integer Data Type in Rust", + "url": "https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types", + "type": "article" + }, + { + "title": "Machine-dependent Integer Types", + "url": "https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types", + "type": "article" + }, + { + "title": "Rust Data Types (With Examples)", + "url": "https://www.programiz.com/rust/data-types#integer-type", + "type": "article" + }, { "title": "Integer Types", "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#integer-types", @@ -206,13 +380,13 @@ "description": "Rust's `bool` primitive type represents truth values with two possible states: `true` or `false`. Booleans are used in conditional statements and logical operations like `&&` (AND), `||` (OR), and `!` (NOT). When cast to integers, `true` becomes `1` and `false` becomes `0`. Example: `let is_active: bool = true;`\n\nLearn more from the following links:", "links": [ { - "title": "The Boolean Type", - "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-boolean-type", + "title": "bool", + "url": "https://doc.rust-lang.org/std/primitive.bool.html", "type": "article" }, { - "title": "bool - Rust", - "url": "https://doc.rust-lang.org/std/primitive.bool.html", + "title": "The Boolean Type", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-boolean-type", "type": "article" }, { @@ -224,10 +398,10 @@ }, "rNHHp1GgmRnKIYlZayi59": { "title": "Floats", - "description": "In Rust, `floats` are a primitive data types used to represent floating-point numbers. They are defined as numerical values with fractional components. Floating-point numbers are represented according to the IEEE-754 standard.\n\nRust supports two types of floating-point numbers: `f32` and `f64`. These are 32-bit and 64-bit in size, respectively.\n\n* `f32` (_binary32_ type defined in IEEE-754-2008) is a single-precision float, which means is less precise than `f64` type.\n* `f64` (_binary64_ type defined in IEEE-754-2008) has double precision. The default type is `f64` because on modern CPUs it’s roughly the same speed as `f32` but allows more precision.\n\nBoth `f32` and `f64` represent negative, zero and positive floating-point values.\n\nLearn more from the following links:", + "description": "In Rust, `floats` are a primitive data types used to represent floating-point numbers. They are defined as numerical values with fractional components. Floating-point numbers are represented according to the IEEE-754 standard.\n\nRust supports two types of floating-point numbers: `f32` and `f64`. These are 32-bit and 64-bit in size, respectively.\n\n* `f32` (_binary32_ type defined in IEEE-754-2008) is a single-precision float, which means is less precise than `f64` type.\n* `f64` (_binary64_ type defined in IEEE-754-2008) has double precision. The default type is `f64` because on modern CPUs it’s roughly the same speed as `f32` but allows more precision.\n\nBoth `f32` and `f64` represent negative, zero and positive floating-point values.\n\nVisit the following resources to learn more:", "links": [ { - "title": "f32 - Rust", + "title": "f32", "url": "https://doc.rust-lang.org/std/primitive.f32.html", "type": "article" }, @@ -279,7 +453,7 @@ "description": "Tuples are fixed-size collections that can hold elements of different types. Access elements using dot notation with zero-based indexing: `tuple.0`, `tuple.1`, etc. Example: `let data: (i32, f64, char) = (42, 3.14, 'x');`. Useful for grouping related values of different types and multiple variable assignments.\n\nLearn more from the following links:", "links": [ { - "title": "Tuple - Rust", + "title": "Tuple", "url": "https://doc.rust-lang.org/std/primitive.tuple.html", "type": "article" }, @@ -297,20 +471,20 @@ }, "Hu1jf46OpX44nam_UvYqc": { "title": "String", - "description": "Rust's `String` is a growable, mutable, UTF-8 encoded string type stored on the heap. Unlike string slices (`&str`), `String` owns its data and can be modified. Create with `String::from(\"text\")` or `\"text\".to_string()`. Common operations include `push_str()`, `push()`, and concatenation with `+` or `format!()` macro.\n\nLearn more from the following links:", + "description": "Rust's `String` is a growable, mutable, UTF-8 encoded string type stored on the heap. Unlike string slices (`&str`), `String` owns its data and can be modified. Create with `String::from(\"text\")` or `\"text\".to_string()`. Common operations include `push_str()`, `push()`, and concatenation with `+` or `format!()` macro.\n\nVisit the following resources to learn more:", "links": [ { - "title": "String in std::string - Rust", + "title": "String", "url": "https://doc.rust-lang.org/std/string/struct.String.html", "type": "article" }, { - "title": "str - Rust", + "title": "str", "url": "https://doc.rust-lang.org/std/primitive.str.html", "type": "article" }, { - "title": "What Is a String?", + "title": "What as a String?", "url": "https://doc.rust-lang.org/book/ch08-02-strings.html?highlight=String#what-is-a-string", "type": "article" }, @@ -331,7 +505,7 @@ "description": "Arrays are fixed-size collections of elements of the same type stored consecutively in memory. Size must be known at compile time and cannot change. Syntax: `let arr: [type; size] = [elements];`. Example: `let nums: [i32; 3] = [1, 2, 3];`. Access elements with zero-based indexing: `arr[0]`.\n\nLearn more from the following links:", "links": [ { - "title": "Rust - array", + "title": "Array", "url": "https://doc.rust-lang.org/std/primitive.array.html", "type": "article" }, @@ -357,7 +531,7 @@ "description": "`HashMap` stores key-value pairs using hashing for fast lookups, insertions, and removals. Keys must be unique; duplicate keys replace old values. Rust uses cryptographically strong hashing for security. Items are unordered. Example: `HashMap::new()` or `HashMap::from([(\"key\", \"value\")])`.\n\nLearn more from the following links:", "links": [ { - "title": "HashMap in std::collections - Rust", + "title": "HashMap in std::collections", "url": "https://doc.rust-lang.org/std/collections/struct.HashMap.html", "type": "article" }, @@ -380,10 +554,10 @@ }, "PskCueCc9pSxfnSzfdX-u": { "title": "Vector", - "description": "`Vec` is Rust's growable, heap-allocated array that stores elements of the same type contiguously. Unlike arrays, vectors can resize at runtime. Key methods include `push()` to add elements, `pop()` to remove the last element, and `len()` for size. Example: `let mut v = vec![1, 2, 3];`\n\nLearn more from the following links:", + "description": "`Vec` is Rust's growable, heap-allocated array that stores elements of the same type contiguously. Unlike arrays, vectors can resize at runtime. Key methods include `push()` to add elements, `pop()` to remove the last element, and `len()` for size. Example: `let mut v = vec![1, 2, 3];`\n\nVisit the following resources to learn more:", "links": [ { - "title": "Vec in std::vec - Rust", + "title": "Vector", "url": "https://doc.rust-lang.org/std/vec/struct.Vec.html", "type": "article" }, @@ -398,7 +572,7 @@ "type": "article" }, { - "title": "Rust: Vectors", + "title": "Rust Vectors", "url": "https://www.youtube.com/watch?v=nOKOFYzvvHo&t=97s&pp=ygUMcnVzdCB2ZWN0b3Jz", "type": "video" }, @@ -414,7 +588,7 @@ "description": "`HashSet` is a collection of unique elements using hash-based storage for fast lookups, insertions, and deletions. No duplicates are allowed and elements are unordered. Provides methods like `insert()`, `contains()`, and `remove()`. Example: `let mut set = HashSet::new(); set.insert(\"value\");`\n\nLearn more from the following links:", "links": [ { - "title": "HashSet in std::collections - Rust", + "title": "HashSet in std::collections", "url": "https://doc.rust-lang.org/std/collections/struct.HashSet.html", "type": "article" }, @@ -432,35 +606,55 @@ }, "iR0ewc2yURqS7bfMWfoBi": { "title": "LinkedList", - "description": "`LinkedList` is a doubly-linked list where each node contains a value and pointers to both next and previous nodes. Provides O(1) insertion/removal at both ends but O(n) indexing. Generally slower than `Vec` and rarely needed; `VecDeque` is usually preferred for queue operations.\n\nLearn more from the following links:", + "description": "`LinkedList` is a doubly-linked list where each node contains a value and pointers to both next and previous nodes. Provides O(1) insertion/removal at both ends but O(n) indexing. Generally slower than `Vec` and rarely needed; `VecDeque` is usually preferred for queue operations.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "LinkedList in std::collections", + "url": "https://doc.rust-lang.org/std/collections/struct.LinkedList.html", + "type": "article" + }, { "title": "Too Many Linked Lists", "url": "https://rust-unofficial.github.io/too-many-lists/", - "type": "opensource" - }, - { - "title": "LinkedList in std::collections - Rust", - "url": "https://doc.rust-lang.org/std/collections/struct.LinkedList.html", "type": "article" } ] }, "B-S1hE-ofNTutnkc2hJBf": { "title": "Stack", - "description": "Stack is a LIFO (Last-In-First-Out) data structure where elements are added and removed from the same end. In Rust, the call stack manages function calls, with each call pushing a frame and returns popping it. Stack memory is fast but limited in size, with stack overflow occurring when exceeded.\n\nLearn more from the following links:", + "description": "Stack is a LIFO (Last-In-First-Out) data structure where elements are added and removed from the same end. In Rust, the call stack manages function calls, with each call pushing a frame and returns popping it. Stack memory is fast but limited in size, with stack overflow occurring when exceeded.\n\nVisit the following resources to learn more:", "links": [ { "title": "Box, Stack and Heap", "url": "https://doc.rust-lang.org/rust-by-example/std/box.html", "type": "article" + }, + { + "title": "std::collections", + "url": "https://doc.rust-lang.org/std/collections/index.html", + "type": "article" + }, + { + "title": "Getting Started with SQLx and SQLite in Rust", + "url": "https://medium.com/rustaceans/getting-started-with-sqlx-and-sqlite-in-rust-895ae7fc01ae", + "type": "article" } ] }, "fq2NMV-QV9ayJl82ZWzov": { "title": "Queue", - "description": "Queue follows FIFO (First-In-First-Out) ordering where elements are added at one end and removed from the other. Rust doesn't have a built-in queue, but `VecDeque` provides queue functionality with `push_back()` for adding and `pop_front()` for removing elements efficiently.\n\nLearn more from the following links:", + "description": "Queue follows FIFO (First-In-First-Out) ordering where elements are added at one end and removed from the other. Rust doesn't have a built-in queue, but `VecDeque` provides queue functionality with `push_back()` for adding and `pop_front()` for removing elements efficiently.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "VecDeque in std::collections", + "url": "https://doc.rust-lang.org/std/collections/struct.VecDeque.html", + "type": "article" + }, + { + "title": "Working with Queues in Rust", + "url": "https://basillica.medium.com/working-with-queues-in-rust-5a5afe82da46", + "type": "article" + }, { "title": "Queues", "url": "https://docs.rs/queues/latest/queues/", @@ -476,13 +670,33 @@ "title": "BinaryHeap", "url": "https://doc.rust-lang.org/std/collections/struct.BinaryHeap.html", "type": "article" + }, + { + "title": "The Rust Guide - BinaryHeap", + "url": "https://rust-guide.com/en/documentation/collections/BinaryHeap", + "type": "article" + }, + { + "title": "Comprehensive Guide to BinaryHeap in Rust", + "url": "https://www.gyata.ai/rust/binaryheap", + "type": "article" } ] }, "2UQ3AuGkDbT0-54l0rOGM": { "title": "Ownsership Rules & Memory Safety", - "description": "Rust's ownership has three key rules: each value has exactly one owner, only one owner exists at a time, and values are dropped when owners go out of scope. This prevents data races, ensures memory safety without garbage collection, and eliminates common bugs like use-after-free and memory leaks.\n\nLearn more from the following links:", + "description": "Rust's ownership has three key rules: each value has exactly one owner, only one owner exists at a time, and values are dropped when owners go out of scope. This prevents data races, ensures memory safety without garbage collection, and eliminates common bugs like use-after-free and memory leaks.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "What is Ownership?", + "url": "https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html", + "type": "article" + }, + { + "title": "Rust Ownership & Borrowing - Memory Safety Without Garbage", + "url": "https://webreference.com/rust/ownership/", + "type": "article" + }, { "title": "What Is Ownership?", "url": "https://rust-book.cs.brown.edu/ch04-01-what-is-ownership.html", @@ -496,20 +710,35 @@ "links": [ { "title": "References and Borrowing", - "url": "https://rust-book.cs.brown.edu/ch04-02-references-and-borrowing.html", + "url": "https://doc.rust-lang.org/book/ch04-02-references-and-borrowing.html", "type": "article" }, { "title": "The Slice Type", "url": "https://rust-book.cs.brown.edu/ch04-04-slices.html", "type": "article" + }, + { + "title": "Borrowing and References in Rust", + "url": "https://codeforgeek.com/borrowing-and-references-in-rust/", + "type": "article" } ] }, "UdXq0H8599cDTKXaIlPqt": { "title": "Deep Dive: Stack vs Heap", - "description": "Stack memory stores fixed-size data with automatic allocation/deallocation following LIFO order - fast but limited. Heap memory stores dynamic-size data with manual management - slower but flexible. Rust's ownership system ensures memory safety across both, with stack being default and heap accessed via smart pointers.\n\nLearn more from the following links:", + "description": "Stack memory stores fixed-size data with automatic allocation/deallocation following LIFO order - fast but limited. Heap memory stores dynamic-size data with manual management - slower but flexible. Rust's ownership system ensures memory safety across both, with stack being default and heap accessed via smart pointers.\n\nLearn more from the following resources:", "links": [ + { + "title": "Box, Stack and Heap", + "url": "https://doc.rust-lang.org/rust-by-example/std/box.html", + "type": "article" + }, + { + "title": "Memory Management in Rust: Stack vs. Heap", + "url": "https://dev.to/iamdipankarpaul/memory-management-in-rust-stack-vs-heap-3m45", + "type": "article" + }, { "title": "The Stack and the Heap", "url": "https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/the-stack-and-the-heap.html", @@ -546,8 +775,13 @@ }, "U9Bd-GO0QwYVLvESR4PTb": { "title": "RC", - "description": "`Rc` (Reference Counting) enables multiple owners of the same heap-allocated data in single-threaded contexts. It tracks the number of references and automatically deallocates data when the count reaches zero. Use `Rc::clone()` to create additional references without deep copying data.\n\nLearn more from the following links:", + "description": "`Rc` (Reference Counting) enables multiple owners of the same heap-allocated data in single-threaded contexts. It tracks the number of references and automatically deallocates data when the count reaches zero. Use `Rc::clone()` to create additional references without deep copying data.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Rc in std::rc", + "url": "https://doc.rust-lang.org/std/rc/struct.Rc.html", + "type": "article" + }, { "title": "rct - The Reference Counted Smart Pointer", "url": "https://doc.rust-lang.org/book/ch15-04-rc.html#rct-the-reference-counted-smart-pointer", @@ -560,7 +794,12 @@ "description": "`Arc` (Atomic Reference Counting) is a thread-safe smart pointer for sharing immutable data across multiple threads. It uses atomic operations to track reference counts, allowing multiple ownership of heap-allocated data. When the reference count reaches zero, the data is automatically cleaned up.\n\nLearn more from the following links:", "links": [ { - "title": "Arc", + "title": "Arc in std::sync", + "url": "https://doc.rust-lang.org/std/sync/struct.Arc.html", + "type": "article" + }, + { + "title": "Arc in Rust Lang", "url": "https://doc.rust-lang.org/rust-by-example/std/arc.html", "type": "article" } @@ -568,23 +807,38 @@ }, "GbbeV3r27IBEKHyiyLqs6": { "title": "Mutex", - "description": "`Mutex` (Mutual Exclusion) protects shared data from concurrent access by multiple threads. Only one thread can access the protected data at a time through `lock()`. Rust automatically unlocks mutexes when they go out of scope and handles panics to prevent deadlocks.\n\nLearn more from the following links:", + "description": "`Mutex` (Mutual Exclusion) protects shared data from concurrent access by multiple threads. Only one thread can access the protected data at a time through `lock()`. Rust automatically unlocks mutexes when they go out of scope and handles panics to prevent deadlocks.\n\nVisit the following resources to learn more:", "links": [ { "title": "Mutex", "url": "https://doc.rust-lang.org/std/sync/struct.Mutex.html", "type": "article" + }, + { + "title": "Rust Mutex: From Basics to Advanced Techniques", + "url": "https://medium.com/@TechSavvyScribe/rust-mutex-from-basics-to-advanced-techniques-56e1f1389d9b", + "type": "article" + }, + { + "title": "Rust Concurrency Made Easy: A Guide to Arc and Mutex", + "url": "https://www.ruststepbystep.com/rust-concurrency-made-easy-a-guide-to-arc-and-mutex/", + "type": "article" } ] }, "WzGl4DkANjUu7VC1AIWI-": { "title": "RwLock", - "description": "`RwLock` (Read-Write Lock) allows multiple concurrent readers OR one exclusive writer, unlike Mutex which allows only one accessor. Use `read()` for shared access and `write()` for exclusive access. Ideal for read-heavy workloads where data is frequently read but rarely modified.\n\nLearn more from the following links:", + "description": "`RwLock` (Read-Write Lock) allows multiple concurrent readers OR one exclusive writer, unlike Mutex which allows only one accessor. Use `read()` for shared access and `write()` for exclusive access. Ideal for read-heavy workloads where data is frequently read but rarely modified.\n\nVisit the following resources to learn more:", "links": [ { "title": "RwLock", "url": "https://doc.rust-lang.org/std/sync/struct.RwLock.html", "type": "article" + }, + { + "title": "Rust Read-Write Locks: Managing Concurrent Read and Write Access", + "url": "https://medium.com/@TechSavvyScribe/rust-read-write-locks-managing-concurrent-read-and-write-access-a6ab689bbed3", + "type": "article" } ] }, @@ -596,25 +850,41 @@ "title": "Channels", "url": "https://doc.rust-lang.org/rust-by-example/std_misc/channels.html", "type": "article" + }, + { + "title": "Using Channels in Rust: Why and When?", + "url": "https://howtorust.com/using-channels-in-rust-why-and-when/", + "type": "article" } ] }, "X2gB0m-ZKSC4TJyIcwsMx": { "title": "Error Handling", - "description": "Rust handles errors through `Result` for operations that may fail and `Option` for values that may be absent. `Result` has `Ok(T)` for success and `Err(E)` for errors, while `Option` has `Some(T)` and `None`. Pattern matching and the `?` operator enable elegant error handling and propagation. Rust doesn't use exceptions, eliminating many common error-handling problems.", - "links": [] + "description": "Rust handles errors through `Result` for operations that may fail and `Option` for values that may be absent. `Result` has `Ok(T)` for success and `Err(E)` for errors, while `Option` has `Some(T)` and `None`. Pattern matching and the `?` operator enable elegant error handling and propagation. Rust doesn't use exceptions, eliminating many common error-handling problems.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Error Handling", + "url": "https://doc.rust-lang.org/book/ch09-00-error-handling.html", + "type": "article" + }, + { + "title": "How to Handle Errors in Rust", + "url": "https://dev.to/nathan20/how-to-handle-errors-in-rust-a-comprehensive-guide-1cco", + "type": "article" + } + ] }, "wQHkBydWsiGEOZMdKmz40": { "title": "Option and Result Enumerations", "description": "`Option` handles nullable values with `Some(T)` and `None` variants, replacing null pointers safely. `Result` manages error handling with `Ok(T)` for success and `Err(E)` for failures. Both enums enable safe error handling through pattern matching and method chaining.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust by Example: Option & unwrap", + "title": "Option & unwrap", "url": "https://doc.rust-lang.org/rust-by-example/error/option_unwrap.html", "type": "article" }, { - "title": "Rust by Example: Result", + "title": "Result", "url": "https://doc.rust-lang.org/rust-by-example/error/result.html", "type": "article" } @@ -625,9 +895,14 @@ "description": "The `?` operator provides concise error propagation in functions returning `Result` or `Option`. It automatically unwraps `Ok`/`Some` values or early-returns `Err`/`None` to the caller. This eliminates verbose `match` expressions and enables clean, readable error handling patterns.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Book: Recoverable Errors with Result", + "title": "Recoverable Errors with Result", "url": "https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html", "type": "article" + }, + { + "title": "Understanding Result, Option, and '?' Operators in Rust", + "url": "https://howtorust.com/understanding-result-option-and-operators-in-rust/", + "type": "article" } ] }, @@ -636,7 +911,7 @@ "description": "Custom error types use `enum` to define specific error variants with attached data. Implement `Debug`, `Display`, and optionally `std::error::Error` traits for proper error handling integration. Libraries like `thiserror` provide derive macros to simplify custom error creation and formatting.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust by Example: Defining an error type", + "title": "Defining an Error Type", "url": "https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html", "type": "article" } @@ -647,9 +922,19 @@ "description": "Modules provide namespacing and encapsulation within a crate, organizing code with `mod` keyword and controlling visibility with `pub`. Crates are compilation units (binaries or libraries) that can depend on other crates. The module system organizes code within crates, while crates enable sharing functionality between projects.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Book: Managing Growing Projects with Packages, Crates, and Modules", + "title": "Crates", + "url": "https://doc.rust-lang.org/rust-by-example/crates.html", + "type": "article" + }, + { + "title": "Managing Growing Projects with Packages, Crates, and Modules", "url": "https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html", "type": "article" + }, + { + "title": "How It Works: Rust's Module System Finally Explained", + "url": "https://confidence.sh/blog/rust-module-system-explained/", + "type": "article" } ] }, @@ -658,12 +943,12 @@ "description": "Rust organizes code through modules (`mod`) for grouping related functionality and crates (binary/library projects). Modules provide namespacing and can be nested. Crates are compilation units with a root file (`main.rs` or `lib.rs`) forming the module tree for libraries or executables.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust by Example: Modules", + "title": "Modules", "url": "https://doc.rust-lang.org/rust-by-example/mod.html", "type": "article" }, { - "title": "The Rust Reference: Namespaces", + "title": "Namespaces", "url": "https://doc.rust-lang.org/reference/names/namespaces.html", "type": "article" }, @@ -679,13 +964,13 @@ "description": "Cargo manages Rust projects and dependencies through `Cargo.toml` files. Dependencies are listed in `[dependencies]` sections with crate names and semantic version specifications. Cargo automatically downloads, builds, and manages external libraries (crates) from [crates.io](http://crates.io) or other sources.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Blog: Cargo", - "url": "https://blog.rust-lang.org/2016/05/05/cargo-pillars.html", + "title": "Dependencies", + "url": "https://doc.rust-lang.org/rust-by-example/cargo/deps.html", "type": "article" }, { - "title": "Rust by Example: Dependencies", - "url": "https://doc.rust-lang.org/rust-by-example/cargo/deps.html", + "title": "Cargo", + "url": "https://blog.rust-lang.org/2016/05/05/cargo-pillars.html", "type": "article" } ] @@ -695,21 +980,57 @@ "description": "Publishing Rust crates involves creating an account on [crates.io](http://crates.io), preparing proper `Cargo.toml` metadata, and using `cargo publish`. Once published, versions cannot be deleted or overwritten, ensuring dependency stability. The registry serves as Rust's central package repository for sharing libraries.\n\nVisit the following resources to learn more:", "links": [ { - "title": "The Cargo Book: Publishing on crates.io", + "title": "The Cargo Book: Publishing", "url": "https://doc.rust-lang.org/cargo/reference/publishing.html", "type": "article" + }, + { + "title": "From Zero to Hero: Your First Rust Crate", + "url": "https://medium.com/rust-programming-language/from-zero-to-hero-your-first-rust-crate-6f2c084df464", + "type": "article" } ] }, "pehYc_xLrs6BFUbcpPTiJ": { "title": "Concurrency & Parallelism", - "description": "Concurrency allows tasks to run in overlapping time periods (interleaved execution), while parallelism executes multiple tasks simultaneously on different cores. Rust provides safe concurrency primitives like channels, mutexes, and atomic operations without data races, enforced at compile time.", - "links": [] + "description": "Concurrency allows tasks to run in overlapping time periods (interleaved execution), while parallelism executes multiple tasks simultaneously on different cores. Rust provides safe concurrency primitives like channels, mutexes, and atomic operations without data races, enforced at compile time.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fearless Concurrency", + "url": "https://doc.rust-lang.org/book/ch16-00-concurrency.html", + "type": "article" + }, + { + "title": "Rust Concurrency and Parallelism", + "url": "https://rustlang.app/article/Rust_concurrency_and_parallelism.html", + "type": "article" + }, + { + "title": "Concurrency and Parallelism in Rust", + "url": "https://sterlingcobb.medium.com/concurrency-and-parallelism-in-rust-an-overview-and-examples-bd811f5a5afe", + "type": "article" + } + ] }, "pJN260pWQVO0gHxi1-_3U": { "title": "Threads, Channels and Message Passing", - "description": "Rust provides native threading with `std::thread::spawn()` and `join()` for 1:1 OS thread mapping. Channels enable safe message passing between threads, avoiding shared state issues. This model promotes concurrent programming without data races through Rust's ownership system.\n\nLearn more from the following links:", + "description": "Rust provides native threading with `std::thread::spawn()` and `join()` for 1:1 OS thread mapping. Channels enable safe message passing between threads, avoiding shared state issues. This model promotes concurrent programming without data races through Rust's ownership system.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "std::thread", + "url": "https://doc.rust-lang.org/std/thread/", + "type": "article" + }, + { + "title": "Using Message Passing to Transfer Data Between Threads", + "url": "https://doc.rust-lang.org/book/ch16-02-message-passing.html", + "type": "article" + }, + { + "title": "Understanding Threads in Rust: A Comprehensive Guide", + "url": "https://blog.stackademic.com/understanding-threads-in-rust-a-comprehensive-guide-7e2d23fb85b0", + "type": "article" + }, { "title": "Rust Atomics and Locks - Low-Level Concurrency in Practice", "url": "https://marabos.nl/atomics/", @@ -719,27 +1040,48 @@ }, "n1Epl_nBuoXW2OE0IKYVR": { "title": "Atomic Operations & Memory Barriers", - "description": "Atomic operations provide lock-free concurrency through uninterruptible operations like `load`, `store`, `swap`, and `compare_and_swap`. These low-level primitives enable thread-safe data sharing without locks, forming the foundation for higher-level concurrent abstractions and non-blocking data structures.\n\nLearn more from the following links:", + "description": "Atomic operations provide lock-free concurrency through uninterruptible operations like `load`, `store`, `swap`, and `compare_and_swap`. These low-level primitives enable thread-safe data sharing without locks, forming the foundation for higher-level concurrent abstractions and non-blocking data structures.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Atomics and Locks - Low-Level Concurrency in Practice", - "url": "https://marabos.nl/atomics/", + "title": "fence in std::sync::atomic", + "url": "https://doc.rust-lang.org/std/sync/atomic/fn.fence.html", + "type": "article" + }, + { + "title": "Atomic Operations and Memory Barriers", + "url": "https://medium.com/@murataslan1/atomic-operations-and-memory-barriers-43ee6f60ead5", "type": "article" } ] }, "kVfBbsOHoixvqb4dYTG3Q": { "title": "Futures and Async/Await Paradigm", - "description": "Futures represent asynchronous computations that produce values or errors eventually. The `async/await` syntax provides ergonomic programming over futures, allowing asynchronous code to look synchronous. Futures are lazy and must be polled to make progress, forming the foundation of Rust's async ecosystem.", - "links": [] + "description": "Futures represent asynchronous computations that produce values or errors eventually. The `async/await` syntax provides ergonomic programming over futures, allowing asynchronous code to look synchronous. Futures are lazy and must be polled to make progress, forming the foundation of Rust's async ecosystem.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fundamentals of Asynchronous Programming", + "url": "https://doc.rust-lang.org/book/ch17-00-async-await.html", + "type": "article" + }, + { + "title": "Async/Await in Rust: A Beginner's Guide", + "url": "https://leapcell.medium.com/async-await-in-rust-a-beginners-guide-8752d2c2abbf", + "type": "article" + } + ] }, "08qKtgnhJ3tlb5JKfTDf5": { "title": "Testing", "description": "Rust has built-in testing support through `cargo test` and the `#[test]` attribute. Test functions use assertion macros like `assert!`, `assert_eq!`, and `assert_ne!` to verify expected behavior. Organize tests with unit tests, integration tests, and documentation tests for comprehensive coverage.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Book: Writing Automated Tests", - "url": "https://doc.rust-lang.org/book/ch11-00-testing.html", + "title": "Writing Automated Tests", + "url": "https://doc.rust-lang.org/book/ch11-01-writing-tests.html", + "type": "article" + }, + { + "title": "Testing in Rust: A Quick Guide to Unit Tests", + "url": "https://dev.to/tramposo/testing-in-rust-a-quick-guide-to-unit-tests-integration-tests-and-benchmarks-2bah", "type": "article" }, { @@ -748,7 +1090,7 @@ "type": "article" }, { - "title": "YouTube", + "title": "Mocking and Testing Rust", "url": "https://www.youtube.com/watch?v=8XaVlL3lObQ", "type": "video" } @@ -759,14 +1101,24 @@ "description": "Unit tests verify individual functions using `#[test]` and live alongside code. Integration tests are in separate files/directories and test component interactions. Rust provides `cargo test` to run both types, supporting test organization for comprehensive code verification and quality assurance.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Book: How to Write Tests", + "title": "Unit Testing", + "url": "https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html", + "type": "article" + }, + { + "title": "How to Write Tests", "url": "https://doc.rust-lang.org/book/ch11-01-writing-tests.html", "type": "article" }, { - "title": "Rust by Example: Unit testing", - "url": "https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html", + "title": "Testing in Rust: A Quick Guide to Unit Tests", + "url": "https://dev.to/tramposo/testing-in-rust-a-quick-guide-to-unit-tests-integration-tests-and-benchmarks-2bah", "type": "article" + }, + { + "title": "Mocking and Testing Rust", + "url": "https://www.youtube.com/watch?v=8XaVlL3lObQ", + "type": "video" } ] }, @@ -789,6 +1141,11 @@ "url": "https://docs.rs/mockall_double/latest/mockall_double/", "type": "article" }, + { + "title": "Mocking in Rust: Mockall and alternatives", + "url": "https://blog.logrocket.com/mocking-rust-mockall-alternatives/", + "type": "article" + }, { "title": "Explore top posts about Testing", "url": "https://app.daily.dev/tags/testing?ref=roadmapsh", @@ -801,7 +1158,7 @@ "description": "Traits define shared behavior that types can implement, while generics enable code reuse with type parameters. Together, they provide trait bounds (`T: Display`) to constrain generic types, ensuring they have required functionality. This enables safe, zero-cost polymorphism and code abstraction.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Book: Generic Types, Traits, and Lifetimes", + "title": "Generic Types, Traits, and Lifetimes", "url": "https://doc.rust-lang.org/book/ch10-00-generics.html", "type": "article" } @@ -812,30 +1169,51 @@ "description": "Traits define shared behavior as a set of method signatures that types can implement. Define with `trait Name { fn method(&self); }` and implement with `impl TraitName for Type`. Traits enable polymorphism, code reuse, and abstraction while maintaining type safety and zero-cost performance.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust by Example: Traits", + "title": "Traits", "url": "https://doc.rust-lang.org/rust-by-example/trait.html", "type": "article" + }, + { + "title": "Understanding Traits and Trait Bounds in Rust", + "url": "https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649", + "type": "article" } ] }, "pRDgDtRIVpNM2CdhSOS3Q": { "title": "Trait Bounds and Associated Types", - "description": "Trait bounds constrain generics by requiring types to implement specific traits (`T: Display`). Associated types define type placeholders within traits that implementors must specify. Together, they enable flexible generic programming with type safety and improved API design patterns.", - "links": [] + "description": "Trait bounds constrain generics by requiring types to implement specific traits (`T: Display`). Associated types define type placeholders within traits that implementors must specify. Together, they enable flexible generic programming with type safety and improved API design patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Trait and Lifetime Bounds", + "url": "https://doc.rust-lang.org/reference/trait-bounds.html", + "type": "article" + }, + { + "title": "Understanding Traits and Trait Bounds in Rust", + "url": "https://leapcell.medium.com/understanding-traits-and-trait-bounds-in-rust-d575f19dd649", + "type": "article" + } + ] }, "_hxwo_iAdOwlWBltv7i6i": { "title": "Generics & Type-Level Programming", "description": "Advanced generics in Rust include `where` clauses for complex bounds, `?Sized` for unsized types, associated types, and higher-kinded types. These enable sophisticated type-level programming, allowing precise control over generic constraints and enabling powerful abstractions while maintaining zero-cost performance.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Book: Generics", - "url": "https://doc.rust-lang.org/book/ch10-01-syntax.html", + "title": "Generic Types, Traits, and Lifetimes", + "url": "https://doc.rust-lang.org/book/ch10-00-generics.html", "type": "article" }, { - "title": "Rust by Example: Generics", + "title": "Generics", "url": "https://doc.rust-lang.org/rust-by-example/generics.html", "type": "article" + }, + { + "title": "Generics Data Type", + "url": "https://doc.rust-lang.org/book/ch10-01-syntax.html", + "type": "article" } ] }, @@ -843,6 +1221,16 @@ "title": "Lifetimes & Borrow Checker", "description": "Lifetimes define how long references remain valid, preventing dangling references and memory safety issues. The borrow checker enforces these rules at compile time. Lifetime annotations use syntax like `'a` to specify relationships between references in function signatures when the compiler can't infer them automatically.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Lifetimes", + "url": "https://doc.rust-lang.org/rust-by-example/scope/lifetime.html", + "type": "article" + }, + { + "title": "Mastering Lifetimes in Rust: Memory Safety and Borrow Checking", + "url": "https://leapcell.medium.com/mastering-lifetimes-in-rust-memory-safety-and-borrow-checking-4a8c082a54ee", + "type": "article" + }, { "title": "Crust of Rust: Lifetime Annotations", "url": "https://youtu.be/rAl-9HwD858", @@ -852,36 +1240,90 @@ }, "R5HIVS-lyCp9b46aXqx2m": { "title": "Explicit Lifetime Annotations", - "description": "Explicit lifetime annotations use syntax like `'a` to specify relationships between reference lifetimes in function signatures. Required when the compiler can't infer lifetimes automatically. Example: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str` ensures all references live equally long.", - "links": [] + "description": "Explicit lifetime annotations use syntax like `'a` to specify relationships between reference lifetimes in function signatures. Required when the compiler can't infer lifetimes automatically. Example: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str` ensures all references live equally long.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Explicit Annotation", + "url": "https://doc.rust-lang.org/rust-by-example/scope/lifetime/explicit.html", + "type": "article" + }, + { + "title": "What are Lifetimes in Rust? Explained with Code Examples", + "url": "https://www.freecodecamp.org/news/what-are-lifetimes-in-rust-explained-with-code-examples/", + "type": "article" + } + ] }, "qJI8GObmsxyc_tTtUEOAd": { "title": "Lifetime Elision Rules", - "description": "Lifetime elision allows the compiler to infer lifetimes in common patterns, reducing explicit annotations. Rules: each reference parameter gets its own lifetime, single input lifetime applies to all outputs, methods with `&self` propagate its lifetime to outputs. Simplifies code while maintaining safety.", - "links": [] + "description": "Lifetime elision allows the compiler to infer lifetimes in common patterns, reducing explicit annotations. Rules: each reference parameter gets its own lifetime, single input lifetime applies to all outputs, methods with `&self` propagate its lifetime to outputs. Simplifies code while maintaining safety.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Lifetime Elision", + "url": "https://doc.rust-lang.org/reference/lifetime-elision.html", + "type": "article" + }, + { + "title": "Understanding Lifetime Elision in Rust", + "url": "https://masteringbackend.com/posts/understanding-lifetime-elision-in-rust", + "type": "article" + } + ] }, "7yVvMnvCvLbFa51pESx0j": { "title": "Covariant & Contravariant Lifetimes", - "description": "Variance describes how subtyping relationships change when types are nested. Covariant types preserve ordering (`&'long T` is subtype of `&'short T`), contravariant reverses it, invariant requires exact matches. Affects how lifetimes work with references, boxes, and function parameters.", - "links": [] + "description": "Variance describes how subtyping relationships change when types are nested. Covariant types preserve ordering (`&'long T` is subtype of `&'short T`), contravariant reverses it, invariant requires exact matches. Affects how lifetimes work with references, boxes, and function parameters.\n\nLearn more from the following links:", + "links": [ + { + "title": "Subtyping and Variance", + "url": "https://doc.rust-lang.org/nomicon/subtyping.html", + "type": "article" + }, + { + "title": "Demystifying Covariant and Contravariant Lifetimes in Rust", + "url": "https://medium.com/@murataslan1/demystifying-covariant-and-contravariant-lifetimes-in-rust-76051484fe1c", + "type": "article" + } + ] }, "eTpZXd8E2jVBmk_aSLZYV": { "title": "Macros & Metaprogramming", - "description": "Macros are code that writes code, enabling metaprogramming in Rust. Declarative macros use `macro_rules!` for pattern-based code generation, while procedural macros provide custom derives and function-like macros. They're expanded at compile time, offering zero-cost abstractions.", - "links": [] + "description": "Macros are code that writes code, enabling metaprogramming in Rust. Declarative macros use `macro_rules!` for pattern-based code generation, while procedural macros provide custom derives and function-like macros. They're expanded at compile time, offering zero-cost abstractions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Macros", + "url": "https://doc.rust-lang.org/book/ch20-05-macros.html", + "type": "article" + }, + { + "title": "macro_rules!", + "url": "https://doc.rust-lang.org/rust-by-example/macros.html", + "type": "article" + }, + { + "title": "Macros in Rust: A Tutorial with Examples", + "url": "https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/", + "type": "article" + }, + { + "title": "Metaprogramming Magic in Rust: The Complete Guide", + "url": "https://elitedev.in/rust/metaprogramming-magic-in-rust-the-complete-guide-/", + "type": "article" + } + ] }, "AXWXXsww7Xkl3BYgtThNe": { "title": "Declarative Macros with macro_rules!", "description": "Declarative macros use `macro_rules!` for pattern-based code generation at compile time. They match syntax patterns and expand into replacement code, enabling code reuse without runtime overhead. More limited than procedural macros but simpler to write and understand.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust Book: Macros", - "url": "https://doc.rust-lang.org/book/ch19-06-macros.html", + "title": "Macros", + "url": "https://doc.rust-lang.org/book/ch20-05-macros.html", "type": "article" }, { - "title": "Macros by Example", - "url": "https://doc.rust-lang.org/reference/macros-by-example.html", + "title": "Macros in Rust: A Tutorial with Examples", + "url": "https://blog.logrocket.com/macros-in-rust-a-tutorial-with-examples/", "type": "article" } ] @@ -894,6 +1336,11 @@ "title": "Procedural Macros", "url": "https://doc.rust-lang.org/reference/procedural-macros.html", "type": "article" + }, + { + "title": "Understanding Procedural Macros and Custom Derive", + "url": "https://www.gyata.ai/rust/procedural-macros-and-custom-derive", + "type": "article" } ] }, @@ -902,70 +1349,170 @@ "description": "DSLs are specialized programming languages for specific domains. Rust macros enable creating DSLs by manipulating syntax trees and defining custom syntax patterns. This allows extending Rust's language capabilities for specialized applications like game development, configuration, or domain-specific tasks.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rust by Example: Domain Specific Languages (DSLs)", + "title": "Domain Specific Languages (DSLs)", "url": "https://doc.rust-lang.org/rust-by-example/macros/dsl.html", "type": "article" + }, + { + "title": "Crafting Expressive Tools: Domain-Specific Languages (DSLs)", + "url": "https://medium.com/@murataslan1/crafting-expressive-tools-domain-specific-languages-dsls-in-rust-94394debe12b", + "type": "article" } ] }, "KomYBYxj0FTrJDYB3nU5B": { "title": "Web Development", - "description": "Rust offers excellent web development capabilities with frameworks like Actix, Rocket, Axum, and Warp. These provide HTTP handling, routing, middleware, and database integration. Rust's performance and safety make it ideal for high-performance web services, APIs, and microservices.", - "links": [] + "description": "Rust offers excellent web development capabilities with frameworks like Actix, Rocket, Axum, and Warp. These provide HTTP handling, routing, middleware, and database integration. Rust's performance and safety make it ideal for high-performance web services, APIs, and microservices.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rocket - Simple, Fast, Type-Safe Web Framework for Rust", + "url": "https://rocket.rs/", + "type": "article" + }, + { + "title": "Rust for Web Development: A Beginner's Guide", + "url": "https://medium.com/@enravishjeni411/rust-for-web-development-a-beginners-guide-fcc994e5c090", + "type": "article" + }, + { + "title": "How to Write Your First Rust Web App with Rocket and RustRover", + "url": "https://blog.jetbrains.com/rust/2024/02/28/how-to-write-your-first-rust-web-app-with-rocket-and-rustrover/", + "type": "article" + } + ] }, "duQ1RO1lqq793mfb5w31P": { "title": "Axum", - "description": "Axum is a modern, ergonomic web framework built on hyper and designed for async Rust. It features excellent type safety, powerful extractors, middleware support, and seamless Tokio integration. Axum emphasizes developer experience while maintaining high performance for web services and APIs.\n\nVisit the following resources to learn more:\n\n[@official@Axum Documentation](https://docs.rs/axum/latest/axum/)", - "links": [] + "description": "Axum is a modern, ergonomic web framework built on hyper and designed for async Rust. It features excellent type safety, powerful extractors, middleware support, and seamless Tokio integration. Axum emphasizes developer experience while maintaining high performance for web services and APIs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Axum Documentation", + "url": "https://docs.rs/axum/latest/axum/", + "type": "article" + }, + { + "title": "Getting Started with Axum - Rust's Most Popular Web Framework", + "url": "https://www.shuttle.dev/blog/2023/12/06/using-axum-rust", + "type": "article" + } + ] }, "3Y90v2ysoMcyjDL24H7mC": { "title": "Actix", "description": "Actix is a high-performance, pragmatic web framework for Rust built on the actor model. It features powerful middleware, WebSocket support, and excellent performance benchmarks. Actix provides a flexible, feature-rich API for building web applications, APIs, and microservices with minimal boilerplate.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Actix", + "title": "Actix - Actor framework for Rust", "url": "https://actix.rs/", "type": "article" + }, + { + "title": "Actix Documentation", + "url": "https://docs.rs/actix/latest/actix/", + "type": "article" + }, + { + "title": "Building a Clean API in Rust with Actix Web", + "url": "https://medium.com/@anto18671/building-a-clean-api-in-rust-with-actix-web-a-comprehensive-guide-d084e368a988", + "type": "article" } ] }, "n5t3MUqmvrcr36VIIOw0u": { "title": "Leptos", - "description": "", - "links": [] + "description": "Leptos is a rust based web framework that lets you build reactive UIs with Rust and WebAssembly. It supports SSR and CSR, fine-grained reactivity, and a rich ecosystem of libraries and tools. Leptos lets you build web applications with client-side rendering, server-side rendering, or hydration.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "leptos-rs/leptos: Build fast web applications with Rust", + "url": "https://github.com/leptos-rs/leptos", + "type": "opensource" + }, + { + "title": "Home - Leptos", + "url": "https://www.leptos.dev/", + "type": "article" + }, + { + "title": "Introduction - Leptos Documentation", + "url": "https://book.leptos.dev/", + "type": "article" + } + ] }, "GnSBtZoN9mAehRf5Eczng": { "title": "Loco", - "description": "", - "links": [] + "description": "Loco is a web framework for Rust that is inspired by Ruby on Rails, designed to help developers build MVC-style applications easily. It emphasizes simplicity, rapid development, and integrates features like ORM, background jobs, and templating engines for a productive coding experience.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Loco.rs - Productivity-first Rust Fullstack Web Framework", + "url": "https://loco.rs/", + "type": "article" + }, + { + "title": "The Loco Guide - Loco.rs", + "url": "https://loco.rs/docs/getting-started/guide/", + "type": "article" + }, + { + "title": "Getting Started with Loco in Rust", + "url": "https://www.shuttle.dev/blog/2023/12/28/using-loco-rust-rails", + "type": "article" + } + ] }, "ApjwY_70OGG_dNIC85oBD": { "title": "Rocket", "description": "Rocket is a web framework for Rust emphasizing ease of use, expressiveness, and type safety. It features code generation via procedural macros, built-in templating, request guards, and comprehensive error handling. Rocket prioritizes developer productivity with intuitive APIs and detailed error messages.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Rocket", + "title": "Rocket - Simple, Fast, Type-Safe Web Framework for Rust", "url": "https://rocket.rs/", "type": "article" + }, + { + "title": "Getting Started with Rocket in Rust", + "url": "https://www.shuttle.dev/blog/2023/12/13/using-rocket-rust", + "type": "article" } ] }, "yu0f5gALho0e8wzV10yow": { "title": "Asynchronous Programming", - "description": "Async programming in Rust allows executing tasks concurrently rather than sequentially, enabling efficient resource usage especially in IO-heavy applications. Rust provides `async` and `await` keywords: `async` marks functions that can return `Future` values, while `await` pauses and resumes async functions. Popular async runtimes like Tokio and async-std manage task execution efficiently.", - "links": [] + "description": "Async programming in Rust allows executing tasks concurrently rather than sequentially, enabling efficient resource usage especially in IO-heavy applications. Rust provides `async` and `await` keywords: `async` marks functions that can return `Future` values, while `await` pauses and resumes async functions. Popular async runtimes like Tokio and async-std manage task execution efficiently.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fundamentals of Asynchronous Programming", + "url": "https://doc.rust-lang.org/book/ch17-00-async-await.html", + "type": "article" + }, + { + "title": "async-std", + "url": "https://docs.rs/async-std/latest/async_std/", + "type": "article" + }, + { + "title": "Demystifying Async Programming in Rust", + "url": "https://medium.com/@trek007/demystifying-async-programming-in-rust-a-complete-guide-with-real-world-examples-147079950f8b", + "type": "article" + }, + { + "title": "Rust Async Programming: Tokio & Async-std", + "url": "https://medium.com/@AlexanderObregon/async-programming-in-rust-exploring-tokio-and-async-std-97d4b524cef0", + "type": "article" + } + ] }, "H0mctp3Bj2OYfIGFDWGfz": { "title": "Tokio", "description": "Tokio is Rust's most popular async runtime for building fast, reliable network applications. It provides an async/await runtime, I/O drivers, timers, and networking primitives. Tokio enables high-performance concurrent applications by efficiently managing thousands of tasks on a small number of threads.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Tokio", "url": "https://tokio.rs/", "type": "article" }, { - "title": "Docs.rs: Tokio", + "title": "Tokio Docs", "url": "https://docs.rs/tokio/latest/tokio/", "type": "article" } @@ -976,9 +1523,14 @@ "description": "`async-std` provides an asynchronous version of Rust's standard library, offering familiar APIs for async programming. It includes its own runtime, task scheduler, and async I/O primitives, designed as a drop-in replacement for std with async capabilities and intuitive syntax.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Docs.rs: async-std", + "title": "async-std", "url": "https://docs.rs/async-std/latest/async_std/", "type": "article" + }, + { + "title": "Rust Async Programming: Tokio & Async-std", + "url": "https://medium.com/@AlexanderObregon/async-programming-in-rust-exploring-tokio-and-async-std-97d4b524cef0", + "type": "article" } ] }, @@ -987,7 +1539,17 @@ "description": "`smol` is a small, fast async runtime for Rust with minimal API and clean design. Built on async-std and Tokio, it supports async/await natively with efficient scheduling. Offers essential async functionality including timers, futures, and task management with superior performance in a lightweight package.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Docs.rs: smol", + "title": "smol-rs/smol: A small and fast async runtime for Rust", + "url": "https://github.com/smol-rs/smol", + "type": "opensource" + }, + { + "title": "Smol - Gist of Rust", + "url": "https://book.gist.rs/rust/r1/smol.html", + "type": "article" + }, + { + "title": "Smol Documentation", "url": "https://docs.rs/smol/latest/smol/", "type": "article" } @@ -995,15 +1557,51 @@ }, "3pL0ARqk8uRNimopHSalW": { "title": "Networking", - "description": "Rust's `std::net` module provides networking primitives including `TcpStream`, `TcpListener`, `UdpSocket`, and address types. Built on BSD sockets, it offers low-level network operations for building networking applications. Higher-level crates like Tokio provide async networking capabilities.", - "links": [] + "description": "Rust's `std::net` module provides networking primitives including `TcpStream`, `TcpListener`, `UdpSocket`, and address types. Built on BSD sockets, it offers low-level network operations for building networking applications. Higher-level crates like Tokio provide async networking capabilities.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "std::net", + "url": "https://doc.rust-lang.org/std/net/", + "type": "article" + }, + { + "title": "TcpListener", + "url": "https://doc.rust-lang.org/std/net/struct.TcpListener.html", + "type": "article" + }, + { + "title": "UdpSocket", + "url": "https://doc.rust-lang.org/std/net/struct.UdpSocket.html", + "type": "article" + }, + { + "title": "TcpStream", + "url": "https://doc.rust-lang.org/std/net/struct.TcpStream.html", + "type": "article" + }, + { + "title": "Networking Fundamentals in Rust", + "url": "https://medium.com/@murataslan1/networking-fundamentals-in-rust-525dcfbd5058", + "type": "article" + } + ] }, "TtajUXZpyNx9AmdUawm-8": { "title": "reqwest", "description": "`reqwest` is a popular HTTP client library for Rust that provides both sync and async APIs for making HTTP requests. Built on `hyper` and `tokio`, it supports JSON, forms, cookies, and various authentication methods with an ergonomic, easy-to-use interface for web API interactions.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Docs.rs: Reqwest", + "title": "Making HTTP requests in Rust with Reqwest", + "url": "https://blog.logrocket.com/making-http-requests-rust-reqwest/", + "type": "article" + }, + { + "title": "Exploring Reqwest in Rust", + "url": "https://medium.com/@chetanreddyk394/exploring-reqwest-in-rust-b91c548e69af", + "type": "article" + }, + { + "title": "Reqwest Documentation", "url": "https://docs.rs/reqwest/latest/reqwest/", "type": "article" } @@ -1014,14 +1612,19 @@ "description": "Hyper is a fast, safe HTTP client/server library for Rust built on Tokio for async I/O. It supports HTTP/1 and HTTP/2 with automatic protocol negotiation. Hyper provides low-level HTTP primitives that power many higher-level web frameworks and serves as the foundation for efficient network programming.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Hyper.rs", "url": "https://hyper.rs/", "type": "article" }, { - "title": "Docs.rs: Hyper", + "title": "Hyper Documentation", "url": "https://docs.rs/hyper/latest/hyper/", "type": "article" + }, + { + "title": "Creating a Basic HTTP Server in Rust using Hyper", + "url": "https://medium.com/@ajay.bhatia/creating-a-basic-http-server-in-rust-using-hyper-a-step-by-step-tutorial-459b48d61151", + "type": "article" } ] }, @@ -1030,7 +1633,17 @@ "description": "`Quinn` is a high-performance QUIC protocol implementation for Rust built on Tokio. QUIC is a modern transport protocol offering better performance than TCP with multiplexing and security. Quinn provides async, futures-based API supporting both client and server roles for networking applications.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Docs.rs: quinn", + "title": "quinn-rs/quinn: Async-friendly QUIC implementation in Rust", + "url": "https://github.com/quinn-rs/quinn", + "type": "opensource" + }, + { + "title": "Quinn — Rust Network Library", + "url": "https://lib.rs/crates/quinn", + "type": "article" + }, + { + "title": "Quinn", "url": "https://docs.rs/quinn/latest/quinn/", "type": "article" } @@ -1038,22 +1651,43 @@ }, "gcmKSLWfBqx4aPZOmyQsg": { "title": "Serialization / Deserialization", - "description": "Serialization converts Rust data structures into bytes for storage or transmission, while deserialization reverses the process. Serde is the standard framework with support for JSON, YAML, TOML, Binary, and more formats. Provides efficient, type-safe data conversion.", - "links": [] + "description": "Serialization converts Rust data structures into bytes for storage or transmission, while deserialization reverses the process. _Serde_ is the standard framework with support for JSON, YAML, TOML, Binary, and more formats. Provides efficient, type-safe data conversion.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Serde Documentation", + "url": "https://docs.rs/serde/latest/serde/", + "type": "article" + }, + { + "title": "Serialization and Deserialization in Rust: A Comprehensive Guide", + "url": "https://rustmeup.com/serialization-in-rust-with-serde", + "type": "article" + }, + { + "title": "Rust Serialization: Easy Beginner's Guide with Examples", + "url": "https://boxoflearn.com/rust-serialization-guide/", + "type": "article" + } + ] }, "EHErECEYws05oi59OsZpC": { "title": "Serde", "description": "Serde is Rust's most popular serialization framework for converting data structures to/from formats like JSON, YAML, TOML, and Binary. It provides `Serialize` and `Deserialize` traits with derive macros for automatic implementation. Offers high performance with customizable behavior for complex use cases.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Serde", "url": "https://serde.rs/", "type": "article" }, { - "title": "Docs.rs: Serde", + "title": "Serde Documentation", "url": "https://docs.rs/serde/latest/serde/", "type": "article" + }, + { + "title": "Serialization in Rust with Serde", + "url": "https://rustmeup.com/serialization-in-rust-with-serde", + "type": "article" } ] }, @@ -1061,6 +1695,16 @@ "title": "json-rust", "description": "JSON handling in Rust primarily uses `serde` and `serde_json` libraries for high-performance serialization/deserialization. These provide seamless conversion between Rust data structures and JSON, with parsing from strings/files, serialization to JSON, and direct manipulation of JSON values.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "serde-rs/serde: Serialization framework for Rust", + "url": "https://github.com/serde-rs/serde", + "type": "opensource" + }, + { + "title": "Serde", + "url": "https://serde.rs/", + "type": "article" + }, { "title": "Docs.rs: JSON", "url": "https://docs.rs/json/latest/json/", @@ -1073,15 +1717,37 @@ } ] }, - "toml-rust@LmFog_qXrS9e5ARhV6OD_.md": { + "LmFog_qXrS9e5ARhV6OD_": { "title": "toml-rust", - "description": "", - "links": [] + "description": "`toml-rs` parses and serializes TOML (Tom's Obvious, Minimal Language) configuration files in Rust. Uses serde for automatic serialization/deserialization between TOML and Rust types. Leverages Rust's trait system and type inference to convert TOML documents into statically-typed Rust structures.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "TOML", + "url": "https://docs.rs/toml/latest/toml/", + "type": "article" + }, + { + "title": "@opensourcetoml-rs/toml-rs", + "url": "https://github.com/toml-rs/toml-rs", + "type": "article" + } + ] }, "_n7emeqzf5UTxVB5-385G": { "title": "Database and ORM", - "description": "ORMs (Object-Relational Mapping) provide abstraction layers between Rust code and SQL databases. Popular Rust ORMs include Diesel (compile-time safety), SQLx (async with compile-time query checking), and Sea-ORM. They eliminate raw SQL writing while maintaining type safety and performance.", - "links": [] + "description": "ORMs (Object-Relational Mapping) provide abstraction layers between Rust code and SQL databases. Popular Rust ORMs include Diesel (compile-time safety), SQLx (async with compile-time query checking), and Sea-ORM. They eliminate raw SQL writing while maintaining type safety and performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Diesel is a Safe, Extensible ORM and Query Builder for Rust", + "url": "https://diesel.rs/", + "type": "article" + }, + { + "title": "Choosing the Right ORM for Rust: A Comparative Analysis", + "url": "https://medium.com/@wiederinchristoph/rusts-ecosystem-offers-a-variety-of-object-relational-mapping-orm-libraries-and-database-ce4690a97a61", + "type": "article" + } + ] }, "UAXpBK3lfnq0Q4RcBehZ1": { "title": "Diesel", @@ -1103,7 +1769,7 @@ "type": "article" }, { - "title": "YouTube", + "title": "Rust & SQL Databases (With Diesel)", "url": "https://www.youtube.com/watch?v=tRC4EIKhMzw", "type": "video" } @@ -1114,14 +1780,19 @@ "description": "SQLx is an async, pure-Rust SQL toolkit providing compile-time query checking for PostgreSQL, MySQL, SQLite, and MSSQL. It features macro-based query validation, strong typing, and compatibility with Tokio/async-std runtimes. SQLx eliminates runtime SQL errors through compile-time verification.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Repository", + "title": "launchbadge/sqlx", "url": "https://github.com/launchbadge/sqlx", "type": "opensource" }, { - "title": "Docs.rs: sqlx", + "title": "sqlx Documentation", "url": "https://docs.rs/sqlx/latest/sqlx/", "type": "article" + }, + { + "title": "Getting Started with SQLx and SQLite in Rust", + "url": "https://medium.com/rustaceans/getting-started-with-sqlx-and-sqlite-in-rust-895ae7fc01ae", + "type": "article" } ] }, @@ -1130,43 +1801,86 @@ "description": "`rusqlite` is an ergonomic SQLite library for Rust built around the sqlite3 C library. It provides simple, efficient database operations with minimal SQL knowledge required. Features seamless `serde` integration for type-safe bidirectional mapping between SQL and Rust data structures.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Repository", + "title": "rusqlite/rusqlite", "url": "https://github.com/rusqlite/rusqlite", "type": "opensource" }, { - "title": "Docs.rs: rusqlite", + "title": "Rusqlite", "url": "https://docs.rs/rusqlite/latest/rusqlite/", "type": "article" + }, + { + "title": "Rust | Sqlite Database", + "url": "https://medium.com/@mikecode/rust-sqlite-database-rusqlite-162bad63fb5d", + "type": "article" } ] }, "Rv_Z-rbtELPZ1Nv0PZQmV": { "title": "Cryptography", - "description": "Cryptography involves securing data through encryption (making readable data unreadable) and decryption (reversing the process). Rust offers crypto libraries like `ring`, `sodiumoxide`, and `rust-crypto` for hashing, symmetric/asymmetric encryption, and digital signatures with memory-safe implementations.", - "links": [] + "description": "Cryptography involves securing data through encryption (making readable data unreadable) and decryption (reversing the process). Rust offers crypto libraries like `ring`, `sodiumoxide`, and `rust-crypto` for hashing, symmetric/asymmetric encryption, and digital signatures with memory-safe implementations.\n\nLearn more from the following links:", + "links": [ + { + "title": "Cryptography — list of Rust libraries/crates", + "url": "https://lib.rs/cryptography", + "type": "article" + }, + { + "title": "Awesome Rust Cryptography", + "url": "https://cryptography.rs/", + "type": "article" + } + ] }, "f68x7r-qzaQfrzXnjOI2q": { "title": "rust-crypto", - "description": "`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality.", - "links": [] + "description": "`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Awesome Rust Cryptography", + "url": "https://cryptography.rs/", + "type": "article" + }, + { + "title": "rust-crypto", + "url": "https://docs.rs/rust-crypto/latest/crypto/", + "type": "article" + }, + { + "title": "Rust | Sqlite Database", + "url": "https://medium.com/@mikecode/rust-sqlite-database-rusqlite-162bad63fb5d", + "type": "article" + } + ] }, "hzzRFb5cyXkgUdLZxaozB": { "title": "sodiumoxide", - "description": "`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits.", - "links": [] + "description": "`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Password Hashing with Argon2id and the Sodiumoxide", + "url": "https://blue42.net/code/rust/examples/sodiumoxide-password-hashing/post/", + "type": "article" + }, + { + "title": "sodiumoxide/sodiumoxide", + "url": "https://deepwiki.com/sodiumoxide/sodiumoxide", + "type": "article" + } + ] }, "w8nxQDxmfoUHkFV66TKiq": { "title": "ring", "description": "`ring` is a safe, fast cryptography library for Rust focused on TLS and core cryptographic primitives. It includes RSA, AES, SHA, and other algorithms with compile-time and runtime safety checks. Restricts usage to safe, reviewed algorithms to prevent common cryptographic pitfalls and insecure implementations.\n\nVisit the following resources to learn more:", "links": [ { - "title": "ring", + "title": "briansmith/ring", "url": "https://github.com/briansmith/ring", "type": "opensource" }, { - "title": "Docs.rs: ring", + "title": "Ring", "url": "https://docs.rs/ring/latest/ring/", "type": "article" } @@ -1174,148 +1888,590 @@ }, "2Zyyf9q_CxmOW-z2pipL8": { "title": "CLI Utilities", - "description": "CLI utilities are command-line tools that allow users to interact with their system through text commands. Rust is excellent for building fast, reliable CLI tools due to its memory safety and performance. Popular crates like clap and structopt help parse command-line arguments, handle input validation, and generate help messages, making CLI development efficient.", - "links": [] + "description": "CLI utilities are command-line tools that allow users to interact with their system through text commands. Rust is excellent for building fast, reliable CLI tools due to its memory safety and performance. Popular crates like clap and structopt help parse command-line arguments, handle input validation, and generate help messages, making CLI development efficient.\n\nLearn more from the following links:", + "links": [ + { + "title": "structopt", + "url": "https://docs.rs/structopt/latest/structopt/", + "type": "article" + }, + { + "title": "clap", + "url": "https://docs.rs/clap/latest/clap/", + "type": "article" + }, + { + "title": "Command-line Apps", + "url": "https://www.rust-lang.org/what/cli/", + "type": "article" + }, + { + "title": "Rust CLI Utilities - GitHub", + "url": "https://github.com/baldwin-sudo/rusty-utils", + "type": "article" + } + ] }, "AId80IokM7NvGBVutmuGC": { "title": "clap", - "description": "`clap` is Rust's most popular command-line argument parser library. It provides declarative CLI definition with automatic help generation, subcommands, validation, and error handling. Supports both builder pattern and derive macros for easy CLI app development with comprehensive features.", - "links": [] + "description": "`clap` is Rust's most popular command-line argument parser library. It provides declarative CLI definition with automatic help generation, subcommands, validation, and error handling. Supports both builder pattern and derive macros for easy CLI app development with comprehensive features.\n\nLearn more from the following links:", + "links": [ + { + "title": "clap", + "url": "https://docs.rs/clap/latest/clap/", + "type": "article" + }, + { + "title": "Using Clap in Rust for command line (CLI) Argument Parsing", + "url": "https://blog.logrocket.com/using-clap-rust-command-line-argument-parsing/", + "type": "article" + } + ] }, "_43912wPdXgLL8v-IMHX_": { "title": "structopt", - "description": "`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation.", - "links": [] + "description": "`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Defining and Instantiating Structs", + "url": "https://doc.rust-lang.org/book/ch05-01-defining-structs.html", + "type": "article" + }, + { + "title": "Parsing Command Line Args with StructOpt", + "url": "https://www.tenderisthebyte.com/blog/2019/05/08/parsing-cli-args-with-structopt/", + "type": "article" + } + ] }, "YS0igALDqSanGDWva_vls": { "title": "termion", - "description": "`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings.", - "links": [] + "description": "`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Termion Documentation", + "url": "https://docs.rs/termion/latest/termion/", + "type": "article" + }, + { + "title": "Implementing Terminal I/O in Rust | by Packt", + "url": "https://packt.medium.com/implementing-terminal-i-o-in-rust-4a44652b0f11", + "type": "article" + }, + { + "title": "Making Terminal Applications in Rust with Termion", + "url": "https://ticki.github.io/blog/making-terminal-applications-in-rust-with-termion/", + "type": "article" + } + ] }, "uG-EmZVZ-jc3mswOT4-7l": { "title": "Game Development", - "description": "Rust's performance and memory safety make it excellent for game development. Popular engines and frameworks include Bevy (ECS-based), Macroquad, ggez, and Fyrox. Rust handles both 2D and 3D games efficiently, with growing ecosystem support for graphics, audio, and physics.", - "links": [] + "description": "Rust's performance and memory safety make it excellent for game development. Popular engines and frameworks include Bevy (ECS-based), Macroquad, ggez, and Fyrox. Rust handles both 2D and 3D games efficiently, with growing ecosystem support for graphics, audio, and physics.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Fyrox - A feature-rich game engine built in Rust", + "url": "https://fyrox.rs/", + "type": "article" + }, + { + "title": "5 Rust Game Engines to Consider for your Next Project", + "url": "https://blog.logrocket.com/5-rust-game-engines-consider-next-project/", + "type": "article" + }, + { + "title": "Game Development with Fyrox and Rust", + "url": "https://bocksdincoding.com/blog/game-development-with-fyrox-and-rust-pt-1", + "type": "article" + } + ] }, "uyrGki0jB7DXQ0HJe2-vY": { "title": "bevy", - "description": "Bevy is a modern, data-driven game engine built in Rust featuring an ECS (Entity Component System) architecture. It supports both 2D and 3D games with modular design, custom shaders, and high performance. Bevy emphasizes developer ergonomics and provides comprehensive tools for game development.", - "links": [] + "description": "Bevy is a modern, data-driven game engine built in Rust featuring an ECS (Entity Component System) architecture. It supports both 2D and 3D games with modular design, custom shaders, and high performance. Bevy emphasizes developer ergonomics and provides comprehensive tools for game development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "bevyengine/bevy", + "url": "https://github.com/bevyengine/bevy", + "type": "opensource" + }, + { + "title": "Bevy Engine", + "url": "https://bevy.org/", + "type": "article" + }, + { + "title": "Bevy Documentation", + "url": "https://docs.rs/bevy/latest/bevy/", + "type": "article" + } + ] }, "x9bmK_cLYpX0ebwjZUn4R": { "title": "fyrox", - "description": "Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications.", - "links": [] + "description": "Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "FyroxEngine/Fyrox: 3D and 2D game engine written in Rust", + "url": "https://github.com/FyroxEngine/Fyrox", + "type": "opensource" + }, + { + "title": "Fyrox - A feature-rich game engine built in Rust", + "url": "https://fyrox.rs/", + "type": "article" + }, + { + "title": "Game Development with Fyrox and Rust", + "url": "https://bocksdincoding.com/blog/game-development-with-fyrox-and-rust-pt-1", + "type": "article" + } + ] }, "qquYnrrzUlyd8738jzj1D": { "title": "ggez", - "description": "`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details.", - "links": [] + "description": "`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "ggez: Rust Game Thing", + "url": "https://ggez.rs/", + "type": "article" + }, + { + "title": "2D Game Renderer in Rust", + "url": "https://dev.to/trish_07/2d-game-renderer-in-rust-lets-make-a-mini-rpg-a9h", + "type": "article" + } + ] }, "EtKhe3lgK3NoiBOjXRb2O": { "title": "macroquad", - "description": "Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS.", - "links": [] + "description": "Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Macroquad", + "url": "https://macroquad.rs/", + "type": "article" + }, + { + "title": "Macroquad Documentation", + "url": "https://macroquad.rs/docs/", + "type": "article" + }, + { + "title": "Rust: Create A Clicker Game With Macroquad", + "url": "https://dev.to/flavius_the_0th/rust-create-a-clicker-game-with-macroquad-1820", + "type": "article" + } + ] }, "6wGShK9WEnXiby_Jm8sTO": { "title": "wgpu-rs", - "description": "`wgpu-rs` provides safe, idiomatic Rust graphics programming by abstracting over wgpu-core. Offers high-level convenience with low-level control options. Provides unified access to graphics and compute functionality across Vulkan, Metal, DirectX, and WebGPU backends for cross-platform compatibility.", - "links": [] + "description": "`wgpu-rs` provides safe, idiomatic Rust graphics programming by abstracting over wgpu-core. Offers high-level convenience with low-level control options. Provides unified access to graphics and compute functionality across Vulkan, Metal, DirectX, and WebGPU backends for cross-platform compatibility.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "gfx-rs/wgpu", + "url": "https://github.com/gfx-rs/wgpu", + "type": "opensource" + }, + { + "title": "wgpu: portable graphics library for Rust", + "url": "https://wgpu.rs/", + "type": "article" + }, + { + "title": "wpgu docs", + "url": "hhttps://docs.rs/wgpu/latest/wgpu/", + "type": "article" + } + ] }, "T1LlJz5m5wnwBvKAEuGnP": { "title": "GUI Development", - "description": "Rust offers several GUI frameworks for desktop applications including Tauri (web-based), Iced (inspired by Elm), Druid, GTK-rs, and Egui. These provide cross-platform support for creating native desktop applications with modern UI patterns and performance benefits of Rust.", - "links": [] + "description": "Rust offers several GUI frameworks for desktop applications including Tauri (web-based), Iced (inspired by Elm), Druid, GTK-rs, and Egui. These provide cross-platform support for creating native desktop applications with modern UI patterns and performance benefits of Rust.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust and GUI Development - Comprehensive Guide", + "url": "https://rustmeup.com/rust-and-gui-development", + "type": "article" + }, + { + "title": "The state of Rust GUI libraries", + "url": "https://blog.logrocket.com/state-rust-gui-libraries/", + "type": "article" + }, + { + "title": "Building Beautiful and Intuitive GUIs with Rust and egui", + "url": "https://triophore.com/blogs/content/rust-egui-gui-development/", + "type": "article" + } + ] }, "Q71MnFDQBkZF1c2hj13pU": { "title": "tauri", - "description": "Tauri is a framework for building lightweight, secure desktop applications using web technologies (HTML, CSS, JS) with a Rust backend. It offers smaller bundle sizes than Electron, enhanced security, and cross-platform support for Windows, macOS, and Linux with native system integration.\n\nLearn more from the following resources:", + "description": "Tauri is a framework for building lightweight, secure desktop applications using web technologies (HTML, CSS, JS) with a Rust backend. It offers smaller bundle sizes than Electron, enhanced security, and cross-platform support for Windows, macOS, and Linux with native system integration.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Tauri Website", + "title": "Tauri", "url": "https://tauri.app", "type": "article" + }, + { + "title": "Tauri Guides", + "url": "https://v1.tauri.app/v1/guides/", + "type": "article" + }, + { + "title": "How to Build Cross-Platform GUI Applications with Rust & Tauri", + "url": "https://codezup.com/cross-platform-gui-apps-rust-tauri-guide/", + "type": "article" } ] }, "2Zp3m3Y7j6R1hK3DIVdkH": { "title": "gtk-rs", - "description": "`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality.", - "links": [] + "description": "`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "gtk-rs/gtk4-rs: Rust Bindings of GTK 4", + "url": "https://github.com/gtk-rs/gtk4-rs", + "type": "opensource" + }, + { + "title": "Unlocking the GNOME stack for Rust", + "url": "https://gtk-rs.org/", + "type": "article" + } + ] }, "QbdGnUoTLgMHO1NCQINIi": { "title": "relm", - "description": "`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications.", - "links": [] + "description": "`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Relm", + "url": "https://relm4.org/", + "type": "article" + }, + { + "title": "Relm Documentation", + "url": "https://relm4.org/book/stable/", + "type": "article" + }, + { + "title": "Relm, a GUI library, based on GTK+ and futures, written in Rust", + "url": "https://relm.antoyo.xyz/relm-intro/", + "type": "article" + } + ] }, "RKXljexmLAceMYwg4D_uP": { "title": "Embedded and Systems", - "description": "Rust excels in embedded systems programming for microcontrollers and real-time applications. Its zero-cost abstractions, memory safety, and low-level control make it ideal for resource-constrained environments. Popular for IoT devices, firmware, and system-level programming without garbage collection overhead.", - "links": [] + "description": "Rust excels in embedded systems programming for microcontrollers and real-time applications. Its zero-cost abstractions, memory safety, and low-level control make it ideal for resource-constrained environments. Popular for IoT devices, firmware, and system-level programming without garbage collection overhead.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Embedded Devices", + "url": "https://www.rust-lang.org/what/embedded", + "type": "article" + }, + { + "title": "Rust for Embedded Systems", + "url": "https://medium.com/@enravishjeni411/rust-for-embedded-systems-a-beginner-friendly-guide-e8c171cfb359", + "type": "article" + }, + { + "title": "Rust Embedded Systems: Beginner's Guide with Example", + "url": "https://boxoflearn.com/rust-embedded-systems-guide/", + "type": "article" + } + ] }, "LzaO2cpDajXERqEYDjMl_": { "title": "embedded-hal", - "description": "`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms.", - "links": [] + "description": "`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "A Hardware Abstraction Layer (HAL) for Embedded Systems", + "url": "https://github.com/rust-embedded/embedded-hal", + "type": "opensource" + }, + { + "title": "HALs - The Embedded Rust Book", + "url": "https://doc.rust-lang.org/stable/embedded-book/design-patterns/hal/index.html", + "type": "article" + } + ] }, "L01rVq2_H4rWzlKygW5kA": { "title": "rppal", - "description": "`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer.", - "links": [] + "description": "`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "golemparts/rppal", + "url": "https://github.com/golemparts/rppal", + "type": "opensource" + }, + { + "title": "RPPAL Documentation", + "url": "https://docs.golemparts.com/rppal/0.11.1/rppal/", + "type": "article" + }, + { + "title": "RPPAL — Embedded dev in Rust", + "url": "https://lib.rs/crates/rppal", + "type": "article" + } + ] }, "ETYrk0s5Wn80XyntNG_t1": { "title": "nrf-hal", - "description": "`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access.", - "links": [] + "description": "`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "nrf-rs/nrf-hal", + "url": "https://github.com/nrf-rs/nrf-hal", + "type": "opensource" + }, + { + "title": "nRF-HAL — embedded dev in Rust", + "url": "https://lib.rs/crates/nrf-hal", + "type": "article" + }, + { + "title": "What the HAL? The Quest for Finding a Suitable Embedded Rust HAL", + "url": "https://dev.to/theembeddedrustacean/what-the-hal-the-quest-for-finding-a-suitable-embedded-rust-hal-2i02", + "type": "article" + } + ] }, "fusu4ZHH4-cjoouLr4F9U": { "title": "WebAssembly (WASM)", - "description": "WebAssembly is a binary instruction format that runs at near-native speed in web browsers and other environments. Rust compiles excellently to WASM with tools like `wasm-pack` and `wasm-bindgen`, enabling high-performance web applications and cross-platform deployment.", - "links": [] + "description": "WebAssembly is a binary instruction format that runs at near-native speed in web browsers and other environments. Rust compiles excellently to WASM with tools like `wasm-pack` and `wasm-bindgen`, enabling high-performance web applications and cross-platform deployment.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Embedding WebAssembly in your Rust Application", + "url": "https://blog.wasmer.io/executing-webassembly-in-your-rust-application-d5cd32e8ce46", + "type": "article" + }, + { + "title": "Writing & Compiling WASM in Rust", + "url": "https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust", + "type": "article" + }, + { + "title": "Compiling from Rust to WebAssembly", + "url": "https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm", + "type": "article" + }, + { + "title": "wasm-pack", + "url": "https://lib.rs/crates/wasm-pack", + "type": "article" + }, + { + "title": "wasm-bindgen", + "url": "https://docs.rs/wasm-bindgen/latest/wasm_bindgen/", + "type": "article" + } + ] }, "SUtBBqqDeR_yAkr669ZvE": { "title": "wasm-bindgen", - "description": "`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects.", - "links": [] + "description": "`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "rustwasm/wasm-bindgen", + "url": "https://github.com/rustwasm/wasm-bindgen", + "type": "opensource" + }, + { + "title": "wasm-bindgen", + "url": "https://docs.rs/wasm-bindgen/latest/wasm_bindgen/", + "type": "article" + }, + { + "title": "Compiling from Rust to WebAssembly", + "url": "https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm", + "type": "article" + } + ] }, "TSlj7mMUB5CDTy8uMFzKV": { "title": "wasm-pack", - "description": "`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness.", - "links": [] + "description": "`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "rustwasm/wasm-pack", + "url": "https://github.com/rustwasm/wasm-pack", + "type": "opensource" + }, + { + "title": "wasm-pack", + "url": "https://lib.rs/crates/wasm-pack", + "type": "article" + }, + { + "title": "Writing & Compiling WASM in Rust", + "url": "https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust", + "type": "article" + }, + { + "title": "Compiling from Rust to WebAssembly", + "url": "https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm", + "type": "article" + } + ] }, "iyFHvZj_ntr_dX6WlL4E1": { "title": "wasmer", - "description": "Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular.", - "links": [] + "description": "Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "wasmerio/wasmer", + "url": "https://github.com/wasmerio/wasmer", + "type": "opensource" + }, + { + "title": "Embedding WebAssembly in your Rust Application", + "url": "https://blog.wasmer.io/executing-webassembly-in-your-rust-application-d5cd32e8ce46", + "type": "article" + }, + { + "title": "Wasmer — WebAssembly in Rust", + "url": "https://lib.rs/crates/wasmer", + "type": "article" + }, + { + "title": "Writing & Compiling WASM in Rust", + "url": "https://www.shuttle.dev/blog/2024/03/06/writing-wasm-rust", + "type": "article" + }, + { + "title": "Compiling from Rust to WebAssembly", + "url": "https://developer.mozilla.org/en-US/docs/WebAssembly/Guides/Rust_to_Wasm", + "type": "article" + } + ] }, "7YKWYxogJq6X35IAUwcZF": { "title": "Debugging", - "description": "Rust provides excellent debugging support through `rust-gdb` and `rust-lldb` debuggers, along with built-in macros like `println!`, `dbg!`, and `debug!`. The strict compiler catches many bugs at compile-time, while runtime debugging is enhanced by panic backtraces and comprehensive error messages.", - "links": [] + "description": "Rust provides excellent debugging support through `rust-gdb` and `rust-lldb` debuggers, along with built-in macros like `println!`, `dbg!`, and `debug!`. The strict compiler catches many bugs at compile-time, while runtime debugging is enhanced by panic backtraces and comprehensive error messages.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Debugging Rust apps with GDB", + "url": "https://blog.logrocket.com/debugging-rust-apps-with-gdb/", + "type": "article" + }, + { + "title": "Rust Debugging: Easy Guide with Practical Examples", + "url": "https://boxoflearn.com/rust-debugging-guide/", + "type": "article" + }, + { + "title": "Testing and Debugging in Rust", + "url": "https://rustmeup.com/testing-and-debugging-in-rust", + "type": "article" + }, + { + "title": "Mastering Rust Debugging: Tips & Tools", + "url": "https://medium.com/@AlexanderObregon/rust-debugging-strategies-tools-and-best-practices-b18b92e0a921", + "type": "article" + } + ] }, "UkHXsAolmbk-MsJFfqObC": { "title": "rust-gdb", - "description": "`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis.", - "links": [] + "description": "`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Use rust-gdb and rust-lldb for Improved Debugging", + "url": "https://users.rust-lang.org/t/use-rust-gdb-and-rust-lldb-for-improved-debugging-you-already-have-them/756", + "type": "article" + }, + { + "title": "Debugging Rust apps with GDB", + "url": "https://blog.logrocket.com/debugging-rust-apps-with-gdb/", + "type": "article" + } + ] }, "p1w1iljGABgHoJjIRJYLY": { "title": "rust-lldb", - "description": "`rust-lldb` is LLDB debugger enhanced with Rust-specific modifications for understanding Rust data structures and concepts. It includes pretty-printers for standard library types and comes bundled with the Rust compiler, providing better debugging experience for Rust applications.", - "links": [] + "description": "`rust-lldb` is LLDB debugger enhanced with Rust-specific modifications for understanding Rust data structures and concepts. It includes pretty-printers for standard library types and comes bundled with the Rust compiler, providing better debugging experience for Rust applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Using rust-lldb for Improved Debugging", + "url": "https://users.rust-lang.org/t/use-rust-gdb-and-rust-lldb-for-improved-debugging-you-already-have-them/756", + "type": "article" + }, + { + "title": "Debugging Rust apps with GDB", + "url": "https://blog.logrocket.com/debugging-rust-apps-with-gdb/", + "type": "article" + }, + { + "title": "Debugging Rust with rust-lldb", + "url": "https://dev.to/bmatcuk/debugging-rust-with-rust-lldb-j1f", + "type": "article" + } + ] }, "65nbahPj9qAb9y8dF8Jnd": { "title": "Documenting with `rustdoc`", - "description": "", - "links": [] + "description": "RustDoc is an invaluable tool within the Rust ecosystem for generating comprehensive and user-friendly documentation directly from your source code. By leveraging special documentation comments (starting with `///` for regular comments and `//!` for crate-level comments), developers can embed Markdown-formatted text, code examples, and even doctests directly alongside their functions, modules, and types. RustDoc then processes these comments to produce static HTML pages, making it easy for others (and your future self) to understand how to use your libraries and applications. This integrated approach not only promotes good documentation habits but also ensures that the documentation remains in sync with the codebase.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "How to Write Documentation", + "url": "https://doc.rust-lang.org/rustdoc/how-to-write-documentation.html", + "type": "article" + }, + { + "title": "Writing Rust Documentation", + "url": "https://dev.to/gritmax/writing-rust-documentation-5hn5", + "type": "article" + } + ] }, "WduD9VIcYSs_JTnuMNyxk": { "title": "Performance and Profiling", - "description": "Performance profiling in Rust identifies bottlenecks using tools like `perf`, `cargo bench`, `criterion`, and `flamegraph`. These tools collect statistical data about runtime performance, helping developers optimize code efficiently by targeting actual problem areas rather than guessing.", - "links": [] + "description": "Performance profiling in Rust identifies bottlenecks using tools like `perf`, `cargo bench`, `criterion`, and `flamegraph`. These tools collect statistical data about runtime performance, helping developers optimize code efficiently by targeting actual problem areas rather than guessing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Profiling - The Rust Performance Book", + "url": "https://nnethercote.github.io/perf-book/profiling.html", + "type": "article" + }, + { + "title": "How to benchmark Rust code with Criterion", + "url": "https://bencher.dev/learn/benchmarking/rust/criterion/", + "type": "article" + }, + { + "title": "Optimizing Rust Application Performance with Profiling", + "url": "https://hemaks.org/posts/optimizing-rust-application-performance-with-profiling/", + "type": "article" + } + ] }, "clQ26LFV_9AdQ4evnaxUK": { "title": "Criterion.rs", - "description": "`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights.", - "links": [] + "description": "`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights.\n\nLearn more from the following links:", + "links": [ + { + "title": "Criterion", + "url": "https://docs.rs/criterion/latest/criterion/", + "type": "article" + }, + { + "title": "Rust Benchmarking with Criterion.rs", + "url": "https://www.rustfinity.com/blog/rust-benchmarking-with-criterion", + "type": "article" + }, + { + "title": "Benchmarking Rust Functions Using Criterion", + "url": "https://www.slingacademy.com/article/benchmarking-rust-functions-using-criterion/", + "type": "article" + } + ] } } \ No newline at end of file diff --git a/public/roadmap-content/software-design-architecture.json b/public/roadmap-content/software-design-architecture.json index fafe0dafc..43b65e998 100644 --- a/public/roadmap-content/software-design-architecture.json +++ b/public/roadmap-content/software-design-architecture.json @@ -411,6 +411,11 @@ "url": "https://en.wikipedia.org/wiki/Class_invariant", "type": "article" }, + { + "title": "Class Invariants", + "url": "https://course.ccs.neu.edu/cs3500f15/lec_08_notes.html", + "type": "article" + }, { "title": "The concept of class invariant in object-oriented programming", "url": "https://arxiv.org/abs/2109.06557", @@ -463,11 +468,6 @@ "title": "Overview of Anemic Domain Model", "url": "https://en.wikipedia.org/wiki/Anemic_domain_model", "type": "article" - }, - { - "title": "What is an Anaemic Domain Model?", - "url": "https://www.ensonodigital.com/blog/anaemic-domain-model-vs-rich-domain-model", - "type": "article" } ] }, @@ -477,7 +477,7 @@ "links": [ { "title": "What is an Abstract Class in Object Oriented Programming", - "url": "https://computinglearner.com/abstract-class-in-object-oriented-programming/", + "url": "https://www.theserverside.com/definition/abstract-class", "type": "article" } ]