Update contribution guidelines for node modifications

- iOS Dynamic Type: 'accomodates' → 'accommodates'
- Redis XREAD: 'entired' → 'entries', 'recieved' → 'received'
- ASP.NET Template Engines: 'How to to' → 'How to'
- Data Engineer Horizontal Scaling: 'a an existing' → 'an existing'
- AWS Configuration Sets: 'allow to publish' → 'allow you to publish'

Co-authored-by: Your Name <your-email@example.com>

contributing.md

@@ -23,7 +23,7 @@ For new roadmaps, you can either:
 For the existing roadmaps, please follow the details listed for the nature of contribution:
 
 - **Fixing Typos** — Make your changes in the [roadmap markdown file](https://github.com/kamranahmedse/developer-roadmap/tree/master/src/data/roadmaps) and submit a [PR](https://github.com/kamranahmedse/developer-roadmap/pulls).
-- **Adding or Removing Nodes** — Please open an [issue](https://github.com/kamranahmedse/developer-roadmap/issues) with your suggestion.
+- **Adding/Removing Nodes and Modifying Node Titles** — Please open an [issue](https://github.com/kamranahmedse/developer-roadmap/issues) with your suggestion.
 
 **Note:** Please note that our goal is **not to have the biggest list of items**. Our goal is to list items or skills most relevant today.
 

src/data/roadmaps/aspnet-core/content/template-engines@C85aJvrzj6rP2Hmfj9uPB.md

@@ -5,4 +5,4 @@ Template engines in [ASP.NET](http://ASP.NET) are libraries that allow developer
 Visit the following resources to learn more:
 
 - [@article@Template Engine in ASP.NET](https://ej2.syncfusion.com/aspnetmvc/documentation/common/template-engine)
-- [@article@How to to Create Custom Templates using the .Net Template Engine ](https://www.infoq.com/articles/dotnet-core-template-engine/)
+- [@article@How to Create Custom Templates using the .Net Template Engine ](https://www.infoq.com/articles/dotnet-core-template-engine/)

src/data/roadmaps/aws/content/configuration-sets@4svXYQYmqjUZU39z8OyhD.md

@@ -1,6 +1,6 @@
 # Configuration Sets
 
-Configuration Sets in SES (Simple Email Service) of AWS (Amazon Web Services) allow to publish email sending events. These sets are used to group together similar rules that you can apply to emails you send using AWS SES. You can apply a configuration set to an email by including it in the headers of the email. It can be used to specify the dedicated sending IP pools, configure the message delivery parameters, and to enable open and click tracking. AWS SES sends information about each email sent with the set to CloudWatch and Kinesis Firehose which can be later utilized for further analysis or to manage your customer interactions more effectively.
+Configuration Sets in SES (Simple Email Service) of AWS (Amazon Web Services) allow you to publish email sending events. These sets are used to group together similar rules that you can apply to emails you send using AWS SES. You can apply a configuration set to an email by including it in the headers of the email. It can be used to specify the dedicated sending IP pools, configure the message delivery parameters, and to enable open and click tracking. AWS SES sends information about each email sent with the set to CloudWatch and Kinesis Firehose which can be later utilized for further analysis or to manage your customer interactions more effectively.
 
 Visit the following resources to learn more:
 

src/data/roadmaps/cpp/content/references@uUzRKa9wGzdUwwmAg3FWr.md

@@ -69,57 +69,13 @@ When iterating over containers such as `std::vector<std::string>`, the choice of
 
 ### Comparison
 
-Loop style
+| Loop style          | Copies made? | Can modify element? | Efficiency                         | Typical use case                         |
+|---------------------|--------------|---------------------|------------------------------------|------------------------------------------|
+| `auto str`          | ✅ Yes        | ✅ Only the copy     | Less efficient for large objects   | When you need a local, mutable copy      |
+| `auto const &str`   | ❌ No         | ❌ Read-only         | Most efficient for read-only use   | Safely read elements without copying     |
+| `auto &str`         | ❌ No         | ✅ Modifies original | Efficient, mutates container       | Modify elements in place                 |
+| `const auto str`    | ✅ Yes        | ❌ Read-only         | Less efficient for large objects   | Explicit read-only copy                  |
 
-Copies made?
-
-Can modify element?
-
-Efficiency
-
-Typical Use Case
-
-`auto str`
-
-✅ Yes
-
-✅ Only the copy
-
-Less efficient for large objects
-
-When you need a local, mutable copy
-
-`auto const &str`
-
-❌ No
-
-❌ Read-only
-
-Most efficient for read-only use
-
-Safely read elements without copying
-
-`auto &str`
-
-❌ No
-
-✅ Modifies original
-
-Efficient, mutates container
-
-Modify elements in place
-
-`const auto str`
-
-✅ Yes
-
-❌ Read-only
-
-Less efficient for large objects
-
-Explicit read-only copy
-
-* * *
 
 Example: Why `const auto str` Can Be Useful
 -------------------------------------------
@@ -156,4 +112,4 @@ Performance Notes
 
 *   For **large objects** like `std::string`, `std::vector`, or custom classes, prefer **`auto const &`** to avoid unnecessary copies.
 *   For **small, cheap-to-copy types** like `int`, `char`, or `bool`, using `auto` or `const auto` is fine and often simpler.
-*   `auto &` should only be used when you _intend_ to modify the elements in place, since it directly mutates the container.
+*   `auto &` should only be used when you _intend_ to modify the elements in place, since it directly mutates the container.

src/data/roadmaps/css/content/direction@ZyqKZMIkQ22ysFqmhL3ZN.md

@@ -1,8 +1,10 @@
 # Direction
 
-Direction in CSS controls the text direction of an element. It specifies whether the text should flow from left to right (LTR) or right to left (RTL). This property is particularly useful for languages like Arabic or Hebrew, which are written from right to left, ensuring proper text rendering and layout.
+The `direction` property in CSS sets the text direction of block-level elements, influencing how text, table columns, and inline-level boxes flow. While `direction` can be used to switch between left-to-right (LTR) and right-to-left (RTL) layouts, it's generally better to use the HTML `dir` global attribute. The `dir` attribute semantically indicates the document's or element's text direction, providing better accessibility and separation of concerns compared to styling direction with CSS.
 
 Visit the following resources to learn more:
 
-- [@article@Direction](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
-- [@video@CSS how to: text direction](https://www.youtube.com/watch?v=SEX09kE5KmQ)
+- [@article@CSS Direction](https://developer.mozilla.org/en-US/docs/Web/CSS/direction)
+- [@article@HTML dir global attribute](https://developer.mozilla.org/en-US/docs/Web/HTML/Reference/Global_attributes/dir)
+- [@video@CSS for beginners 60: direction property](https://www.youtube.com/watch?v=LM0yIWmP62Q)
+- [@video@HTML Global Attributes - dir Attribute](https://www.youtube.com/watch?v=6hqHM7Ez_Xg)

src/data/roadmaps/css/content/tables@Q-6tdHPE-xpPGIG8J_Wz7.md

@@ -5,4 +5,4 @@ Tables in CSS are used to format tabular data on a webpage, arranging informatio
 Visit the following resources to learn more:
 
 - [@article@Table](https://developer.mozilla.org/en-US/docs/Web/CSS/CSS_table)
-- [@article@Styling HTML tables with CSS - Web Design/UX Tutorial](https://www.youtube.com/watch?v=biI9OFH6Nmg)
+- [@video@Styling HTML tables with CSS - Web Design/UX Tutorial](https://www.youtube.com/watch?v=biI9OFH6Nmg)

src/data/roadmaps/data-engineer/content/horizontal-vs-vertical-scaling@k_XSLLwb0Jk0Dd1sw-MpR.md

@@ -1,6 +1,6 @@
 # Horizontal vs Vertical Scaling
 
-Horizontal scaling is the process of adding more machines or nodes to a an existing pool in a system to distribute the workload and address increased load.
+Horizontal scaling is the process of adding more machines or nodes to an existing pool in a system to distribute the workload and address increased load.
 
 By contrast, vertical scaling involves increasing the computing power of individual machines in a system. This is achieved by adjusting or upgrading hardware components, such as CPU, RAM, and network speed.
 

src/data/roadmaps/frontend-beginner/content/css@ZhJhf1M2OphYbEmduFq-9.md

@@ -0,0 +1,11 @@
+# CSS
+
+CSS, or Cascading Style Sheets, is a language used to describe the look and formatting of a document written in HTML. It controls things like the colors, fonts, layout, and overall visual presentation of a website, ensuring it's both appealing and easy to navigate for users. Think of it as the makeup artist for your website, taking the basic structure provided by HTML and making it beautiful.
+
+Visit the following resources to learn more:
+
+- [@official@Visit the Dedicated CSS Roadmap](https://roadmap.sh/css)
+- [@article@HTML & CSS: design and build websites](https://sites.math.duke.edu/courses/math_everywhere/assets/techRefs/HTML%20and%20CSS-%20Design%20and%20Build%20Websites_Jon%20Duckett_2011.pdf)
+- [@article@CSS MDN Docs](https://developer.mozilla.org/en-US/docs/Learn_web_development/Core/Styling_basics/What_is_CSS)
+- [@article@CSS | Wikipedia](https://en.wikipedia.org/wiki/CSS)
+- [@video@SS Tutorial – Full Course for Beginners](https://www.youtube.com/watch?v=OXGznpKZ_sA)

src/data/roadmaps/frontend-beginner/content/git@R_I4SGYqLk5zze5I1zS_E.md

@@ -0,0 +1,10 @@
+# Git
+
+Git is like a save button for your code, but way more powerful. It's a system that tracks changes you make to your files, so you can easily go back to earlier versions, compare different versions, and collaborate with others on the same project without messing up each other's work. Think of it as a detailed history book for your code, allowing you to experiment and fix mistakes without fear of losing progress.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit Dedicated Git & GitHub Roadmap](https://roadmap.sh/git-github)
+- [@article@Learn Git with Tutorials, News and Tips - Atlassian](https://www.atlassian.com/git)
+- [@article@Git Cheat Sheet](https://cs.fyi/guide/git-cheatsheet)
+- [@video@Git & GitHub Crash Course For Beginners](https://www.youtube.com/watch?v=SWYqp7iY_Tc)

src/data/roadmaps/frontend-beginner/content/github@qmTVMJDsEhNIkiwE_UTYu.md

@@ -0,0 +1,10 @@
+# GitHub
+
+GitHub is a website and service that helps developers store and manage their code. Think of it like a cloud-based folder where you can keep all your project files. It also allows multiple people to work on the same project at the same time without messing each other's work up, using a system called version control. This makes it easier to collaborate and track changes to your code.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit Dedicated Git & GitHub Roadmap](https://roadmap.sh/git-github)
+- [@official@GitHub](https://github.com)
+- [@official@GitHub Documentation](https://docs.github.com/en/get-started/quickstart)
+- [@video@What is GitHub?](https://www.youtube.com/watch?v=w3jLJU7DT5E)

src/data/roadmaps/frontend-beginner/content/html@yWG2VUkaF5IJVVut6AiSy.md

@@ -0,0 +1,10 @@
+# HTML
+
+HTML, or HyperText Markup Language, is the standard language for creating web pages. It uses tags to structure content like headings, paragraphs, images, and links, telling the web browser how to display the information. Think of it as the skeleton of a website, providing the basic structure and content that users see.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit the dedicated HTML roadmap](https://roadmap.sh/html)
+- [@article@Responsive Web Design Certification - Co-Learn HTML & CSS with guided projects](https://www.freecodecamp.org/learn/2022/responsive-web-design/)
+- [@video@HTML Full Course for Beginners](https://www.youtube.com/watch?v=mJgBOIoGihA)
+- [@video@HTML Full Course - Build a Website Tutorial](https://www.youtube.com/watch?v=pQN-pnXPaVg)

src/data/roadmaps/frontend-beginner/content/javascript@ODcfFEorkfJNupoQygM53.md

@@ -0,0 +1,11 @@
+# JavaScript
+
+JavaScript is a programming language that makes websites interactive. It lets you add dynamic content, control multimedia, animate images, and pretty much everything else that makes a webpage more than just static text. It runs in web browsers, allowing you to create engaging experiences for users.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit Dedicated JavaScript Roadmap](https://roadmap.sh/javascript)
+- [@book@JavaScript from Beginner to Professional](https://www.gurukultti.org/admin/notice/javascript.pdf)
+- [@article@The Modern JavaScript Tutorial](https://javascript.info/)
+- [@article@Build 30 Javascript projects in 30 days](https://javascript30.com/)
+- [@video@JavaScript Crash Course For Beginners](https://www.youtube.com/watch?v=hdI2bqOjy3c&t=4s)

src/data/roadmaps/frontend-beginner/content/npm@ib_FHinhrw8VuSet-xMF7.md

@@ -0,0 +1,11 @@
+# npm
+
+npm is like a personal assistant for your coding projects. It's a tool that helps you easily manage and share code packages (like pre-written bits of code that do specific things) in your projects. Think of it as an app store, but for code. You can use it to install, update, and uninstall these packages, making it much easier to use other people's code and share your own.
+
+Visit the following resources to learn more:
+
+- [@official@NPM Website](https://www.npmjs.com/)
+- [@official@NPM Documentation](https://docs.npmjs.com/)
+- [@opensource@How to NPM](https://github.com/workshopper/how-to-npm)
+- [@article@Modern JavaScript for Dinosaurs](https://peterxjang.com/blog/modern-javascript-explained-for-dinosaurs.html)
+- [@video@NPM Tutorial for Beginners](https://www.youtube.com/watch?v=2V1UUhBJ62Y)

src/data/roadmaps/frontend-beginner/content/react@tG5v3O4lNIFc2uCnacPak.md

@@ -0,0 +1,9 @@
+# React
+
+React is a JavaScript library for building user interfaces. It lets you break down complex UIs into smaller, reusable components. These components manage their own data and can be composed together to create larger applications. React uses a declarative approach, meaning you describe what you want the UI to look like, and React takes care of updating the DOM efficiently.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Visit Dedicated React Roadmap](https://roadmap.sh/react)
+- [@official@React Website](https://react.dev)
+- [@video@Full Stack React Developer Course](https://www.youtube.com/watch?v=Bvwq_S0n2pk)

src/data/roadmaps/frontend-beginner/content/tailwind@eghnfG4p7i-EDWfp3CQXC.md

@@ -0,0 +1,11 @@
+# Tailwind CSS
+
+Tailwind CSS is a utility-first CSS framework. Instead of providing pre-designed components like buttons or navigation bars, it gives you a set of pre-defined CSS classes that you can use directly in your HTML to style your elements. This allows for highly customized designs without writing custom CSS from scratch, offering a faster and more flexible way to style your web pages.
+
+Visit the following resources to learn more:
+
+- [@official@Tailwind Website](https://tailwindcss.com)
+- [@official@Online Playground](https://play.tailwindcss.com)
+- [@course@Tailwind CSS Full Course for Beginners](https://www.youtube.com/watch?v=lCxcTsOHrjo)
+- [@video@Should You Use Tailwind CSS?](https://www.youtube.com/watch?v=hdGsFpZ0J2E)
+- [@video@Official Screencasts](https://www.youtube.com/c/TailwindLabs/videos)

src/data/roadmaps/frontend-beginner/content/vitest@hVQ89f6G0LXEgHIOKHDYq.md

@@ -0,0 +1,9 @@
+# Vitest
+
+Vitest is a testing framework powered by Vite. It's designed to be fast and easy to use, especially for projects that already use Vite for development. Vitest allows you to write unit tests and integration tests for your frontend code, ensuring that your components and functions work as expected. It offers features like hot module replacement (HMR) during testing, a watch mode for automatically re-running tests on file changes, and compatibility with popular testing libraries like Jest.
+
+Visit the following resources to learn more:
+
+- [@official@Vitest - Next Generation Testing Framework](https://vitest.dev/)
+- [@official@Vitest Documentation](https://vitest.dev/guide/)
+- [@video@Vitest Simplified](https://www.youtube.com/watch?v=snCLQmINqCU)

src/data/roadmaps/ios/content/dynamic-type@0nei6iwP4Pgi_j4vVi_Qt.md

@@ -1,5 +1,5 @@
 # Dynamic Type
-The Dynamic Type feature allows users to choose the size of textual content displayed on the screen. It helps users who need larger text for better readability. It also accomodates those who can read smaller text, allowing more information to appear on the screen. Apps that support Dynamic Type also provide a more consistent reading experience.
+The Dynamic Type feature allows users to choose the size of textual content displayed on the screen. It helps users who need larger text for better readability. It also accommodates those who can read smaller text, allowing more information to appear on the screen. Apps that support Dynamic Type also provide a more consistent reading experience.
 
 Visit the following resources to learn more:
 

src/data/roadmaps/python/content/django@x1V8GjdjANTnhP6YXMbgC.md

@@ -4,6 +4,7 @@ Django is a free and open-source, Python-based web framework that follows the mo
 
 Visit the following resources to learn more:
 
+- [@roadmap@Visit the Dedicated Django Roadmap](https://roadmap.sh/django)
 - [@official@Django Website](https://www.djangoproject.com/)
 - [@official@Getting Started](https://www.djangoproject.com/start/)
 - [@article@Is Django Synchronous or Asynchronous?](https://stackoverflow.com/questions/58548089/django-is-synchronous-or-asynchronous)

src/data/roadmaps/redis/content/xread@4sKiAtX5aIL4NDsQkilNC.md

@@ -1,6 +1,6 @@
 # XREAD
 
-The XREAD command reads data from one or more streams, only returning entired with an ID greater than the last recieved ID.
+The XREAD command reads data from one or more streams, only returning entries with an ID greater than the last received ID.
 
 Learn more from the following resources:
 

src/data/roadmaps/ruby/content/arithmetic@I708SVAEVSpdHzwxoHhgD.md

@@ -0,0 +1,8 @@
+# Arithmetic Operators
+
+Arithmetic operators are symbols that perform mathematical calculations on numerical values. These operators allow you to perform addition, subtraction, multiplication, division, and other common arithmetic operations. They take one or more operands (the values being operated on) and produce a result based on the operation performed.
+
+Visit the following resources to learn more:
+
+- [@article@Arithmetical operators](https://ruby-for-beginners.rubymonstas.org/operators/arithmetical.html)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/arrays@2QHXNKV0tETI5FroFNylt.md

@@ -0,0 +1,12 @@
+# Arrays
+
+Arrays in Ruby are ordered collections of items. They can hold any type of data, including numbers, strings, symbols, or even other arrays. You create an array using square brackets `[]`, with elements separated by commas. Arrays are dynamic, meaning their size can change as you add or remove elements. You can access elements in an array using their index, starting from 0 for the first element.
+
+Visit the following resources to learn more:
+
+- [@official@class Array](https://docs.ruby-lang.org/en/master/Array.html)
+- [@article@Arrays](https://launchschool.com/books/ruby/read/arrays#whatisanarray)
+- [@article@Arrays - Odin Project](https://www.theodinproject.com/lessons/ruby-arrays)
+- [@article@Arrrays](https://ruby-for-beginners.rubymonstas.org/built_in_classes/arrays.html)
+- [@video@Arrays are Easy in Ruby for Beginners 9](https://www.youtube.com/watch?v=PeyodDIfLeE)
+- [@video@Arrays | Ruby | Tutorial 13](https://www.youtube.com/watch?v=SP3Vf2KcYeU)

src/data/roadmaps/ruby/content/assignment@NpHLz4I9wwwXX-KBrjdgU.md

@@ -0,0 +1,8 @@
+# Assignment Operators
+
+Assignment operators in Ruby are used to assign values to variables. The most basic assignment operator is the equals sign (=), which assigns the value on the right-hand side to the variable on the left-hand side. Ruby also provides compound assignment operators that combine assignment with arithmetic or bitwise operations, such as +=, -=, \*=, /=, and %=. These operators modify the variable's value by performing the specified operation with the right-hand side operand and then assigning the result back to the variable.
+
+Visit the following resources to learn more:
+
+- [@article@Assignment operators](https://kddnewton.com/2023/07/20/ruby-operators.html#assignment-operators)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/attributes-accessors@I9dIFxsUrysgrcqUSBNsW.md

@@ -0,0 +1,10 @@
+# Attributes Accessors
+
+Attributes accessors provide a convenient way to access and modify the instance variables of a class. They automatically generate methods for reading (getting) and writing (setting) the values of these variables. The three main types are `attr_reader`, which creates a getter method; `attr_writer`, which creates a setter method; and `attr_accessor`, which makes both a getter and a setter method. These accessors simplify code and encapsulate the internal state of objects.
+
+Visit the following resources to learn more:
+
+- [@article@Accessors and Attributes of Class in Ruby](https://www.naukri.com/code360/library/accessors-and-attributes-of-class-in-ruby)
+- [@article@What is an accessor?](https://ruby-doc.org/docs/ruby-doc-bundle/UsersGuide/rg/accessors.html)
+- [@article@Understanding attr methods in Ruby!](https://dev.to/kateh/understanding-attr-methods-in-ruby-412)
+- [@video@How to Use Attribute Accessors in Ruby](https://www.youtube.com/watch?v=C4O7bcbItw4)

src/data/roadmaps/ruby/content/begin-rescue-ensure@-2BSGoXGMMP50en_NnQ97.md

@@ -0,0 +1,10 @@
+# Exception Handling with begin, rescue, and ensure
+
+Exception handling is a mechanism to deal with errors that occur during the execution of a program. In Ruby, the `begin`, `rescue`, and `ensure` keywords provide a structured way to handle these exceptions. The `begin` block encloses the code that might raise an exception. If an exception occurs, the `rescue` block catches and handles it. The `ensure` block, if present, guarantees that its code will always be executed, regardless of whether an exception was raised or not, making it suitable for cleanup operations.
+
+Visit the following resources to learn more:
+
+- [@article@How to Use The “Begin” & “Rescue” Keywords in Ruby](https://www.rubyguides.com/2019/06/ruby-rescue-exceptions/)
+- [@article@Understanding Ruby Error Handling](https://betterstack.com/community/guides/scaling-ruby/ruby-error-handling/)
+- [@article@Unlocking Ruby Keywords: Begin, End, Ensure, Rescue](https://vaidehijoshi.github.io/blog/2015/08/25/unlocking-ruby-keywords-begin-end-ensure-rescue/)
+- [@video@Handling Errors | Ruby | Tutorial 28](https://www.youtube.com/watch?v=J7R94i2bhlI)

src/data/roadmaps/ruby/content/blocks@DzolktV1UUCdSWqmqWgV3.md

@@ -0,0 +1,12 @@
+# Blocks
+
+Blocks are chunks of code that can be passed to methods as if they were arguments. They are defined using either `do...end` or curly braces `{}`. Blocks are not objects themselves, but they can be converted into objects called Procs. Methods can then execute the code within the block using the `yield` keyword. Blocks are a fundamental part of Ruby's expressiveness, allowing for powerful iteration and control flow patterns.
+
+Visit the following resources to learn more:
+
+- [@article@The Ultimate Guide to Blocks, Procs & Lambdas](https://www.rubyguides.com/2016/02/ruby-procs-and-lambdas/)
+- [@article@Blocks and Procs](https://launchschool.com/books/ruby/read/more_stuff#blocksandprocs)
+- [@article@Blocks - Odin Project](https://www.theodinproject.com/lessons/ruby-blocks)
+- [@article@The two common ways to call a Ruby block](https://www.codewithjason.com/two-common-ways-call-ruby-block/)
+- [@video@Blocks, Procs, and Lambda Functions in Ruby](https://www.youtube.com/watch?v=Dh3cSYjHITI)
+- [@video@Ruby Blocks, Procs, and Lambdas 🦁🐅🐻](https://www.youtube.com/watch?v=SADF5diqAJk)

src/data/roadmaps/ruby/content/booleans@Ze02ApxTvyQqtB3VYv3d4.md

@@ -0,0 +1,9 @@
+# Booleans
+
+Booleans represent truth values: either `true` or `false`. They are fundamental for decision-making in Ruby code, allowing programs to execute different blocks of code based on whether a condition is true or false. Boolean values are the result of logical operations and comparisons.
+
+Visit the following resources to learn more:
+
+- [@article@Booleans - Odin Project](https://www.theodinproject.com/lessons/ruby-basic-data-types#booleans)
+- [@article@True, False, and Nil](https://ruby-for-beginners.rubymonstas.org/built_in_classes/true_false_nil.html)
+- [@video@True or False Booleans in Ruby for Beginners 4](https://www.youtube.com/watch?v=zzDNAu3IVpQ)

src/data/roadmaps/ruby/content/break@0gjDinuRDgPV9iTm39ZnS.md

@@ -0,0 +1,9 @@
+# Break Statement in Ruby
+
+The `break` statement in Ruby is a control flow tool used to exit a loop prematurely. When `break` is encountered within a loop (like `for`, `while`, `until`, or `each`), the loop's execution is immediately terminated, and the program continues with the next statement after the loop. It's useful for stopping a loop when a specific condition is met, preventing unnecessary iterations.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding The Ruby Next & Break Keywords](https://www.rubyguides.com/2019/09/ruby-next-break-keywords/)
+- [@article@Controlling Loop Execution](https://launchschool.com/books/ruby/read/loops_iterators#controllloop)
+- [@article@Ruby Explained: Iteration](https://eriktrautman.com/posts/ruby-explained-iteration)

src/data/roadmaps/ruby/content/bundler@Y6yFuFfcdlcupQUFHV3cg.md

@@ -0,0 +1,10 @@
+# Bundler
+
+Bundler is a dependency manager for Ruby. It ensures that an application uses the exact versions of gems (Ruby libraries) that it needs to function correctly. It tracks and installs the specific gem versions required by a project, creating a consistent environment across different machines and deployments. This prevents conflicts and ensures that the application behaves as expected, regardless of where it's run.
+
+Visit the following resources to learn more:
+
+- [@official@Bundler](https://bundler.io/)
+- [@official@What is Bundler?](https://bundler.io/guides/getting_started.html)
+- [@article@The Beginner's Guide to Bundler and Gemfiles](https://www.moncefbelyamani.com/the-beginner-s-guide-to-bundler-and-gemfiles/)
+- [@video@Introduction to Ruby Bundler Gem](https://www.youtube.com/watch?v=nGKAa04hpZE)

src/data/roadmaps/ruby/content/byebug@2y9U11vXpTXHwkIGogzaf.md

@@ -0,0 +1,9 @@
+# Byebug
+
+Byebug is a powerful debugger for Ruby programs. It allows you to step through your code line by line, inspect variables, set breakpoints, and evaluate expressions in real-time. This helps you understand the flow of your program, identify the source of bugs, and fix them more efficiently.
+
+Visit the following resources to learn more:
+
+- [@opensource@byebug](https://github.com/deivid-rodriguez/byebug)
+- [@article@Debugging with ‘ByeBug’ gem](https://medium.com/le-wagon-tokyo/debugging-with-byebug-gem-6a47b2a210bb)
+- [@video@Debugging Ruby With Byebug](https://www.youtube.com/watch?v=toZrovVX4ug)

src/data/roadmaps/ruby/content/case@BiUeOOd9E7V4Gpmu3PWj7.md

@@ -0,0 +1,9 @@
+# Case Statements
+
+A `case` statement in Ruby provides a way to execute different blocks of code based on the value of a variable or expression. It's an alternative to using multiple `if/elsif/else` statements, especially when you need to check for several different possible values. The `case` statement compares a given value against multiple `when` clauses, and executes the code block associated with the first matching clause. An optional `else` clause can be included to handle cases where none of the `when` clauses match.
+
+Visit the following resources to learn more:
+
+- [@article@Case statements](https://www.theodinproject.com/lessons/ruby-conditional-logic#case-statements)
+- [@article@The Many Uses Of Ruby Case Statements](https://www.rubyguides.com/2015/10/ruby-case/)
+- [@video@case..when in Ruby](https://www.youtube.com/watch?v=gsmexAC2eoM)

src/data/roadmaps/ruby/content/chaining-methods@CIV4Ph1B-kUcYv_EqVw2I.md

@@ -0,0 +1,10 @@
+# Chaining Methods
+
+Chaining methods in Ruby lets you call multiple methods on an object in a single line of code. This works because most methods in Ruby return an object (often `self`, the object the method was called on). By returning an object, the next method in the chain can be immediately called on the result of the previous method. This creates a fluent and readable way to perform a series of operations on a single object.
+
+Visit the following resources to learn more:
+
+- [@article@Chaining Methods](https://launchschool.com/books/ruby/read/methods#chainingmethods)
+- [@article@Chaining methods - Odin Project](https://www.theodinproject.com/lessons/ruby-methods#chaining-methods)
+- [@article@A Guide to Method Chaining](https://www.sitepoint.com/a-guide-to-method-chaining/)
+- [@video@How to Read, Analyze & Understand Ruby Method Chains](https://www.youtube.com/watch?v=toeX_3cHqYg)

src/data/roadmaps/ruby/content/closures@yaC-XKRT0dWDFmDqpCvUw.md

@@ -0,0 +1,10 @@
+# Closures
+
+A closure is a block of code that can be passed around and executed later, even after the scope in which it was originally defined has ended. It "closes over" its surrounding environment, capturing the values of variables that were in scope when the closure was created. This allows the closure to access and use those variables even when it's executed in a different context.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding Ruby closures](https://www.codewithjason.com/ruby-closures/)
+- [@article@Closures in Ruby: Blocks, Procs and Lambdas](https://blog.appsignal.com/2018/09/04/ruby-magic-closures-in-ruby-blocks-procs-and-lambdas.html)
+- [@video@Understanding Ruby closures](https://www.youtube.com/watch?v=1OrZ2edTHGQ)
+- [@video@An Introduction to Procs, Lambdas and Closures in Ruby](https://www.youtube.com/watch?v=VBC-G6hahWA)

src/data/roadmaps/ruby/content/comments@PqSnJOOQm3lRoBUs9Fan6.md

@@ -0,0 +1,9 @@
+# Comments
+
+Comments are notes in your code that the Ruby interpreter ignores. They're used to explain what the code does, making it easier for you and others to understand. You can create a single-line comment by starting a line with a `#`. For multi-line comments, you can use `=begin` and `=end` blocks; anything between these markers is treated as a comment.
+
+Visit the following resources to learn more:
+
+- [@official@Code Comments](https://docs.ruby-lang.org/en/master/syntax/comments_rdoc.html)
+- [@article@How To Use Comments in Ruby](https://www.digitalocean.com/community/tutorials/how-to-use-comments-in-ruby)
+- [@video@Comments | Ruby | Tutorial 25](https://www.youtube.com/watch?v=7wbX3OMgqn0)

src/data/roadmaps/ruby/content/comparison@HiDx1OWbSDJJb7APHwG34.md

@@ -0,0 +1,8 @@
+# Comparison Operators
+
+Comparison operators are symbols used to compare two values. These operators evaluate to either `true` or `false` based on the relationship between the values being compared. Common comparison operators include equal to (`==`), not equal to (`!=`), greater than (`>`), less than (`<`), greater than or equal to (`>=`), and less than or equal to (`<=`).
+
+Visit the following resources to learn more:
+
+- [@article@Comparison operators](https://ruby-for-beginners.rubymonstas.org/operators/comparison.html)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/concurrency@oM4ezZoguNFOALXH3Sl6E.md

@@ -0,0 +1,9 @@
+# Concurrency & Parallelism
+
+Concurrency and parallelism are techniques for improving the performance and responsiveness of programs by executing multiple tasks seemingly or actually at the same time. Concurrency deals with managing multiple tasks within a single program, allowing them to make progress even if one task is blocked. Parallelism, on the other hand, involves physically executing multiple tasks simultaneously, typically by distributing them across multiple processor cores.
+
+Visit the following resources to learn more:
+
+- [@article@Ruby Concurrency and Parallelism: A Practical Tutorial](http://toptal.com/developers/ruby/ruby-concurrency-and-parallelism-a-practical-primer)
+- [@article@Parallelism and concurrency in Ruby](https://msuliq.medium.com/concurrency-and-parallin-ruby-91d10045d2fe)
+- [@video@RailsConf 2016 - Introduction to Concurrency in Ruby by Thijs Cadier](https://www.youtube.com/watch?v=5AxtY4dfuwc)

src/data/roadmaps/ruby/content/concurrent-ruby@toevE0eM7c5f_zeSaVjdr.md

@@ -0,0 +1,8 @@
+# Concurrent Ruby
+
+Concurrent Ruby is a library that provides tools and abstractions for concurrent and parallel programming in Ruby. It offers features like actors, promises, dataflow variables, and thread pools to help developers write efficient and thread-safe code, enabling them to take advantage of multi-core processors and improve application performance.
+
+Visit the following resources to learn more:
+
+- [@official@Concurrent Ruby](https://ruby-concurrency.github.io/concurrent-ruby/1.3.6/index.html)
+- [@opensource@concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby)

src/data/roadmaps/ruby/content/conditional-statements@FIALdP3ZhOlzW-OIlJoT2.md

@@ -0,0 +1,9 @@
+# Conditional Statements
+
+Conditional statements allow you to execute different blocks of code based on whether a certain condition is true or false. They provide a way to control the flow of your program, enabling it to make decisions and respond differently to various inputs or situations. Common conditional statements include `if`, `elsif`, and `else`, which let you define different code paths depending on the evaluation of boolean expressions.
+
+Visit the following resources to learn more:
+
+- [@article@Conditional Logic](https://www.theodinproject.com/lessons/ruby-conditional-logic#case-statements)
+- [@article@Conditionals](https://launchschool.com/books/ruby/read/flow_control#conditionals)
+- [@article@Ruby Explained: Conditionals and Flow Control](https://eriktrautman.com/posts/ruby-explained-conditionals-and-flow-control)

src/data/roadmaps/ruby/content/conditional-statements@jw218cE_PQDRnOTzCXpXr.md

@@ -0,0 +1,9 @@
+# Conditional Statements
+
+Conditional statements allow you to execute different blocks of code based on whether a certain condition is true or false. They provide a way to control the flow of your program, enabling it to make decisions and respond differently to various inputs or situations. Common conditional statements include `if`, `elsif`, `else`, and `unless`.
+
+Visit the following resources to learn more:
+
+- [@article@Conditional Logic](https://www.theodinproject.com/lessons/ruby-conditional-logic)
+- [@article@The Beginner's Guide to Ruby If & Else Statements](http://rubyguides.com/ruby-tutorial/ruby-if-else/)
+- [@article@Ruby - if...else, case, unless](https://www.tutorialspoint.com/ruby/ruby_if_else.htm)

src/data/roadmaps/ruby/content/constants--variables@FfM3pPbyP1VsvWousb3YK.md

@@ -0,0 +1,12 @@
+# Constants & Variables
+
+In Ruby, variables are named storage locations that hold data, and their values can be changed during the program's execution. Constants, on the other hand, are also named storage locations, but their values are intended to remain fixed throughout the program's runtime. While Ruby technically allows you to reassign a constant (it will issue a warning), the convention is to treat them as immutable values that should not be altered. Variables are typically named using snake\_case, while constants are named using SCREAMING\_SNAKE\_CASE.
+
+Visit the following resources to learn more:
+
+- [@article@Variables](https://ruby-for-beginners.rubymonstas.org/variables.html)
+- [@article@Ruby Variables](https://www.tutorialspoint.com/ruby/ruby_variables.htm)
+- [@article@Everything You Need to Know About Ruby Constants](https://www.rubyguides.com/2017/07/ruby-constants/)
+- [@article@Getting Started with Ruby Variables: A Beginner’s Guide](https://medium.com/@sz.soczewka/getting-started-with-ruby-variables-a-beginners-guide-d90a53eb5139)
+- [@video@Variables | Ruby | Tutorial 6](https://www.youtube.com/watch?v=4mWc6Q9shcQ)
+- [@video@Ruby Programming Tutorial - 20 - Constants](https://www.youtube.com/watch?v=qAqGIMKIMcA)

src/data/roadmaps/ruby/content/data-types@wsnjdnZZohQsVBfM1uN8H.md

@@ -0,0 +1,10 @@
+# Data Types
+
+Data types are classifications that specify which type of value a variable can hold and what operations can be performed on it. They define the kind of data, such as numbers, text, or boolean values, that can be stored and manipulated within a program. Understanding data types is fundamental to writing correct and efficient code, as it allows the program to handle different kinds of information appropriately.
+
+Visit the following resources to learn more:
+
+- [@article@Basic Data Types](https://www.theodinproject.com/lessons/ruby-basic-data-types)
+- [@article@Understanding Data Types in Ruby](https://www.digitalocean.com/community/tutorials/understanding-data-types-in-ruby)
+- [@article@Ruby DataTypes: Explore the Fundamentals](https://www.theknowledgeacademy.com/blog/ruby-data-types/)
+- [@video@Data Types | Ruby | Tutorial 7](https://www.youtube.com/watch?v=rjLB_bD3SLU)

src/data/roadmaps/ruby/content/date--time@RGo3VGXftLx877w0Cxhwb.md

@@ -0,0 +1,12 @@
+# Date & Time
+
+Date and Time represent specific points in time. They allow you to work with dates (year, month, day) and times (hour, minute, second) and perform operations like calculating durations, formatting dates for display, and comparing different points in time. They are essential for handling events, scheduling tasks, and managing temporal data.
+
+Visit the following resources to learn more:
+
+- [@official@class Date](https://docs.ruby-lang.org/en/master/Date.html)
+- [@official@class Time](https://docs.ruby-lang.org/en/master/Time.html)
+- [@article@How to Use Ruby Time & Date Classes](https://www.rubyguides.com/2015/12/ruby-time/)
+- [@article@Ruby - Date & Time](https://www.tutorialspoint.com/ruby/ruby_date_time.htm)
+- [@video@Ruby Tutorial For Beginners - Date and Time in Ruby](https://www.youtube.com/watch?v=noUaGvexdok)
+- [@video@#62 Ruby Tutorial : Date and DateTime Class Part - 3](https://www.youtube.com/watch?v=htxjcfvGmu4)

src/data/roadmaps/ruby/content/debug@JSauSDvDotwrWZiyLuWks.md

@@ -0,0 +1,8 @@
+# Debug
+
+`debug` is a powerful debugging tool integrated directly into Ruby. It allows developers to step through code execution, inspect variables, set breakpoints, and evaluate expressions in real-time. This helps in identifying and resolving errors or unexpected behavior within Ruby programs.
+
+Visit the following resources to learn more:
+
+- [@official@debug](https://github.com/ruby/debug)
+- [@article@ruby/debug cheatsheet](https://st0012.dev/2022/09/08/ruby-debug-cheatsheet/)

src/data/roadmaps/ruby/content/define_method@iwLZktEcLmnahj4o-IgWB.md

@@ -0,0 +1,10 @@
+# define_method
+
+`define_method` is a method used to dynamically create new methods within a class or module. Instead of explicitly writing out the method definition with the `def` keyword, `define_method` allows you to generate methods at runtime, often based on data or logic that isn't known until the program is running. This provides a powerful way to reduce code duplication and create more flexible and adaptable code.
+
+Visit the following resources to learn more:
+
+- [@article@Dynamic method definition with ruby’s .define_method](https://medium.com/@camfeg/dynamic-method-definition-with-rubys-define-method-b3ffbbee8197)
+- [@article@Explain Ruby's define_method like I'm five](https://dev.to/tiffanywismer/explain-rubys-definemethod-like-im-five-2807)
+- [@video@define_method - Metaprogramming in Ruby](https://www.youtube.com/watch?v=I0itVuoprAY)
+- [@video@Ruby Tutorial | Metaprogramming in Ruby - Dynamic Method Definition](https://www.youtube.com/watch?v=bg2KvfwxDnM)

src/data/roadmaps/ruby/content/defining-classes@lPPdaW7EEyUCxV41ljvPY.md

@@ -0,0 +1,11 @@
+# Defining Classes
+
+A class is a blueprint for creating objects. It defines the attributes (data) and behaviors (methods) that objects of that class will possess. Defining a class involves specifying its name and the characteristics that its instances will have. This includes declaring instance variables to hold data and defining methods to perform actions on that data.
+
+Visit the following resources to learn more:
+
+- [@article@How to Write Your Own Classes in Ruby (Explained Clearly)](https://www.rubyguides.com/2019/02/ruby-class/)
+- [@article@A Beginner’s Guide to Ruby Classes (Part 1)](https://medium.com/@grahamwatson/a-beginners-guide-to-ruby-classes-f8dec30d5821)
+- [@article@Ruby Classes Refresher](https://codesignal.com/learn/courses/ruby-classes-basics-revision/lessons/understanding-ruby-classes-a-refresher-on-attributes-and-methods)
+- [@video@Classes & Objects | Ruby | Tutorial 29](https://www.youtube.com/watch?v=sc5RhTIBf4c)
+- [@video@Learn classes in Ruby in less than 20 minutes](https://www.youtube.com/watch?v=XyoOOxGR54A)

src/data/roadmaps/ruby/content/defining-methods@CkYLHSGH8dmfS5fK2JLfH.md

@@ -0,0 +1,11 @@
+# Defining Methods
+
+Methods, also known as functions in other programming languages, are reusable blocks of code designed to perform a specific task. Defining a method involves specifying its name, the parameters it accepts (if any), and the sequence of instructions it executes. This allows you to organize your code into logical units, making it more readable, maintainable, and reusable throughout your program.
+
+Visit the following resources to learn more:
+
+- [@official@Methods](https://docs.ruby-lang.org/en/master/syntax/methods_rdoc.html)
+- [@article@Methods - Odin Project](https://www.theodinproject.com/lessons/ruby-methods)
+- [@article@Objects, Classes, Methods](https://ruby-for-beginners.rubymonstas.org/objects.html)
+- [@article@Ruby - Methods](https://www.tutorialspoint.com/ruby/ruby_methods.htm)
+- [@video@Methods | Ruby | Tutorial 15](https://www.youtube.com/watch?v=e1EpXUgSfN8)

src/data/roadmaps/ruby/content/dowhile@OwRukUn8ypko_hPUHkxv_.md

@@ -0,0 +1,8 @@
+# do/while Loops
+
+`do/while` loops are a type of control flow statement that executes a block of code at least once, and then repeatedly executes the block as long as a specified condition is true. The condition is checked _after_ the code block is executed, ensuring the block runs at least one time regardless of the initial state of the condition. This is different from a `while` loop, where the condition is checked _before_ the code block is executed.
+
+Visit the following resources to learn more:
+
+- [@article@Ruby Loops](https://www.codecademy.com/resources/docs/ruby/loops)
+- [@video@Ruby For Beginners #5 - Loops | For, While, Do, Do While](https://www.youtube.com/watch?v=Q_zP40toAMY)

src/data/roadmaps/ruby/content/each@iJ7e3-VJV6l-Qe-b5yAgC.md

@@ -0,0 +1,9 @@
+# Each
+
+`each` is a fundamental method in Ruby used to iterate over elements within a collection, such as an array or a hash. It applies a given block of code to each element in the collection, allowing you to perform operations on every item. The `each` method does not modify the original collection; it simply iterates through it.
+
+Visit the following resources to learn more:
+
+- [@official@Iterators](https://www.ruby-lang.org/en/documentation/faq/5/)
+- [@article@Iterators](https://launchschool.com/books/ruby/read/loops_iterators#iterators)
+- [@article@Ruby Explained: Iteration](https://eriktrautman.com/posts/ruby-explained-iteration)

src/data/roadmaps/ruby/content/enumerable@7lMZv3oRfC1UWAOfRvvwC.md

@@ -0,0 +1,11 @@
+# Enumerable
+
+Enumerable is a module in Ruby that provides a collection of useful iteration methods. It's designed to be mixed into classes that represent collections of data, such as arrays and hashes. By including Enumerable, a class gains the ability to iterate over its elements and perform operations like searching, filtering, sorting, and transforming data in a concise and readable way.
+
+Visit the following resources to learn more:
+
+- [@official@module Enumerable](https://ruby-doc.org/3.4.1/Enumerable.html)
+- [@article@Basic Enumerable Methods](https://www.theodinproject.com/lessons/ruby-basic-enumerable-methods)
+- [@article@Enumerable](https://rubyreferences.github.io/rubyref/builtin/types/enumerable.html)
+- [@article@An Introduction to Ruby Enumerators and the Enumerable Module](https://betterstack.com/community/guides/scaling-ruby/enumerators-enumerable/)
+- [@video@How to use Enumerable with Ruby Classes](https://www.youtube.com/watch?v=zALFRuKZQYc)

src/data/roadmaps/ruby/content/enumerable@jw218cE_PQDRnOTzCXpXr.md

@@ -0,0 +1,9 @@
+# Conditional Statements
+
+Conditional statements allow you to execute different blocks of code based on whether a certain condition is true or false. They provide a way to control the flow of your program, enabling it to make decisions and respond differently to various inputs or situations. Common conditional statements include `if`, `elsif`, `else`, and `unless`.
+
+Visit the following resources to learn more:
+
+- [@article@Conditional Logic](https://www.theodinproject.com/lessons/ruby-conditional-logic)
+- [@article@The Beginner's Guide to Ruby If & Else Statements](http://rubyguides.com/ruby-tutorial/ruby-if-else/)
+- [@article@Ruby - if...else, case, unless](https://www.tutorialspoint.com/ruby/ruby_if_else.htm)

src/data/roadmaps/ruby/content/everything-is-an-object@vnDB786JPJGLIEbaQuXn2.md

@@ -0,0 +1,10 @@
+# Everything is an Object
+
+In Ruby, everything you encounter – numbers, strings, arrays, even classes and methods – is treated as an object. This means that each of these entities is an instance of a class and possesses both state (data) and behavior (methods) that can be invoked. This unified object model is a fundamental characteristic of Ruby's design.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding the Ruby Object Model In Depth](https://www.honeybadger.io/blog/ruby-object-model/)
+- [@article@Everything is object in Ruby](https://medium.com/@pk60905/everything-is-object-in-ruby-559475ce71dd)
+- [@article@Ruby: Everything Is An Object?](https://reinteractive.com/articles/tutorial-series-new-to-rails/ruby-everything-is-an-object)
+- [@video@Ruby Programming Tutorial - 9 - Everything is an Object!](https://www.youtube.com/watch?v=F75wFJIa368)

src/data/roadmaps/ruby/content/fetching@PQX6c9h1O_p-ExDvC88zl.md

@@ -0,0 +1,9 @@
+# Fetching
+
+`Enumerable` comes with some methods that allow you to retrieve entries from the Enumerable, without modifying it. This includes methods to get leading and trailing elements, extract minimum and maximum value elements, as well as conduct groups, slices, and partitions.
+
+Visit the following resources to learn more:
+
+- [@article@https://ruby-doc.org/3.4.1/Enumerable.html#top](https://ruby-doc.org/3.4.1/Enumerable.html#top)
+- [@article@Getting to know Ruby's Enumerable Module](https://www.rafaelmontas.com/getting-to-know-ruby-enumerable-module/)
+- [@article@The Simple Yet Powerful Ruby Enumerable Module](https://www.cloudbees.com/blog/the-enumerable-module)

src/data/roadmaps/ruby/content/fibers@ZSBRUhjgQNJNbCuLYEiJJ.md

@@ -0,0 +1,3 @@
+# Fibers
+
+Fibers are a lightweight way to achieve concurrency. They are essentially blocks of code that can be paused and resumed, allowing you to switch between different execution contexts within a single thread. This enables cooperative multitasking, where the programmer explicitly controls when to switch between different parts of the program.

src/data/roadmaps/ruby/content/fibers@_ruCDzzaSuoE_8tRacTeK.md

@@ -0,0 +1,10 @@
+# Fibers
+
+Fibers are a lightweight concurrency construct that allows you to create code blocks that can be paused and resumed. They provide a way to implement cooperative multitasking within a single thread, enabling you to manage multiple tasks without the overhead of creating and managing multiple threads or processes. Fibers are useful for scenarios where you need fine-grained control over the execution flow and want to avoid the complexities of thread synchronization.
+
+Visit the following resources to learn more:
+
+- [@book@Magesh, "Concurrency in Ruby: Threads, Fibers, and Ractors Demystified"](https://www.youtube.com/watch?v=LVHiq_SbQOE)
+- [@official@class Fiber](https://docs.ruby-lang.org/en/master/Fiber.html)
+- [@article@How to use Ruby Fibers for Background Jobs](https://medium.com/@alieckaja/unleashing-the-power-of-fibers-for-background-jobs-8a22e3a38cd1)
+- [@article@Ruby Fibers 101](https://blog.saeloun.com/2022/03/01/ruby-fibers-101/)

src/data/roadmaps/ruby/content/file-io@UQeCaogH4IJg4_Inxsjg1.md

@@ -0,0 +1,11 @@
+# File I/O
+
+File I/O involves reading data from and writing data to files. It allows your Ruby programs to interact with files on your computer's file system. You can open files, read their contents line by line or in chunks, write new data to them, or append data to existing files. This interaction is essential for tasks like reading configuration files, processing data from external sources, and saving program output.
+
+Visit the following resources to learn more:
+
+- [@official@class IO](https://docs.ruby-lang.org/en/master/IO.html)
+- [@article@Input & Output (IO) In Ruby: The Definitive Guide](https://www.rubyguides.com/2019/02/ruby-io/)
+- [@article@Ruby - FIlei/o](https://www.tutorialspoint.com/ruby/ruby_input_output.htm)
+- [@video@Reading Files | Ruby | Tutorial 26](https://www.youtube.com/watch?v=92li0A8d4io)
+- [@video@Writing Files | Ruby | Tutorial 27](https://www.youtube.com/watch?v=FW9hDsMY1is)

src/data/roadmaps/ruby/content/floats@aLIXcqB258WNrdASuN_7G.md

@@ -0,0 +1,10 @@
+# Floats
+
+Floats represent real numbers with fractional parts in Ruby. They are used to store numerical values that require more precision than integers can provide. Floats are typically represented using a decimal point or in scientific notation.
+
+Visit the following resources to learn more:
+
+- [@official@class Floar](https://docs.ruby-lang.org/en/master/Float.html)
+- [@article@Numbers](https://ruby-for-beginners.rubymonstas.org/built_in_classes/numbers.html)
+- [@article@Numbers - Odin Project](https://www.theodinproject.com/lessons/ruby-basic-data-types#numbers)
+- [@video@03 Ruby Learning Path Integers and Floats](https://www.youtube.com/watch?v=FScOX-TavfA)

src/data/roadmaps/ruby/content/for@VlhY73X3c0PnA1uYjbfZH.md

@@ -0,0 +1,9 @@
+# For Loop
+
+The `for` loop in Ruby provides a way to iterate over a sequence of values, such as elements in an array or a range. It executes a block of code for each item in the sequence. While functional, the `for` loop is not as commonly used in Ruby as other iteration methods like `each`, `map`, or `select`, which are often considered more idiomatic and flexible.
+
+Visit the following resources to learn more:
+
+- [@article@For Loops](https://launchschool.com/books/ruby/read/loops_iterators#forloops)
+- [@article@For loop](https://www.theodinproject.com/lessons/ruby-loops#for-loop)
+- [@video@Ruby For Beginners #5 - Loops | For, While, Do, Do While](https://www.youtube.com/watch?v=Q_zP40toAMY)

src/data/roadmaps/ruby/content/handling-exceptions@aZYZcRlB1Azm4N_jox0Ow.md

@@ -0,0 +1,11 @@
+# Handling Exceptions
+
+Exception handling is a mechanism to deal with errors that occur during the execution of a program. It involves identifying potential error-prone sections of code, anticipating possible exceptions, and implementing specific blocks of code to gracefully handle these exceptions, preventing the program from crashing and allowing it to continue execution or terminate in a controlled manner.
+
+Visit the following resources to learn more:
+
+- [@official@Exceptions](https://docs.ruby-lang.org/en/master/language/exceptions_md.html)
+- [@official@Exception Handling](https://docs.ruby-lang.org/en/3.4/syntax/exceptions_rdoc.html)
+- [@article@Handling Exceptions in Ruby (begin/rescue)](https://medium.com/@alexfarmer/handling-exceptions-in-ruby-b4ba93caf538)
+- [@article@Understanding Ruby Error Handling](https://betterstack.com/community/guides/scaling-ruby/ruby-error-handling/)
+- [@video@Handling Errors | Ruby | Tutorial 28](https://www.youtube.com/watch?v=J7R94i2bhlI)

src/data/roadmaps/ruby/content/hashes@mpsx0lr9ljlMEzuU5cZD6.md

@@ -0,0 +1,11 @@
+# Ruby Hashes
+
+Hashes are collections of key-value pairs. Think of them like dictionaries, where each word (the key) has a definition (the value). Keys are unique within a hash, and they are used to quickly access their corresponding values. Hashes can store any type of data as keys and values, making them a versatile way to organize and retrieve information.
+
+Visit the following resources to learn more:
+
+- [@official@class Hash](https://docs.ruby-lang.org/en/master/Hash.html)
+- [@article@What is a Hash](https://launchschool.com/books/ruby/read/hashes#whatisahash)
+- [@article@Hashes - Odin Project](https://www.theodinproject.com/lessons/ruby-hashes)
+- [@video@Hashes | Ruby | Tutorial 14](https://www.youtube.com/watch?v=BtHKhsDUPwQ)
+- [@video@Ruby Programming Tutorial - 31 - Hashes](https://www.youtube.com/watch?v=imns9_XncQU)

src/data/roadmaps/ruby/content/if-elsif-else@cVSN9992bpxZwZ9JC1HHg.md

@@ -0,0 +1,10 @@
+# Conditional Statements (if, elsif, else)
+
+Conditional statements allow you to execute different blocks of code based on whether a certain condition is true or false. The `if` statement executes a block of code if a condition is true. The `elsif` statement (optional) allows you to check additional conditions if the initial `if` condition is false. The `else` statement (optional) provides a block of code to execute if none of the preceding conditions are true.
+
+Visit the following resources to learn more:
+
+- [@article@Conditionals](https://ruby-for-beginners.rubymonstas.org/conditionals.html)
+- [@article@The Beginner's Guide to Ruby If & Else Statements](https://www.rubyguides.com/ruby-tutorial/ruby-if-else/)
+- [@article@Conditional logic](https://www.theodinproject.com/lessons/ruby-conditional-logic)
+- [@video@If Statements | Ruby | Tutorial 17](https://www.youtube.com/watch?v=Ss-IHmrSTow)

src/data/roadmaps/ruby/content/ineractive-ruby-irb@uvPvcmhaO6WbkE9Xs5hsJ.md

@@ -0,0 +1,10 @@
+# Interactive Ruby (irb)
+
+Interactive Ruby (irb) is a command-line tool that allows you to execute Ruby code interactively. It provides a read-eval-print loop (REPL) environment where you can type in Ruby expressions, and irb will immediately evaluate and display the result. This makes it a valuable tool for experimenting with code, testing ideas, and quickly checking the behavior of Ruby methods and objects.
+
+Visit the following resources to learn more:
+
+- [@article@How To Use IRB to Explore Ruby](https://www.digitalocean.com/community/tutorials/how-to-use-irb-to-explore-ruby)
+- [@article@Interactive Ruby](https://ruby-for-beginners.rubymonstas.org/your_tools/irb.html)
+- [@article@Interactive Ruby](https://ruby-doc.org/docs/ruby-doc-bundle/Tutorial/part_01/first_steps.html)
+- [@video@Inteactive Ruby (irb) | Ruby | Tutorial 35](https://www.youtube.com/watch?v=9pKLGhh5mrM)

src/data/roadmaps/ruby/content/inheritance@7HSJh15ice_CG3FtfQ5x6.md

@@ -0,0 +1,11 @@
+# Inheritance
+
+Inheritance in Ruby allows a class (the subclass or derived class) to inherit properties and behaviors from another class (the superclass or base class). This promotes code reuse and establishes an "is-a" relationship. The subclass automatically gains the methods and attributes of the superclass, and can also add its own or override existing ones to customize its behavior.
+
+Visit the following resources to learn more:
+
+- [@article@Inheritance](https://launchschool.com/books/oo_ruby/read/inheritance)
+- [@article@Ruby — Inheritance and Module](https://medium.com/swlh/ruby-inheritance-and-module-cc0132348dcd)
+- [@article@Ruby Inheritance Explained – Learn OOP Today!](https://www.rubyguides.com/2019/01/what-is-inheritance-in-ruby/)
+- [@video@Inheritance | Ruby | Tutorial 33](https://www.youtube.com/watch?v=Zkk7whVb3f4)
+- [@video@Ruby Programming Tutorial - 6 - Inheritance](https://www.youtube.com/watch?v=mKXGMdWa1Ow)

src/data/roadmaps/ruby/content/installers@zY4gsqXOOT3yp9ad9-T5a.md

@@ -0,0 +1,11 @@
+# Installers
+
+Installers are software packages designed to simplify the process of setting up Ruby on your computer. They typically handle downloading the necessary files, configuring your system environment, and ensuring that Ruby and its related tools are ready to use. Using an installer avoids the complexities of manual installation, making it easier for beginners to get started with Ruby development.
+
+Visit the following resources to learn more:
+
+- [@official@Installers - Ruby Docs](https://www.ruby-lang.org/en/documentation/installation/#installers)
+- [@official@RubyInstaller (Windows)](https://rubyinstaller.org/)
+- [@official@Ruby Stack](https://bitnami.com/stack/ruby/installer)
+- [@opensource@ruby-build (macOS, Linux, UNIX OS)](https://github.com/rbenv/ruby-build#readme)
+- [@opensource@ruby-install (macOS, Linux, UNIX OS)](https://github.com/postmodern/ruby-install#readme)

src/data/roadmaps/ruby/content/installing-ruby@Av5hlCtE-ZoeKpS0k3kLA.md

@@ -0,0 +1,12 @@
+# Installing Ruby
+
+Installing Ruby involves setting up the Ruby interpreter and related tools on your system so you can run Ruby programs. This typically includes downloading a Ruby distribution, configuring your environment, and verifying the installation to ensure everything is working correctly. Different operating systems (like Windows, macOS, and Linux) have their own preferred methods for installing Ruby, often involving package managers or dedicated installers.
+
+Visit the following resources to learn more:
+
+- [@official@Installing Ruby](https://www.ruby-lang.org/en/documentation/installation/)
+- [@article@Installing Ruby](https://www.theodinproject.com/lessons/ruby-installing-ruby)
+- [@article@How to Install Ruby on Windows, macOS, and Linux](https://dev.to/luigi_ichi/how-to-install-ruby-on-windows-macos-and-linux-35o3)
+- [@article@Setting up Ruby on WSL2 using Rbenv](https://codex.org/2022/08/19/setting-up-ruby-wsl2.html)
+- [@video@Ruby Beginner Tutorial 2 | How To Install Ruby On Windows](https://www.youtube.com/watch?v=XC1ccTyhLPI)
+- [@video@Ruby Beginner Tutorial 3 | How To Install Ruby On MacOS](https://www.youtube.com/watch?v=2pycF6hMy0s)

src/data/roadmaps/ruby/content/instance-variables@dbdllih50mNFBrP9huQz9.md

@@ -0,0 +1,9 @@
+# Instance Variables
+
+Instance variables in Ruby are variables that hold data specific to an object. They are defined within a class but belong to individual instances (objects) of that class. You create an instance variable by prefixing a variable name with an `@` symbol (e.g., `@name`). Each object of the class will have its own copy of these variables, allowing you to store different values for each object's attributes.
+
+Visit the following resources to learn more:
+
+- [@article@Read This If You Want to Understand Instance Variables in Ruby](https://www.rubyguides.com/2019/07/ruby-instance-variables/)
+- [@article@Understanding Ruby Objects and Instance Variables](https://dev.to/bhumi/understanding-ruby-objects-and-instance-variables-4157)
+- [@video@Instances and Instance Variables in Ruby Programming](https://www.youtube.com/watch?v=H27i3WuAEVI)

src/data/roadmaps/ruby/content/integers@_-bUq5jtewDmsmnzYw1-q.md

@@ -0,0 +1,10 @@
+# Integers
+
+Integers are whole numbers, meaning they don't have any fractional or decimal parts. They can be positive, negative, or zero. In programming, integers are used to represent countable quantities, indices, and other discrete values.
+
+Visit the following resources to learn more:
+
+- [@official@class Integer](https://docs.ruby-lang.org/en/master/Integer.html)
+- [@article@Numbers](https://ruby-for-beginners.rubymonstas.org/built_in_classes/numbers.html)
+- [@article@Numbers - Odin Project](https://www.theodinproject.com/lessons/ruby-basic-data-types#numbers)
+- [@video@03 Ruby Learning Path Integers and Floats](https://docs.ruby-lang.org/en/master/Integer.html)

src/data/roadmaps/ruby/content/introduction@A_ftl-42mIGBk-9S5LgCv.md

@@ -0,0 +1,15 @@
+# Ruby
+
+Ruby is a dynamic, open-source programming language known for its simplicity and productivity. It emphasizes human readability, using a syntax that is easy to learn and write. Ruby is object-oriented, meaning everything is treated as an object, and it supports multiple programming paradigms, including procedural, object-oriented, and functional programming.
+
+Visit the following resources to learn more:
+
+- [@book@The Ruby Programming Language](https://github.com/maniramakumar/the-best-ruby-books/blob/master/books/The%20Ruby%20Programming%20Language.pdf)
+- [@official@Ruby](https://www.ruby-lang.org/en/)
+- [@official@Documentation](https://www.ruby-lang.org/en/documentation/)
+- [@official@Ruby in Twenty Minutes](https://www.ruby-lang.org/en/documentation/quickstart/)
+- [@article@Ruby Tutorial](https://www.tutorialspoint.com/ruby/index.htm)
+- [@article@Learn Ruby Online](https://www.learnrubyonline.org/)
+- [@video@Ruby Programming Language - Full Course](https://www.youtube.com/playlist?list=PL_EzhIKp343lBMH4UuklrMRL_WkilGoXe)
+- [@video@Masterclass | Ruby Programming in 1 video | Beginners Ruby HandsOn Crash Course Interview FAQs |](https://www.youtube.com/watch?v=xyDoP5a_dvo)
+- [@feed@Explore top posts about Ruby](https://app.daily.dev/tags/ruby?ref=roadmapsh)

src/data/roadmaps/ruby/content/irb@_TyiwnXJ7kQI8Z02ooAIy.md

@@ -0,0 +1,9 @@
+# Debugging with IRB
+
+IRB (Interactive Ruby) is a powerful tool for debugging Ruby code. It allows you to execute Ruby code line by line, inspect variables, and test code snippets in real-time. This interactive environment helps you understand how your code behaves, identify errors, and experiment with different solutions without having to run your entire program. You can use IRB to step through your code, set breakpoints, and examine the state of your application at any point during execution.
+
+Visit the following resources to learn more:
+
+- [@official@Debugging with IRB](https://ruby.github.io/irb/#label-Debugging+with+IRB)
+- [@article@A Beginner’s Guide to Debugging in Ruby](https://medium.com/@claire_logan/a-beginners-guide-to-debugging-in-ruby-b8103d7ad35b)
+- [@video@Ruby Debugging Tools: irb, pry, byebug, debug | Talk.rb](https://www.youtube.com/watch?v=Jx5SdGUezY0)

src/data/roadmaps/ruby/content/iterating@frFY2AeO2BQF6I0CmTLkV.md

@@ -0,0 +1,9 @@
+# Iterating with Enumerable
+
+The `Enumerable` module in Ruby provides a collection of methods that allow you to traverse and process elements within a collection (like an array or hash). These iterating methods, such as `each`, `map`, `select`, and `reject`, simplify the process of performing actions on each item in the collection, transforming the collection, or filtering elements based on specific conditions. They abstract away the need for manual indexing and provide a more concise and readable way to work with collections.
+
+Visit the following resources to learn more:
+
+- [@article@module Enumerable](https://ruby-doc.org/3.4.1/Enumerable.html#top)
+- [@article@Programación Iterating in Ruby: Enumerable and Enumerators](https://libreim.github.io/blog/2015/08/24/ruby-enumerators/)
+- [@article@Understanding Ruby - Enumerable - Iterating and Taking](https://dev.to/baweaver/understanding-ruby-enumerable-iterating-and-taking-1fga)

src/data/roadmaps/ruby/content/lambdas@Tb5DcDuAZNyuIPepJ_yy4.md

@@ -0,0 +1,11 @@
+# Lambdas
+
+Lambdas are anonymous functions, meaning they are functions without a name. They are objects in Ruby and can be treated like any other object, such as being passed as arguments to methods or stored in variables. Lambdas are defined using the `lambda` keyword or the shorthand `->` syntax, and they are similar to procs but differ in how they handle arguments and `return` statements.
+
+Visit the following resources to learn more:
+
+- [@article@An Introduction to Lambdas in Ruby](https://blog.appsignal.com/2023/06/21/an-introduction-to-lambdas-in-ruby.html)
+- [@article@https://www.rubyguides.com/2016/02/ruby-procs-and-lambdas/](https://www.rubyguides.com/2016/02/ruby-procs-and-lambdas/)
+- [@article@How to Use Lambdas in Ruby](https://www.scoutapm.com/blog/how-to-use-lambdas-in-ruby)
+- [@video@Ruby Blocks, Procs, and Lambdas 🦁🐅🐻](https://www.youtube.com/watch?v=SADF5diqAJk)
+- [@video@Blocks, Procs, and Lambda Functions in Ruby](https://www.youtube.com/watch?v=Dh3cSYjHITI)

src/data/roadmaps/ruby/content/logical@vLgIRI5GD9ANBjYJoZmid.md

@@ -0,0 +1,8 @@
+# Logical Operators in Ruby
+
+Logical operators in Ruby let you combine or modify boolean expressions (true or false). The main ones are `&&` (and), `||` (or), and `!` (not). `&&` returns true only if both operands are true. `||` returns true if at least one operand is true. `!` reverses the boolean value of its operand, turning true into false and vice versa. These operators are fundamental for controlling program flow based on different conditions.
+
+Visit the following resources to learn more:
+
+- [@article@Logical operators](https://ruby-for-beginners.rubymonstas.org/operators/logical.html)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/loops--enumerations@dRfPXHrI5CHCELySKLZuQ.md

@@ -0,0 +1,10 @@
+# Loops & Enumerations
+
+Loops in Ruby allow you to execute a block of code repeatedly. Enumerations, on the other hand, are methods that iterate over collections like arrays and hashes, applying a block of code to each element. Both loops and enumerations provide ways to process data and perform actions multiple times, but enumerations are often preferred for their conciseness and readability when working with collections.
+
+Visit the following resources to learn more:
+
+- [@article@Loops and Iterators](https://launchschool.com/books/ruby/read/loops_iterators#simpleloop)
+- [@article@Loops](https://www.theodinproject.com/lessons/ruby-loops)
+- [@article@Ruby Loops: Repeating Something Many Times](https://www.rubyguides.com/ruby-tutorial/loops/)
+- [@article@Ruby - Loops](https://www.tutorialspoint.com/ruby/ruby_loops.htm)

src/data/roadmaps/ruby/content/managers@RnKFjcscp8nqwesQ06YWU.md

@@ -0,0 +1,7 @@
+# Ruby Version Managers
+
+Ruby version managers are tools that allow you to install and manage multiple versions of Ruby on the same system. This is useful because different projects may require different Ruby versions, and using a version manager prevents conflicts and simplifies switching between them. They typically work by modifying your shell environment to point to the desired Ruby installation.
+
+Visit the following resources to learn more:
+
+- [@official@Managers - Ruby Docs](https://www.ruby-lang.org/en/documentation/installation/#managers)

src/data/roadmaps/ruby/content/metaprogramming@ufLdyKM3iya8zuMD1_sIj.md

@@ -0,0 +1,12 @@
+# Metaprogramming
+
+Metaprogramming is essentially writing code that manipulates other code. It allows you to define methods, classes, or even modify existing ones at runtime. This means your program can dynamically adapt and change its behavior based on conditions or data it encounters while running, rather than being fixed at compile time.
+
+Visit the following resources to learn more:
+
+- [@book@Metaprogramming Ruby.pdf](https://theswissbay.ch/pdf/Gentoomen%20Library/Programming/Ruby/Metaprogramming%20Ruby.pdf)
+- [@article@Ruby Metaprogramming: How to Write Dynamic Code](https://betterstack.com/community/guides/scaling-ruby/metaprogramming/)
+- [@article@An Introduction to Metaprogramming in Ruby](https://blog.appsignal.com/2023/07/26/an-introduction-to-metaprogramming-in-ruby.html)
+- [@article@Ruby Metaprogramming: Real-World Examples](https://www.rubyguides.com/2016/04/metaprogramming-in-the-wild/)
+- [@article@Ruby Metaprogramming Secrets](https://www.rubyguides.com/guides/metaprogramming-guide.pdf)
+- [@video@RubyConf 2022: In Defense of Ruby Metaprogramming By Noel Rappin](https://www.youtube.com/watch?v=D_ZRaZucjm4)

src/data/roadmaps/ruby/content/method-lookup@ihUJHaZ1gu3Fb7MiybXCj.md

@@ -0,0 +1,8 @@
+# Method Lookup
+
+Method lookup is the process a programming language uses to determine which method to execute when a method is called on an object. It involves searching through the object's class and its ancestors (inheritance hierarchy) to find the appropriate method definition. The search typically starts with the object's class and proceeds up the inheritance chain until a matching method is found.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding Ruby Method Lookup](https://www.honeybadger.io/blog/ruby-method-lookup/)
+- [@article@Better Know A Ruby Thing: Method Lookup](https://noelrappin.com/blog/2025/03/better-know-a-ruby-thing-method-lookup/)

src/data/roadmaps/ruby/content/method-parameters@m4QhKH7mVhxRqnJOF5Xc2.md

@@ -0,0 +1,10 @@
+# Method Parameters
+
+Method parameters, also called arguments, are the values you pass into a method when you call it. There are several types: required parameters, which must be provided; optional parameters, which have default values if not provided; and variable-length arguments (using `*args`), which allow you to pass in an arbitrary number of arguments as an array. Arbitrary keyword arguments (using `**args`) allow you to pass arguments by name, and can also be required or optional. Block parameters (using `&block`) allow you to pass a block of code to a method.
+
+Visit the following resources to learn more:
+
+- [@official@Arguments](https://docs.ruby-lang.org/en/master/syntax/methods_rdoc.html#label-Arguments)
+- [@article@Parameters and arguments](https://www.theodinproject.com/lessons/ruby-methods#parameters-and-arguments)
+- [@article@Methods](https://launchschool.com/books/ruby/read/methods)
+- [@video@How to Use Method Arguments in Ruby](https://www.youtube.com/watch?v=rwVWKx-fQDg)

src/data/roadmaps/ruby/content/method_missing@pBbtuN36wqgXz4Oua0ukX.md

@@ -0,0 +1,10 @@
+# method_missing
+
+`method_missing` is a Ruby method that gets called when you try to invoke a method on an object that doesn't exist. Instead of raising a `NoMethodError`, Ruby gives you a chance to handle the missing method call yourself. This allows you to dynamically respond to method calls based on the method name and arguments provided, enabling flexible and expressive code.
+
+Visit the following resources to learn more:
+
+- [@article@Metaprogramming in Ruby: method_missing](https://josh-works.medium.com/metaprogramming-in-ruby-method-missing-f6d7f7f6aef5)
+- [@article@Ruby Metaprogramming - Method Missing](https://www.leighhalliday.com/ruby-metaprogramming-method-missing)
+- [@video@How and why to use Ruby’s method_missing](https://www.youtube.com/watch?v=rp1luOKyT9g)
+- [@video@Ruby Tutorial | Metaprogramming in Ruby - Method Missing](https://www.youtube.com/watch?v=AVfp6V-lEZo)

src/data/roadmaps/ruby/content/minitest@C7Dy0rqAo-HotIVlCBa1G.md

@@ -0,0 +1,10 @@
+# Minitest
+
+Minitest is a complete testing suite for Ruby. It provides support for test-driven development (TDD), behavior-driven development (BDD), mocking, and benchmarking. It's a lightweight and fast testing framework that's included in the Ruby standard library, making it readily available for use in Ruby projects without requiring additional installations.
+
+Visit the following resources to learn more:
+
+- [@roadmap@Ruby Minitest Tutorial](https://www.youtube.com/watch?v=Reso8FlRRAc)
+- [@opensource@minitest](https://github.com/minitest/minitest)
+- [@article@MiniTest - Writing Test Code In Ruby (2/3)](https://dev.to/exampro/minitest-writing-test-code-in-ruby-part-2-of-3-4306)
+- [@article@Getting Started with Minitest](https://www.cloudbees.com/blog/getting-started-with-minitest)

src/data/roadmaps/ruby/content/modules--mixins@8OF85n6CRQ3u3GFxlJlc8.md

@@ -0,0 +1,11 @@
+# Modules & Mixins
+
+Modules in Ruby are collections of methods, classes, and constants. They provide a way to namespace and prevent naming conflicts. Mixins allow you to incorporate module functionality into classes, enabling code reuse and multiple inheritance-like behavior. By including a module in a class, the class gains access to the module's methods, effectively "mixing in" the module's functionality.
+
+Visit the following resources to learn more:
+
+- [@official@Module](https://ruby-doc.org/core-2.5.0/Module.html)
+- [@article@A Beginner's Guide to Ruby Modules and Mixins](https://betterstack.com/community/guides/scaling-ruby/modules-mixins/)
+- [@article@Mixing in Modules](https://launchschool.com/books/oo_ruby/read/inheritance#mixinginmodules)
+- [@article@Ruby — Inheritance and Module](https://medium.com/swlh/ruby-inheritance-and-module-cc0132348dcd)
+- [@video@Modules | Ruby | Tutorial 34](https://www.youtube.com/watch?v=Cq_dKYAqMrI&pp=ygUMcnVieSBtb2R1bGVz)

src/data/roadmaps/ruby/content/monkey-patching@6mCtbDW5pkFQdLSjsr_Ad.md

@@ -0,0 +1,8 @@
+# Monkey Patching
+
+Monkey patching is a technique that allows you to add, modify, or replace existing code in a class or module at runtime. This means you can change the behavior of classes and modules, even those defined in external libraries, without directly altering their source code. It's a powerful tool for extending functionality or fixing bugs, but it should be used with caution as it can lead to unexpected side effects and make code harder to maintain.
+
+Visit the following resources to learn more:
+
+- [@article@Responsible Monkeypatching in Ruby](https://blog.appsignal.com/2021/08/24/responsible-monkeypatching-in-ruby.html)
+- [@video@Introduction to Monkey Patching In Ruby](https://www.youtube.com/watch?v=BH8-1SK7ZYI)

src/data/roadmaps/ruby/content/mutex@toevE0eM7c5f_zeSaVjdr.md

@@ -0,0 +1,3 @@
+# Mutex
+
+A mutex (mutual exclusion) is a synchronization primitive that provides exclusive access to a shared resource. It essentially acts as a lock, ensuring that only one thread or process can access a critical section of code at any given time. This prevents race conditions and data corruption that can occur when multiple threads try to modify the same data simultaneously.

src/data/roadmaps/ruby/content/naming-conventions@tRGKIfQG9IiPJGuO8DUX4.md

@@ -0,0 +1,8 @@
+# Naming Conventions
+
+Naming conventions are a set of rules or guidelines for choosing names for variables, methods, classes, and other entities in a programming language. These conventions promote code readability, maintainability, and consistency across projects. Following a standard naming style helps developers understand the purpose and scope of different elements within the code more easily.
+
+Visit the following resources to learn more:
+
+- [@article@Ruby Naming Convention](https://namingconvention.org/ruby/)
+- [@article@Naming conventions in Ruby language](https://dhanusir.com/ruby/section-two/naming-conventions/)

src/data/roadmaps/ruby/content/naming-conventions@wsnjdnZZohQsVBfM1uN8H.md

@@ -0,0 +1,8 @@
+# Naming Conventions
+
+Naming conventions are a set of rules or guidelines for choosing names for variables, methods, classes, and other entities in a programming language. These conventions promote code readability, maintainability, and consistency across a project. Following a standard naming scheme helps developers understand the purpose and scope of different elements within the code, making it easier to collaborate and debug.
+
+Visit the following resources to learn more:
+
+- [@article@Ruby Naming Convention](https://namingconvention.org/ruby/)
+- [@article@Naming conventions in Ruby language](https://dhanusir.com/ruby/section-two/naming-conventions/)

src/data/roadmaps/ruby/content/next@ueQ4bgcEXEgEDGhfVPjH8.md

@@ -0,0 +1,9 @@
+# Next Keyword in Loops
+
+The `next` keyword in Ruby provides a way to skip the current iteration of a loop and proceed directly to the next iteration. When `next` is encountered within a loop (like `for`, `while`, `until`, or iterators like `each`), the remaining code in the current loop cycle is bypassed, and the loop immediately begins its next cycle, if one exists. This is useful for skipping certain elements or conditions within a collection or range.
+
+Visit the following resources to learn more:
+
+- [@article@Controlling Loop Execution](https://launchschool.com/books/ruby/read/loops_iterators#controllloop)
+- [@article@Ruby Explained: Iteration](https://eriktrautman.com/posts/ruby-explained-iteration)
+- [@article@Understanding The Ruby Next & Break Keywords](https://www.rubyguides.com/2019/09/ruby-next-break-keywords/)

src/data/roadmaps/ruby/content/nil@WMa8k6sbhow-TXNibFj0a.md

@@ -0,0 +1,10 @@
+# Nil
+
+`nil` represents the absence of a value or a non-existent object. It's a special object in Ruby that signifies emptiness or the lack of a meaningful result. Think of it as a placeholder indicating that a variable or expression doesn't currently hold a valid value.
+
+Visit the following resources to learn more:
+
+- [@article@Nothingness and the truth](http://ruby-for-beginners.rubymonstas.org/conditionals/nothing_and_truth.html)
+- [@article@Everything You Need to Know About Nil](https://www.rubyguides.com/2018/01/ruby-nil/)
+- [@article@True, False, and Nil](https://ruby-for-beginners.rubymonstas.org/built_in_classes/true_false_nil.html)
+- [@video@Ruby Nil Explained](https://www.youtube.com/watch?v=mBJrQ84f6-4)

src/data/roadmaps/ruby/content/operators@5ThpsSMnFZUxWV1Y2Z75A.md

@@ -0,0 +1,9 @@
+# Operators
+
+Operators are special symbols in Ruby that perform operations on one or more operands (values or variables). These operations can include arithmetic calculations (like addition and subtraction), comparisons (like checking if two values are equal), logical evaluations (like determining if a condition is true or false), and assignment of values to variables. They are fundamental building blocks for creating expressions and controlling the flow of logic in Ruby programs.
+
+Visit the following resources to learn more:
+
+- [@official@Operators](https://docs.ruby-lang.org/en/3.4/syntax/operators_rdoc.html)
+- [@article@Everything You Need to Know About Ruby Operators](https://www.rubyguides.com/2018/07/ruby-operators/)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/package-managers@cRQjwGKIG7CmbDOwj7dfU.md

@@ -0,0 +1,7 @@
+# Package Managers
+
+Package managers simplify the process of installing and managing software, including Ruby, on your system. Instead of manually downloading and configuring Ruby, you can use a package manager specific to your operating system. For example, on macOS, you might use Homebrew, while on Debian/Ubuntu Linux, you'd use apt. These tools handle dependencies and ensure Ruby is installed correctly, making the setup process much easier.
+
+Visit the following resources to learn more:
+
+- [@official@Package Management Systems](https://www.ruby-lang.org/en/documentation/installation/#package-management-systems)

src/data/roadmaps/ruby/content/procs@DD3TQAEl2JD0TIPDNZXXl.md

@@ -0,0 +1,11 @@
+# Procs
+
+A Proc in Ruby is an object that represents a block of code that can be stored, passed around, and executed later. Think of it as a named, reusable chunk of code. Unlike regular methods, Procs are objects, allowing them to be treated like any other variable, passed as arguments to methods, and stored in data structures. They capture the surrounding context in which they are defined, meaning they have access to variables and methods available at the time of their creation.
+
+Visit the following resources to learn more:
+
+- [@official@class Proc](https://docs.ruby-lang.org/en/master/Proc.html)
+- [@article@The Ultimate Guide to Blocks, Procs & Lambdas](https://www.rubyguides.com/2016/02/ruby-procs-and-lambdas/)
+- [@article@Understanding Ruby Proc objects](https://www.codewithjason.com/ruby-procs/)
+- [@video@Blocks, Procs, and Lambda Functions in Ruby](https://www.youtube.com/watch?v=Dh3cSYjHITI)
+- [@video@Ruby Blocks, Procs, and Lambdas 🦁🐅🐻](https://www.youtube.com/watch?v=SADF5diqAJk)

src/data/roadmaps/ruby/content/pry@Voz_H9SBIeOndzl3gmuS7.md

@@ -0,0 +1,10 @@
+# Pry
+
+Pry is a powerful Ruby runtime developer console and an alternative to `irb`. It offers features like syntax highlighting, code browsing, documentation lookup, and the ability to step through code execution. Pry allows developers to pause program execution at any point, inspect variables, and even modify code on the fly, making it an invaluable tool for debugging and understanding Ruby code.
+
+Visit the following resources to learn more:
+
+- [@article@Debugging Ruby Code with Pry](https://laflamablanc.medium.com/debugging-ruby-code-with-pry-a0bf1f5e97ca)
+- [@article@Debugging in Ruby with pry-byebug](https://blog.appsignal.com/2024/05/08/debugging-in-ruby-with-pry-byebug.html)
+- [@article@Pry debugging](https://docs.gitlab.com/development/pry_debugging/)
+- [@video@Debugging Ruby with PRY](https://www.youtube.com/watch?v=dPDrgpWakrA)

src/data/roadmaps/ruby/content/puts-print-p@DKA6AJR1kz6Ox90MmN5Tl.md

@@ -0,0 +1,9 @@
+# Puts, Print, and P
+
+`puts`, `print`, and `p` are methods in Ruby used to display output to the console. `puts` prints the given arguments followed by a newline character, `print` prints the arguments as they are without adding a newline, and `p` prints a human-readable representation of the given object, which is useful for debugging.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding The Differences Between Puts, Print & P](https://www.rubyguides.com/2018/10/puts-vs-print/)
+- [@article@puts vs print vs p in Ruby](https://flexiple.com/ruby-on-rails/puts-vs-p-vs-print-ruby)
+- [@video@Differences Between Print, Puts & P in Ruby](https://www.youtube.com/watch?v=9jSwVvyjAKE)

src/data/roadmaps/ruby/content/querying@ZQuUDWqbNUxOYc-Fkk2pI.md

@@ -0,0 +1,8 @@
+# Querying Enumerable Collections
+
+Enumerable querying methods in Ruby allow you to gather information _about_ a collection without necessarily extracting or transforming its elements. These methods check for the presence of elements that meet certain conditions, determine the size or characteristics of the collection, or verify if all or any elements satisfy a given criteria. They return boolean values, counts, or other summary data about the Enumerable itself, rather than returning a modified Enumerable.
+
+Visit the following resources to learn more:
+
+- [@article@Methods for Querying](https://ruby-doc.org/3.4.1/Enumerable.html#module-Enumerable-label-Methods+for+Querying)
+- [@article@Getting to know Ruby's Enumerable Module](https://www.rafaelmontas.com/getting-to-know-ruby-enumerable-module/)

src/data/roadmaps/ruby/content/rack@qvg65UaeythwvO38wn8Gc.md

@@ -0,0 +1,11 @@
+# Rack
+
+Rack provides a minimal interface between web servers and Ruby frameworks. By abstracting the connection between the server and the application, Rack allows developers to write Ruby web applications that can run on a variety of web servers with minimal configuration. It essentially provides a common API for handling HTTP requests and responses.
+
+Visit the following resources to learn more:
+
+- [@opensource@rack](https://github.com/rack/rack)
+- [@article@The Basics of Rack for Ruby](https://blog.appsignal.com/2024/10/30/the-basics-of-rack-for-ruby.html)
+- [@article@What is Ruby Rack? — Build your first Rack app](https://cdragon.medium.com/what-is-ruby-rack-build-your-first-rack-app-32771cde34d9)
+- [@video@What is Rack? How does it work? A brief guide for Ruby on Rails Developers](https://www.youtube.com/watch?v=C4wy8L--FmE)
+- [@video@Rack - The BEST Ruby Web Framework](https://www.youtube.com/watch?v=PzMNycHMmws)

src/data/roadmaps/ruby/content/ractors@H4Cz_4xcMJmU0UwvEhNIn.md

@@ -0,0 +1,3 @@
+# Threads
+
+Threads are a way to achieve concurrency within a single process. They allow multiple parts of a program to execute seemingly simultaneously by sharing the same memory space. This can improve performance by utilizing multiple CPU cores or by allowing a program to remain responsive while performing long-running tasks.

src/data/roadmaps/ruby/content/ranges@OHq_172eTWaVlxES7Ccfc.md

@@ -0,0 +1,8 @@
+# Ranges
+
+Ranges in Ruby are used to create a sequence of values. They are defined using two endpoints, which can be numbers, characters, or any objects that can be compared using the `<=>` operator. Ranges can be inclusive (including the last value) or exclusive (excluding the last value), denoted by `..` and `...` respectively. They are commonly used for iterating over a sequence, creating subsets of arrays, and checking if a value falls within a specific interval.
+
+Visit the following resources to learn more:
+
+- [@article@Range operators](https://kddnewton.com/2023/07/20/ruby-operators.html#range-operators)
+- [@article@Ruby - Operators](https://www.tutorialspoint.com/ruby/ruby_operators.htm)

src/data/roadmaps/ruby/content/rbenv@VaRe4VrB7hjGp2UUFxtGf.md

@@ -0,0 +1,11 @@
+# Rbenv
+
+Rbenv is a command-line tool that allows you to easily manage multiple Ruby environments (versions) on a single system. It works by intercepting Ruby commands and determining which Ruby version to use based on the current directory or a global setting. This enables you to work on different projects that require different Ruby versions without conflicts.
+
+Visit the following resources to learn more:
+
+- [@official@Rbenv](https://rbenv.org/)
+- [@opensource@rbenv](https://github.com/rbenv/rbenv)
+- [@article@Rbenv — How it works](https://medium.com/@Sudhagar/rbenv-how-it-works-e5a0e4fa6e76)
+- [@article@rbenv cheatsheet](https://devhints.io/rbenv)
+- [@article@rbenv vs RVM: Picking Your Ruby Version Manager Buddy](https://dev.to/lovestaco/rbenv-vs-rvm-picking-your-ruby-version-manager-buddy-4130)

src/data/roadmaps/ruby/content/rdoc@QFkREObmZZebsCwXM3ML0.md

@@ -0,0 +1,9 @@
+# RDoc
+
+RDoc is a documentation generator for Ruby source code. It parses Ruby files and creates HTML or other formatted documentation based on comments and code structure. It's the standard tool for generating API documentation for Ruby projects, allowing developers to easily understand and use libraries and applications.
+
+Visit the following resources to learn more:
+
+- [@official@RDoc - Ruby Documentation System](https://ruby.github.io/rdoc/)
+- [@opensource@rdoc](https://github.com/ruby/rdoc)
+- [@video@Reading and using Ruby Documentation - Rdoc](https://www.youtube.com/watch?v=opvB-_vycTs)

src/data/roadmaps/ruby/content/recursion@yqsXD8ugaAHPnLJsd5XDQ.md

@@ -0,0 +1,9 @@
+# Recursion
+
+Recursion is a programming technique where a function calls itself within its own definition. This creates a loop-like behavior, but instead of using explicit loops (like `for` or `while`), the function breaks down a problem into smaller, self-similar subproblems until it reaches a base case, which stops the recursion and returns a value. The results from each recursive call are then combined to produce the final solution.
+
+Visit the following resources to learn more:
+
+- [@article@How to Use Recursion & Memoization in Ruby](https://www.rubyguides.com/2015/08/ruby-recursion-and-memoization/)
+- [@article@Simple Recursion in Practice with Ruby](https://codesignal.com/learn/courses/easy-interview-coding-practice-in-ruby/lessons/simple-recursion-in-practice-with-ruby)
+- [@video@Ruby Recursion Explained!](https://www.youtube.com/watch?v=5JyJWdOP8PM)

src/data/roadmaps/ruby/content/redo@gUa4S-_xZhClyiit_MSkQ.md

@@ -0,0 +1,9 @@
+# Redo
+
+`redo` is a control flow statement in Ruby used within loops (like `for`, `while`, `until`) and iterators (like `each`, `map`). When `redo` is encountered, it restarts the current iteration of the loop or iterator from the beginning, without evaluating any remaining code in that iteration. It essentially repeats the current step.
+
+Visit the following resources to learn more:
+
+- [@article@Ruby's redo, retry and next keywords](https://blog.appsignal.com/2018/06/05/redo-retry-next.html)
+- [@article@The redo Keyword in Ruby](https://medium.com/rubycademy/the-redo-keyword-in-ruby-3f150d69e3c2)
+- [@video@#23 Ruby Tutorial - NEXT and REDO statements with codes in Ruby](https://www.youtube.com/watch?v=oHlSMSawyc8)

src/data/roadmaps/ruby/content/refinements@aNf0-Yhwl98L_oNfipvj3.md

@@ -0,0 +1,9 @@
+# Refinements
+
+Refinements provide a way to modify the behavior of a class or module within a specific scope, without affecting the global definition of that class or module. This allows you to introduce changes or extensions to existing code in a localized manner, preventing unintended side effects in other parts of your application. Refinements are particularly useful for managing dependencies and avoiding conflicts when working with shared code or libraries.
+
+Visit the following resources to learn more:
+
+- [@article@The Pros and Cons of Ruby Refinements](https://www.cloudbees.com/blog/ruby-refinements)
+- [@article@Understanding Ruby refinements and lexical scope](https://www.honeybadger.io/blog/understanding-ruby-refinements-and-lexical-scope/)
+- [@article@Refinement: The Correct Way To Monkey-Patch in Ruby](https://reinteractive.com/articles/tutorial-series-for-experienced-rails-developers/ruby-refinements-vs-monkey-patching-best-practices)

src/data/roadmaps/ruby/content/regex@B5T4d3FYTvydh4DOcTFFR.md

@@ -0,0 +1,12 @@
+# Regular Expressions in Ruby
+
+Regular expressions (regex) are patterns used to match character combinations in strings. In Ruby, you can use regex to search, replace, or validate text within strings. They are defined using forward slashes (`/pattern/`) or the `%r{pattern}` syntax and provide a powerful way to manipulate and analyze text data based on specific patterns.
+
+Visit the following resources to learn more:
+
+- [@official@class Regexp](https://docs.ruby-lang.org/en/master/Regexp.html)
+- [@article@Mastering Ruby Regular Expressions](https://www.rubyguides.com/2015/06/ruby-regex/)
+- [@article@Regular Expressions](https://ruby-for-beginners.rubymonstas.org/advanced/regular_expressions.html)
+- [@article@Cool Ruby regex tricks](https://www.honeybadger.io/blog/ruby-regex-tricks/)
+- [@video@Ruby for Newbies: Regular Expressions](https://www.youtube.com/watch?v=hy6KUoU34_w)
+- [@video@Ruby Programming Tutorial - 23 - Beginning Regular Expressions](https://www.youtube.com/watch?v=q70q-QyIios)

src/data/roadmaps/ruby/content/rspec@E6k00oTuohQOBkPNyuKAA.md

@@ -0,0 +1,11 @@
+# RSpec
+
+RSpec is a testing tool for Ruby. It provides a domain-specific language (DSL) for writing tests in a clear and readable format. RSpec focuses on behavior-driven development (BDD), allowing developers to describe the expected behavior of their code in a way that is easy to understand and maintain.
+
+Visit the following resources to learn more:
+
+- [@official@RSpec](https://rspec.info/)
+- [@article@Getting Started with RSpec](https://semaphore.io/community/tutorials/getting-started-with-rspec)
+- [@article@Introduction to RSpec](https://www.theodinproject.com/lessons/ruby-introduction-to-rspec)
+- [@video@RSpec Ruby Tutorial](https://www.youtube.com/watch?v=FgGOa7Mxoxg&list=PL_noPv5wmuO9Z3h_Nq4aEPfzGqrJzhthb)
+- [@video@How to Test Your Ruby Code With RSpec](https://www.youtube.com/watch?v=LdutLs5-ObI)