diff --git a/src/data/roadmaps/ruby/content/arrays@2QHXNKV0tETI5FroFNylt.md b/src/data/roadmaps/ruby/content/arrays@2QHXNKV0tETI5FroFNylt.md index 72648ffd0..330c87679 100644 --- a/src/data/roadmaps/ruby/content/arrays@2QHXNKV0tETI5FroFNylt.md +++ b/src/data/roadmaps/ruby/content/arrays@2QHXNKV0tETI5FroFNylt.md @@ -5,8 +5,8 @@ Arrays in Ruby are ordered collections of items. They can hold any type of data, Visit the following resources to learn more: - [@official@class Array](https://docs.ruby-lang.org/en/master/Array.html) -- [@article@Arrays](https://www.theodinproject.com/lessons/ruby-arrays) -- [@article@Ruby Arrays](https://www.tutorialspoint.com/ruby/ruby_arrays.htm) +- [@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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/attributes-accessors@I9dIFxsUrysgrcqUSBNsW.md b/src/data/roadmaps/ruby/content/attributes-accessors@I9dIFxsUrysgrcqUSBNsW.md index f7103cc89..3a1b28144 100644 --- a/src/data/roadmaps/ruby/content/attributes-accessors@I9dIFxsUrysgrcqUSBNsW.md +++ b/src/data/roadmaps/ruby/content/attributes-accessors@I9dIFxsUrysgrcqUSBNsW.md @@ -1,3 +1,10 @@ # Attributes Accessors -Attributes accessors in Ruby 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 creates both a getter and a setter method. These accessors simplify code and encapsulate the internal state of objects. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/begin-rescue-ensure@-2BSGoXGMMP50en_NnQ97.md b/src/data/roadmaps/ruby/content/begin-rescue-ensure@-2BSGoXGMMP50en_NnQ97.md index 4b4ce2563..3f7bd05d3 100644 --- a/src/data/roadmaps/ruby/content/begin-rescue-ensure@-2BSGoXGMMP50en_NnQ97.md +++ b/src/data/roadmaps/ruby/content/begin-rescue-ensure@-2BSGoXGMMP50en_NnQ97.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/blocks@DzolktV1UUCdSWqmqWgV3.md b/src/data/roadmaps/ruby/content/blocks@DzolktV1UUCdSWqmqWgV3.md index 0622e0c05..c64b814a8 100644 --- a/src/data/roadmaps/ruby/content/blocks@DzolktV1UUCdSWqmqWgV3.md +++ b/src/data/roadmaps/ruby/content/blocks@DzolktV1UUCdSWqmqWgV3.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/bundler@Y6yFuFfcdlcupQUFHV3cg.md b/src/data/roadmaps/ruby/content/bundler@Y6yFuFfcdlcupQUFHV3cg.md index fcf4812a7..a98955c6f 100644 --- a/src/data/roadmaps/ruby/content/bundler@Y6yFuFfcdlcupQUFHV3cg.md +++ b/src/data/roadmaps/ruby/content/bundler@Y6yFuFfcdlcupQUFHV3cg.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/byebug@2y9U11vXpTXHwkIGogzaf.md b/src/data/roadmaps/ruby/content/byebug@2y9U11vXpTXHwkIGogzaf.md index d5881b88b..a43d65b72 100644 --- a/src/data/roadmaps/ruby/content/byebug@2y9U11vXpTXHwkIGogzaf.md +++ b/src/data/roadmaps/ruby/content/byebug@2y9U11vXpTXHwkIGogzaf.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/chaining-methods@CIV4Ph1B-kUcYv_EqVw2I.md b/src/data/roadmaps/ruby/content/chaining-methods@CIV4Ph1B-kUcYv_EqVw2I.md index 3f3aaf7eb..640369b2c 100644 --- a/src/data/roadmaps/ruby/content/chaining-methods@CIV4Ph1B-kUcYv_EqVw2I.md +++ b/src/data/roadmaps/ruby/content/chaining-methods@CIV4Ph1B-kUcYv_EqVw2I.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/closures@yaC-XKRT0dWDFmDqpCvUw.md b/src/data/roadmaps/ruby/content/closures@yaC-XKRT0dWDFmDqpCvUw.md index d0c4bc029..5322d4cf2 100644 --- a/src/data/roadmaps/ruby/content/closures@yaC-XKRT0dWDFmDqpCvUw.md +++ b/src/data/roadmaps/ruby/content/closures@yaC-XKRT0dWDFmDqpCvUw.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/concurrency@oM4ezZoguNFOALXH3Sl6E.md b/src/data/roadmaps/ruby/content/concurrency@oM4ezZoguNFOALXH3Sl6E.md index 5627f8f82..61610c517 100644 --- a/src/data/roadmaps/ruby/content/concurrency@oM4ezZoguNFOALXH3Sl6E.md +++ b/src/data/roadmaps/ruby/content/concurrency@oM4ezZoguNFOALXH3Sl6E.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/concurrent-ruby@toevE0eM7c5f_zeSaVjdr.md b/src/data/roadmaps/ruby/content/concurrent-ruby@toevE0eM7c5f_zeSaVjdr.md new file mode 100644 index 000000000..15a105aab --- /dev/null +++ b/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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/date--time@RGo3VGXftLx877w0Cxhwb.md b/src/data/roadmaps/ruby/content/date--time@RGo3VGXftLx877w0Cxhwb.md index 32211edd8..cbbd8f043 100644 --- a/src/data/roadmaps/ruby/content/date--time@RGo3VGXftLx877w0Cxhwb.md +++ b/src/data/roadmaps/ruby/content/date--time@RGo3VGXftLx877w0Cxhwb.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/debug@JSauSDvDotwrWZiyLuWks.md b/src/data/roadmaps/ruby/content/debug@JSauSDvDotwrWZiyLuWks.md index 148dae000..493f82686 100644 --- a/src/data/roadmaps/ruby/content/debug@JSauSDvDotwrWZiyLuWks.md +++ b/src/data/roadmaps/ruby/content/debug@JSauSDvDotwrWZiyLuWks.md @@ -1,3 +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. \ No newline at end of file +`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/) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/define_method@iwLZktEcLmnahj4o-IgWB.md b/src/data/roadmaps/ruby/content/define_method@iwLZktEcLmnahj4o-IgWB.md index 063f3f0ac..c6235cabd 100644 --- a/src/data/roadmaps/ruby/content/define_method@iwLZktEcLmnahj4o-IgWB.md +++ b/src/data/roadmaps/ruby/content/define_method@iwLZktEcLmnahj4o-IgWB.md @@ -1,3 +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. \ No newline at end of file +`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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/defining-classes@lPPdaW7EEyUCxV41ljvPY.md b/src/data/roadmaps/ruby/content/defining-classes@lPPdaW7EEyUCxV41ljvPY.md index ada6b13cd..5f852ea04 100644 --- a/src/data/roadmaps/ruby/content/defining-classes@lPPdaW7EEyUCxV41ljvPY.md +++ b/src/data/roadmaps/ruby/content/defining-classes@lPPdaW7EEyUCxV41ljvPY.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/defining-methods@CkYLHSGH8dmfS5fK2JLfH.md b/src/data/roadmaps/ruby/content/defining-methods@CkYLHSGH8dmfS5fK2JLfH.md index 5fec7de4e..c57df32c3 100644 --- a/src/data/roadmaps/ruby/content/defining-methods@CkYLHSGH8dmfS5fK2JLfH.md +++ b/src/data/roadmaps/ruby/content/defining-methods@CkYLHSGH8dmfS5fK2JLfH.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/fibers@_ruCDzzaSuoE_8tRacTeK.md b/src/data/roadmaps/ruby/content/fibers@_ruCDzzaSuoE_8tRacTeK.md new file mode 100644 index 000000000..f16f45be9 --- /dev/null +++ b/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: + +- [@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/) +- [@book@Magesh, "Concurrency in Ruby: Threads, Fibers, and Ractors Demystified"](https://www.youtube.com/watch?v=LVHiq_SbQOE) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/file-io@UQeCaogH4IJg4_Inxsjg1.md b/src/data/roadmaps/ruby/content/file-io@UQeCaogH4IJg4_Inxsjg1.md index 372ac7f7e..e29e7b833 100644 --- a/src/data/roadmaps/ruby/content/file-io@UQeCaogH4IJg4_Inxsjg1.md +++ b/src/data/roadmaps/ruby/content/file-io@UQeCaogH4IJg4_Inxsjg1.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/handling-exceptions@aZYZcRlB1Azm4N_jox0Ow.md b/src/data/roadmaps/ruby/content/handling-exceptions@aZYZcRlB1Azm4N_jox0Ow.md index 4b5f78e30..d6d448f97 100644 --- a/src/data/roadmaps/ruby/content/handling-exceptions@aZYZcRlB1Azm4N_jox0Ow.md +++ b/src/data/roadmaps/ruby/content/handling-exceptions@aZYZcRlB1Azm4N_jox0Ow.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/hashes@mpsx0lr9ljlMEzuU5cZD6.md b/src/data/roadmaps/ruby/content/hashes@mpsx0lr9ljlMEzuU5cZD6.md index c0956f057..67f5d93e5 100644 --- a/src/data/roadmaps/ruby/content/hashes@mpsx0lr9ljlMEzuU5cZD6.md +++ b/src/data/roadmaps/ruby/content/hashes@mpsx0lr9ljlMEzuU5cZD6.md @@ -4,8 +4,8 @@ Hashes are collections of key-value pairs. Think of them like dictionaries, wher Visit the following resources to learn more: -- [@official@Ruby - Hashes](https://www.tutorialspoint.com/ruby/ruby_hashes.htm) -- [@article@Hashes](https://www.theodinproject.com/lessons/ruby-hashes) -- [@article@class Hash](https://docs.ruby-lang.org/en/master/Hash.html) +- [@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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/ineractive-ruby-irb@uvPvcmhaO6WbkE9Xs5hsJ.md b/src/data/roadmaps/ruby/content/ineractive-ruby-irb@uvPvcmhaO6WbkE9Xs5hsJ.md index 021a25466..3864c8279 100644 --- a/src/data/roadmaps/ruby/content/ineractive-ruby-irb@uvPvcmhaO6WbkE9Xs5hsJ.md +++ b/src/data/roadmaps/ruby/content/ineractive-ruby-irb@uvPvcmhaO6WbkE9Xs5hsJ.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/inheritance@7HSJh15ice_CG3FtfQ5x6.md b/src/data/roadmaps/ruby/content/inheritance@7HSJh15ice_CG3FtfQ5x6.md index e548bf267..338ce49fb 100644 --- a/src/data/roadmaps/ruby/content/inheritance@7HSJh15ice_CG3FtfQ5x6.md +++ b/src/data/roadmaps/ruby/content/inheritance@7HSJh15ice_CG3FtfQ5x6.md @@ -1,3 +1,11 @@ # Inheritance -Inheritance is a fundamental concept in object-oriented programming where a new class (called a subclass or derived class) is created from an existing class (called a superclass or base class). The subclass inherits the properties and behaviors (attributes and methods) of the superclass, allowing it to reuse and extend the functionality of the existing class. This promotes code reusability and helps in creating a hierarchical structure of classes. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/instance-variables@dbdllih50mNFBrP9huQz9.md b/src/data/roadmaps/ruby/content/instance-variables@dbdllih50mNFBrP9huQz9.md index e64cc66a9..f6a08fee0 100644 --- a/src/data/roadmaps/ruby/content/instance-variables@dbdllih50mNFBrP9huQz9.md +++ b/src/data/roadmaps/ruby/content/instance-variables@dbdllih50mNFBrP9huQz9.md @@ -1,3 +1,9 @@ # Instance Variables -Instance variables are variables that belong to a specific instance (object) of a class. Each object has its own set of instance variables, which can hold different values for each object. They store data that is unique to that particular object and define its state. Instance variables are typically accessed and modified through methods defined within the class. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/irb@_TyiwnXJ7kQI8Z02ooAIy.md b/src/data/roadmaps/ruby/content/irb@_TyiwnXJ7kQI8Z02ooAIy.md index 39c073a9f..1645d2a63 100644 --- a/src/data/roadmaps/ruby/content/irb@_TyiwnXJ7kQI8Z02ooAIy.md +++ b/src/data/roadmaps/ruby/content/irb@_TyiwnXJ7kQI8Z02ooAIy.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/lambdas@Tb5DcDuAZNyuIPepJ_yy4.md b/src/data/roadmaps/ruby/content/lambdas@Tb5DcDuAZNyuIPepJ_yy4.md index 019ca2655..d46c5e508 100644 --- a/src/data/roadmaps/ruby/content/lambdas@Tb5DcDuAZNyuIPepJ_yy4.md +++ b/src/data/roadmaps/ruby/content/lambdas@Tb5DcDuAZNyuIPepJ_yy4.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/metaprogramming@ufLdyKM3iya8zuMD1_sIj.md b/src/data/roadmaps/ruby/content/metaprogramming@ufLdyKM3iya8zuMD1_sIj.md index f74a7ff25..48f4a3a57 100644 --- a/src/data/roadmaps/ruby/content/metaprogramming@ufLdyKM3iya8zuMD1_sIj.md +++ b/src/data/roadmaps/ruby/content/metaprogramming@ufLdyKM3iya8zuMD1_sIj.md @@ -1,3 +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. \ No newline at end of file +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: + +- [@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) +- [@book@Metaprogramming Ruby.pdf](https://theswissbay.ch/pdf/Gentoomen%20Library/Programming/Ruby/Metaprogramming%20Ruby.pdf) +- [@video@RubyConf 2022: In Defense of Ruby Metaprogramming By Noel Rappin](https://www.youtube.com/watch?v=D_ZRaZucjm4) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/method-lookup@ihUJHaZ1gu3Fb7MiybXCj.md b/src/data/roadmaps/ruby/content/method-lookup@ihUJHaZ1gu3Fb7MiybXCj.md index 63d08e430..08667b31d 100644 --- a/src/data/roadmaps/ruby/content/method-lookup@ihUJHaZ1gu3Fb7MiybXCj.md +++ b/src/data/roadmaps/ruby/content/method-lookup@ihUJHaZ1gu3Fb7MiybXCj.md @@ -1,3 +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. \ No newline at end of file +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/) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/method-parameters@m4QhKH7mVhxRqnJOF5Xc2.md b/src/data/roadmaps/ruby/content/method-parameters@m4QhKH7mVhxRqnJOF5Xc2.md index 169015786..c3aadc1a9 100644 --- a/src/data/roadmaps/ruby/content/method-parameters@m4QhKH7mVhxRqnJOF5Xc2.md +++ b/src/data/roadmaps/ruby/content/method-parameters@m4QhKH7mVhxRqnJOF5Xc2.md @@ -1,3 +1,10 @@ # Method Parameters -Method parameters 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. Keyword arguments (using `key: value`) 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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/method_missing@pBbtuN36wqgXz4Oua0ukX.md b/src/data/roadmaps/ruby/content/method_missing@pBbtuN36wqgXz4Oua0ukX.md index 17f5c23aa..6ae66d36f 100644 --- a/src/data/roadmaps/ruby/content/method_missing@pBbtuN36wqgXz4Oua0ukX.md +++ b/src/data/roadmaps/ruby/content/method_missing@pBbtuN36wqgXz4Oua0ukX.md @@ -1,3 +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. \ No newline at end of file +`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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/minitest@C7Dy0rqAo-HotIVlCBa1G.md b/src/data/roadmaps/ruby/content/minitest@C7Dy0rqAo-HotIVlCBa1G.md index abfbd0e64..b754a015c 100644 --- a/src/data/roadmaps/ruby/content/minitest@C7Dy0rqAo-HotIVlCBa1G.md +++ b/src/data/roadmaps/ruby/content/minitest@C7Dy0rqAo-HotIVlCBa1G.md @@ -1,3 +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. \ No newline at end of file +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: + +- [@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) +- [@roadmap@Ruby Minitest Tutorial](https://www.youtube.com/watch?v=Reso8FlRRAc) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/modules--mixins@8OF85n6CRQ3u3GFxlJlc8.md b/src/data/roadmaps/ruby/content/modules--mixins@8OF85n6CRQ3u3GFxlJlc8.md index 99be530c5..ae39cc591 100644 --- a/src/data/roadmaps/ruby/content/modules--mixins@8OF85n6CRQ3u3GFxlJlc8.md +++ b/src/data/roadmaps/ruby/content/modules--mixins@8OF85n6CRQ3u3GFxlJlc8.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/monkey-patching@6mCtbDW5pkFQdLSjsr_Ad.md b/src/data/roadmaps/ruby/content/monkey-patching@6mCtbDW5pkFQdLSjsr_Ad.md index 3c58dd905..6048ac5cb 100644 --- a/src/data/roadmaps/ruby/content/monkey-patching@6mCtbDW5pkFQdLSjsr_Ad.md +++ b/src/data/roadmaps/ruby/content/monkey-patching@6mCtbDW5pkFQdLSjsr_Ad.md @@ -1,3 +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 original 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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/procs@DD3TQAEl2JD0TIPDNZXXl.md b/src/data/roadmaps/ruby/content/procs@DD3TQAEl2JD0TIPDNZXXl.md index 21e4f2e53..e4e8342fb 100644 --- a/src/data/roadmaps/ruby/content/procs@DD3TQAEl2JD0TIPDNZXXl.md +++ b/src/data/roadmaps/ruby/content/procs@DD3TQAEl2JD0TIPDNZXXl.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/pry@Voz_H9SBIeOndzl3gmuS7.md b/src/data/roadmaps/ruby/content/pry@Voz_H9SBIeOndzl3gmuS7.md index 53e0aa111..38a12b496 100644 --- a/src/data/roadmaps/ruby/content/pry@Voz_H9SBIeOndzl3gmuS7.md +++ b/src/data/roadmaps/ruby/content/pry@Voz_H9SBIeOndzl3gmuS7.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/querying@ZQuUDWqbNUxOYc-Fkk2pI.md b/src/data/roadmaps/ruby/content/querying@ZQuUDWqbNUxOYc-Fkk2pI.md index 7132bdfb9..60c72f700 100644 --- a/src/data/roadmaps/ruby/content/querying@ZQuUDWqbNUxOYc-Fkk2pI.md +++ b/src/data/roadmaps/ruby/content/querying@ZQuUDWqbNUxOYc-Fkk2pI.md @@ -1,6 +1,6 @@ # 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. +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: diff --git a/src/data/roadmaps/ruby/content/rack@qvg65UaeythwvO38wn8Gc.md b/src/data/roadmaps/ruby/content/rack@qvg65UaeythwvO38wn8Gc.md index c012d7404..079ce6d32 100644 --- a/src/data/roadmaps/ruby/content/rack@qvg65UaeythwvO38wn8Gc.md +++ b/src/data/roadmaps/ruby/content/rack@qvg65UaeythwvO38wn8Gc.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/ractors@H4Cz_4xcMJmU0UwvEhNIn.md b/src/data/roadmaps/ruby/content/ractors@H4Cz_4xcMJmU0UwvEhNIn.md new file mode 100644 index 000000000..af6b501f0 --- /dev/null +++ b/src/data/roadmaps/ruby/content/ractors@H4Cz_4xcMJmU0UwvEhNIn.md @@ -0,0 +1,10 @@ +# Ractors + +Ractors are an actor-model concurrency abstraction in Ruby. They provide a way to achieve parallel execution by isolating state between different actors. Each Ractor has its own independent memory space, preventing data races and allowing for safer concurrent programming. Communication between Ractors happens through message passing, ensuring that data is explicitly transferred and not shared directly. + +Visit the following resources to learn more: + +- [@official@class Ractor](https://docs.ruby-lang.org/en/master/Ractor.html) +- [@article@An Introduction to Ractors in Ruby](https://blog.appsignal.com/2022/08/24/an-introduction-to-ractors-in-ruby.html) +- [@article@Ruby on Ractors: Parallel Execution Done Beautifully](https://medium.com/@dave_russell/ruby-on-ractors-parallel-execution-done-beautifully-c05a09d22102) +- [@video@Magesh, "Concurrency in Ruby: Threads, Fibers, and Ractors Demystified"](https://www.youtube.com/watch?v=LVHiq_SbQOE) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rbenv@VaRe4VrB7hjGp2UUFxtGf.md b/src/data/roadmaps/ruby/content/rbenv@VaRe4VrB7hjGp2UUFxtGf.md index 4d11afdaa..1f0c453ed 100644 --- a/src/data/roadmaps/ruby/content/rbenv@VaRe4VrB7hjGp2UUFxtGf.md +++ b/src/data/roadmaps/ruby/content/rbenv@VaRe4VrB7hjGp2UUFxtGf.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rdoc@QFkREObmZZebsCwXM3ML0.md b/src/data/roadmaps/ruby/content/rdoc@QFkREObmZZebsCwXM3ML0.md index 4d4757c8a..f3a0f4faa 100644 --- a/src/data/roadmaps/ruby/content/rdoc@QFkREObmZZebsCwXM3ML0.md +++ b/src/data/roadmaps/ruby/content/rdoc@QFkREObmZZebsCwXM3ML0.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/recursion@yqsXD8ugaAHPnLJsd5XDQ.md b/src/data/roadmaps/ruby/content/recursion@yqsXD8ugaAHPnLJsd5XDQ.md index b84e31d3d..aa06b32bc 100644 --- a/src/data/roadmaps/ruby/content/recursion@yqsXD8ugaAHPnLJsd5XDQ.md +++ b/src/data/roadmaps/ruby/content/recursion@yqsXD8ugaAHPnLJsd5XDQ.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/refinements@aNf0-Yhwl98L_oNfipvj3.md b/src/data/roadmaps/ruby/content/refinements@aNf0-Yhwl98L_oNfipvj3.md index 862b9e118..2408f5aa6 100644 --- a/src/data/roadmaps/ruby/content/refinements@aNf0-Yhwl98L_oNfipvj3.md +++ b/src/data/roadmaps/ruby/content/refinements@aNf0-Yhwl98L_oNfipvj3.md @@ -1,3 +1,9 @@ # Refinements -Refinements in Ruby 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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/regex@B5T4d3FYTvydh4DOcTFFR.md b/src/data/roadmaps/ruby/content/regex@B5T4d3FYTvydh4DOcTFFR.md index f9b4a08a3..c82fb150a 100644 --- a/src/data/roadmaps/ruby/content/regex@B5T4d3FYTvydh4DOcTFFR.md +++ b/src/data/roadmaps/ruby/content/regex@B5T4d3FYTvydh4DOcTFFR.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rspec@E6k00oTuohQOBkPNyuKAA.md b/src/data/roadmaps/ruby/content/rspec@E6k00oTuohQOBkPNyuKAA.md index cee96dbf4..cbfee904a 100644 --- a/src/data/roadmaps/ruby/content/rspec@E6k00oTuohQOBkPNyuKAA.md +++ b/src/data/roadmaps/ruby/content/rspec@E6k00oTuohQOBkPNyuKAA.md @@ -1,3 +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. \ No newline at end of file +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) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rubocop@gHn3q_539Ia31Kviem8lK.md b/src/data/roadmaps/ruby/content/rubocop@gHn3q_539Ia31Kviem8lK.md index 4cb55ed7c..33273bccb 100644 --- a/src/data/roadmaps/ruby/content/rubocop@gHn3q_539Ia31Kviem8lK.md +++ b/src/data/roadmaps/ruby/content/rubocop@gHn3q_539Ia31Kviem8lK.md @@ -1,3 +1,11 @@ # RuboCop -RuboCop is a static code analyzer and formatter for Ruby. It inspects Ruby code and reports style issues, potential errors, and code smells based on a community-driven Ruby style guide. RuboCop can also automatically correct many of these issues, ensuring code consistency and improving overall code quality. \ No newline at end of file +RuboCop is a static code analyzer and formatter for Ruby. It inspects Ruby code and reports style issues, potential errors, and code smells based on a community-driven Ruby style guide. RuboCop can also automatically correct many of these issues, ensuring code consistency and improving overall code quality. + +Visit the following resources to learn more: + +- [@official@RuboCop](https://rubocop.org/) +- [@official@RuboCop Docs](https://docs.rubocop.org/rubocop/1.82/index.html) +- [@opensource@rubocop](https://github.com/rubocop/rubocop) +- [@article@Using RuboCop for Effective Ruby Code Linting](https://betterstack.com/community/guides/scaling-ruby/rubocop/) +- [@video@RubyConf 2022: Analyzing an analyzer - A dive into how RuboCop works by Kyle d'Oliveira](https://www.youtube.com/watch?v=LAo-PYs6bp0) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/ruby-dsl@aU4XniRWyGKQxGnrxYKyE.md b/src/data/roadmaps/ruby/content/ruby-dsl@aU4XniRWyGKQxGnrxYKyE.md index 6d72f9d58..548466358 100644 --- a/src/data/roadmaps/ruby/content/ruby-dsl@aU4XniRWyGKQxGnrxYKyE.md +++ b/src/data/roadmaps/ruby/content/ruby-dsl@aU4XniRWyGKQxGnrxYKyE.md @@ -1,3 +1,9 @@ # Ruby DSLs -A Domain Specific Language (DSL) is a programming language designed for a particular kind of application. Instead of being a general-purpose language that can solve a wide range of problems, a DSL is focused on solving problems in a specific domain, making code more readable and maintainable within that domain. Ruby's flexible syntax makes it well-suited for creating internal DSLs, which are DSLs implemented within Ruby itself, leveraging Ruby's features to create a more expressive and concise syntax for a specific task. \ No newline at end of file +A Domain Specific Language (DSL) is a programming language designed for a particular kind of application. Instead of being a general-purpose language that can solve a wide range of problems, a DSL is focused on solving problems in a specific domain, making code more readable and maintainable within that domain. Ruby's flexible syntax makes it well-suited for creating internal DSLs, which are DSLs implemented within Ruby itself, leveraging Ruby's features to create a more expressive and concise syntax for a specific task. + +Visit the following resources to learn more: + +- [@article@Creating a Ruby DSL: A Guide to Advanced Metaprogramming](https://www.toptal.com/developers/ruby/ruby-dsl-metaprogramming-guide) +- [@article@Writing a Domain-Specific Language in Ruby](https://thoughtbot.com/blog/writing-a-domain-specific-language-in-ruby) +- [@article@Crafting a Ruby configuration DSL: Lessons learned](https://vaisakhvm.medium.com/crafting-a-ruby-configuration-dsl-lessons-learned-8bbb0958c670) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/ruby-on-rails@AE7YB3XH70HJWCf51i5YH.md b/src/data/roadmaps/ruby/content/ruby-on-rails@AE7YB3XH70HJWCf51i5YH.md index cefa5a6fa..83be7f52e 100644 --- a/src/data/roadmaps/ruby/content/ruby-on-rails@AE7YB3XH70HJWCf51i5YH.md +++ b/src/data/roadmaps/ruby/content/ruby-on-rails@AE7YB3XH70HJWCf51i5YH.md @@ -1,3 +1,12 @@ # Ruby on Rails -Ruby on Rails is a server-side web application framework written in Ruby under the MIT License. Rails is a model-view-controller (MVC) framework, providing default structures for a database, a web service, and web pages. It encourages the use of web standards such as JSON or XML for data transfer, and HTML, CSS, and JavaScript for the user interface. \ No newline at end of file +Ruby on Rails is a server-side web application framework written in Ruby under the MIT License. Rails is a model-view-controller (MVC) framework, providing default structures for a database, a web service, and web pages. It encourages the use of web standards such as JSON or XML for data transfer, and HTML, CSS, and JavaScript for the user interface. + +Visit the following resources to learn more: + +- [@official@Ruby on Rails](https://rubyonrails.org/) +- [@official@Getting Started with Rails](https://guides.rubyonrails.org/getting_started.html) +- [@opensource@rails](https://github.com/rails/rails) +- [@article@Ruby vs Ruby on Rails: What’s the Difference?](https://kinsta.com/blog/ruby-vs-ruby-on-rails/) +- [@video@Learn Ruby on Rails - Full Course](https://www.youtube.com/watch?v=fmyvWz5TUWg) +- [@video@Ruby on Rails in 100 Seconds](https://www.youtube.com/watch?v=2DvrRadXwWY) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rubygems@iwXBPrnuwPvNRbOIDxWvq.md b/src/data/roadmaps/ruby/content/rubygems@iwXBPrnuwPvNRbOIDxWvq.md index b6417505a..ab6f95955 100644 --- a/src/data/roadmaps/ruby/content/rubygems@iwXBPrnuwPvNRbOIDxWvq.md +++ b/src/data/roadmaps/ruby/content/rubygems@iwXBPrnuwPvNRbOIDxWvq.md @@ -1,3 +1,11 @@ # RubyGems -RubyGems is a package management system for the Ruby programming language. It provides a standard format for distributing Ruby programs and libraries (called "gems"), a tool for easily installing gems, and a central repository ([RubyGems.org](http://RubyGems.org)) for finding and sharing them. It simplifies the process of managing dependencies and distributing reusable code in the Ruby ecosystem. \ No newline at end of file +RubyGems is a package management system for the Ruby programming language. It provides a standard format for distributing Ruby programs and libraries (called "gems"), a tool for easily installing gems, and a central repository ([RubyGems.org](http://RubyGems.org)) for finding and sharing them. It simplifies the process of managing dependencies and distributing reusable code in the Ruby ecosystem. + +Visit the following resources to learn more: + +- [@official@RubyGems](https://rubygems.org/) +- [@official@Libraries](https://www.ruby-lang.org/en/libraries/) +- [@official@RubyGems Basics](https://guides.rubygems.org/rubygems-basics/) +- [@opensource@rubygems](https://github.com/ruby/rubygems) +- [@video@What Are RubyGems - Explained](https://www.youtube.com/watch?v=M4szKwqFHKs) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rubymine@WQQuaLnCCzy48uDPJ-sDb.md b/src/data/roadmaps/ruby/content/rubymine@WQQuaLnCCzy48uDPJ-sDb.md index 4c1ed92d6..37cb53819 100644 --- a/src/data/roadmaps/ruby/content/rubymine@WQQuaLnCCzy48uDPJ-sDb.md +++ b/src/data/roadmaps/ruby/content/rubymine@WQQuaLnCCzy48uDPJ-sDb.md @@ -1,3 +1,10 @@ # RubyMine -RubyMine is an Integrated Development Environment (IDE) specifically designed for Ruby and Ruby on Rails development. It provides a comprehensive suite of tools for coding, testing, debugging, and deploying Ruby applications, aiming to enhance developer productivity through features like intelligent code completion, refactoring, and integration with various testing frameworks and version control systems. \ No newline at end of file +RubyMine is an Integrated Development Environment (IDE) specifically designed for Ruby and Ruby on Rails development. It provides a comprehensive suite of tools for coding, testing, debugging, and deploying Ruby applications, aiming to enhance developer productivity through features like intelligent code completion, refactoring, and integration with various testing frameworks and version control systems. + +Visit the following resources to learn more: + +- [@official@RubyMine](https://www.jetbrains.com/ruby/) +- [@article@Introduction to RubyMine — A Powerful Ruby Development Tool](https://medium.com/@AlexanderObregon/introduction-to-rubymine-a-powerful-ruby-development-tool-4127851de5f9) +- [@video@RubyMine vs VSCode (2026): Which Is The Best IDE For Ruby on Rails?](https://www.youtube.com/watch?v=WIc1de6_1MM) +- [@video@Episode #526 - RubyMine](https://www.youtube.com/watch?v=j3hv7pz1ROc) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/rvm@0c_0zyh1LQA80gmriWOT3.md b/src/data/roadmaps/ruby/content/rvm@0c_0zyh1LQA80gmriWOT3.md index 7539587cb..4e85dcbfc 100644 --- a/src/data/roadmaps/ruby/content/rvm@0c_0zyh1LQA80gmriWOT3.md +++ b/src/data/roadmaps/ruby/content/rvm@0c_0zyh1LQA80gmriWOT3.md @@ -1,3 +1,10 @@ # RVM -RVM (Ruby Version Manager) is a command-line tool that allows you to easily manage multiple Ruby environments on a single system. It enables you to install, manage, and work with different Ruby versions (like Ruby 2.7, 3.0, or JRuby) and gemsets (isolated collections of gems) independently. This prevents conflicts between projects that require different Ruby versions or gem dependencies. \ No newline at end of file +RVM (Ruby Version Manager) is a command-line tool that allows you to easily manage multiple Ruby environments on a single system. It enables you to install, manage, and work with different Ruby versions (like Ruby 2.7, 3.0, or JRuby) and gemsets (isolated collections of gems) independently. This prevents conflicts between projects that require different Ruby versions or gem dependencies. + +Visit the following resources to learn more: + +- [@official@RVM](https://rvm.io/) +- [@opensource@rvn](https://github.com/rvm/rvm) +- [@article@What’s an RVM and Why You Should Use it for Rails Apps?](https://medium.com/@moulayjam/whats-an-rvm-and-why-you-should-use-it-for-rails-apps-b5cced2469a8) +- [@article@rbenv vs RVM: Picking Your Ruby Version Manager Buddy](https://dev.to/lovestaco/rbenv-vs-rvm-picking-your-ruby-version-manager-buddy-4130) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/scope@SB_IzxfilaHBVL1fe5aYG.md b/src/data/roadmaps/ruby/content/scope@SB_IzxfilaHBVL1fe5aYG.md index 52aa3b463..3f3dcd126 100644 --- a/src/data/roadmaps/ruby/content/scope@SB_IzxfilaHBVL1fe5aYG.md +++ b/src/data/roadmaps/ruby/content/scope@SB_IzxfilaHBVL1fe5aYG.md @@ -1,3 +1,10 @@ # Scope -Scope refers to the visibility and accessibility of variables within different parts of a program. It determines where a variable can be accessed and used. Understanding scope is crucial for avoiding naming conflicts and ensuring that data is accessed and modified correctly within different parts of your Ruby code. \ No newline at end of file +Scope refers to the visibility and accessibility of variables within different parts of a program. It determines where a variable can be accessed and used. Understanding scope is crucial for avoiding naming conflicts and ensuring that data is accessed and modified correctly within different parts of your Ruby code. + +Visit the following resources to learn more: + +- [@official@Scope](https://docs.ruby-lang.org/en/master/syntax/methods_rdoc.html#label-Scope) +- [@article@Variable Scope and Access in Ruby: The Important Parts](https://ethanweiner.medium.com/variable-scope-and-access-in-ruby-the-important-parts-dc2d146977b3) +- [@article@Method Definition and Local Variable Scope](https://launchschool.com/books/ruby/read/methods) +- [@video@Methods & Variable Scope in Ruby](https://www.youtube.com/watch?v=rzZK79C6nSI) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/search-algorithms@EPNxjJqcP10c1__q1KKea.md b/src/data/roadmaps/ruby/content/search-algorithms@EPNxjJqcP10c1__q1KKea.md index ba57c051d..e27531409 100644 --- a/src/data/roadmaps/ruby/content/search-algorithms@EPNxjJqcP10c1__q1KKea.md +++ b/src/data/roadmaps/ruby/content/search-algorithms@EPNxjJqcP10c1__q1KKea.md @@ -1,3 +1,10 @@ # Search Algorithms -Search algorithms are methods used to find a specific element within a collection of data, like an array or a hash. These algorithms work by systematically checking each element in the data structure until the desired element is found or it's determined that the element is not present. Common examples include linear search, which checks each element sequentially, and binary search, which efficiently finds elements in sorted data by repeatedly dividing the search interval in half. \ No newline at end of file +Search algorithms are methods used to find a specific element within a collection of data, like an array or a hash. These algorithms work by systematically checking each element in the data structure until the desired element is found or it's determined that the element is not present. Common examples include linear search, which checks each element sequentially, and binary search, which efficiently finds elements in sorted data by repeatedly dividing the search interval in half. + +Visit the following resources to learn more: + +- [@article@Search algorithms with Ruby](https://dev.to/daviducolo/search-algorithms-in-ruby-3nbj) +- [@article@Search Algorithms in Ruby](https://medium.com/@limichelle21/search-algorithms-in-ruby-c3b8c9b70451) +- [@article@Introduction to Binary Search](https://codesignal.com/learn/courses/sorting-and-searching-algorithms-in-ruby/lessons/introduction-to-binary-search-in-ruby) +- [@video@Binary Search & Linear Search: Algorithms With Ruby](https://www.youtube.com/watch?v=7RPr83FYEkE) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/send@5uayAWgKAYW_mJiMxuXmK.md b/src/data/roadmaps/ruby/content/send@5uayAWgKAYW_mJiMxuXmK.md index 818293dab..a03c0f544 100644 --- a/src/data/roadmaps/ruby/content/send@5uayAWgKAYW_mJiMxuXmK.md +++ b/src/data/roadmaps/ruby/content/send@5uayAWgKAYW_mJiMxuXmK.md @@ -1,3 +1,8 @@ # Send -`send` in Ruby is a method that allows you to call other methods on an object dynamically by their name, which is passed as a symbol or string. It essentially bypasses the usual method call syntax, enabling you to invoke methods at runtime based on conditions or data. This provides a powerful way to write flexible and adaptable code. \ No newline at end of file +`send` in Ruby is a method that allows you to call other methods on an object dynamically by their name, which is passed as a symbol or string. It essentially bypasses the usual method call syntax, enabling you to invoke methods at runtime based on conditions or data. This provides a powerful way to write flexible and adaptable code. + +Visit the following resources to learn more: + +- [@article@Metaprogramming with the send Method in Ruby](https://medium.com/nyc-ruby-on-rails/meta-programming-with-the-send-method-in-ruby-e88d568f868) +- [@video@send in ruby](https://www.youtube.com/watch?v=cY-wxg5z5bA) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/sinatra@XI-1114QVFgALBF9VAb99.md b/src/data/roadmaps/ruby/content/sinatra@XI-1114QVFgALBF9VAb99.md index d219fe438..653b89c08 100644 --- a/src/data/roadmaps/ruby/content/sinatra@XI-1114QVFgALBF9VAb99.md +++ b/src/data/roadmaps/ruby/content/sinatra@XI-1114QVFgALBF9VAb99.md @@ -1,3 +1,11 @@ # Sinatra -Sinatra is a lightweight and flexible Domain Specific Language (DSL) for creating web applications in Ruby with minimal effort. It provides a simple way to map routes to Ruby code, allowing developers to quickly build web applications without the complexity of larger frameworks. Sinatra emphasizes convention over configuration, making it easy to get started and build small to medium-sized web applications. \ No newline at end of file +Sinatra is a lightweight and flexible Domain Specific Language (DSL) for creating web applications in Ruby with minimal effort. It provides a simple way to map routes to Ruby code, allowing developers to quickly build web applications without the complexity of larger frameworks. Sinatra emphasizes convention over configuration, making it easy to get started and build small to medium-sized web applications. + +Visit the following resources to learn more: + +- [@official@Sinatra](https://sinatrarb.com/) +- [@opensource@sinatra](https://github.com/sinatra/sinatra) +- [@article@How to Use Sinatra to Build a Ruby Application](https://blog.appsignal.com/2023/05/31/how-to-use-sinatra-to-build-a-ruby-application.html) +- [@article@Tutorial: Run a Sinatra application](https://www.jetbrains.com/help/ruby/sinatra.html) +- [@video@Sinatra Ruby Gem](https://www.youtube.com/watch?v=sfw5ZPowLJY&list=PL1sGH26TWrxot1_zsMNqb1lYbS54-OzVU) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/singleton-classes@WNiD4Tllt2uDncEVPg8Pm.md b/src/data/roadmaps/ruby/content/singleton-classes@WNiD4Tllt2uDncEVPg8Pm.md index c28899a64..ce67fe30c 100644 --- a/src/data/roadmaps/ruby/content/singleton-classes@WNiD4Tllt2uDncEVPg8Pm.md +++ b/src/data/roadmaps/ruby/content/singleton-classes@WNiD4Tllt2uDncEVPg8Pm.md @@ -1,3 +1,9 @@ # Singleton Classes -A singleton class in Ruby is a special kind of class that is associated with a single object. It allows you to define methods that are specific to that particular object, without affecting other objects of the same class. Think of it as a way to add unique behavior to an individual object instance. \ No newline at end of file +A singleton class in Ruby is a special kind of class that is associated with a single object. It allows you to define methods that are specific to that particular object, without affecting other objects of the same class. Think of it as a way to add unique behavior to an individual object instance. + +Visit the following resources to learn more: + +- [@article@Explaining Ruby's Singleton Class (Eigenclass) to confused beginners](https://dev.to/samuelfaure/explaining-ruby-s-singleton-class-eigenclass-to-confused-beginners-cep) +- [@article@Better Know A Ruby Thing: Singleton Classes](https://noelrappin.com/blog/2025/01/better-know-a-ruby-thing-singleton-classes/) +- [@video@The Singleton Pattern in Ruby](https://www.youtube.com/watch?v=IP3I_t2rR6A) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/sorting-algorithms@hD6uldPLaedTvUwAWKFYY.md b/src/data/roadmaps/ruby/content/sorting-algorithms@hD6uldPLaedTvUwAWKFYY.md index 7247d98f5..b51aa94ff 100644 --- a/src/data/roadmaps/ruby/content/sorting-algorithms@hD6uldPLaedTvUwAWKFYY.md +++ b/src/data/roadmaps/ruby/content/sorting-algorithms@hD6uldPLaedTvUwAWKFYY.md @@ -1,3 +1,9 @@ # Sorting Algorithms -Sorting algorithms are methods used to rearrange a collection of items (like numbers, strings, or objects) into a specific order, such as ascending or descending. These algorithms work by comparing elements and swapping their positions until the entire collection is ordered according to the desired criteria. Different sorting algorithms have varying efficiencies and are suitable for different types and sizes of data. \ No newline at end of file +Sorting algorithms are methods used to rearrange a collection of items (like numbers, strings, or objects) into a specific order, such as ascending or descending. These algorithms work by comparing elements and swapping their positions until the entire collection is ordered according to the desired criteria. Different sorting algorithms have varying efficiencies and are suitable for different types and sizes of data. + +Visit the following resources to learn more: + +- [@article@Sorting Algorithms with Ruby](https://dev.to/daviducolo/sorting-algorithms-with-ruby-4o18) +- [@article@Sorting Algorithms in Ruby](https://www.sitepoint.com/sorting-algorithms-ruby/) +- [@video@Ruby Sorting Algorithms](https://www.youtube.com/playlist?list=PLVVKl6q0Euw62GGkbh5PNSlEm37Lft9Re) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/stacks---queues@wcw4QurFUczUKnyBPpnr5.md b/src/data/roadmaps/ruby/content/stacks---queues@wcw4QurFUczUKnyBPpnr5.md index fe00160aa..b633524c1 100644 --- a/src/data/roadmaps/ruby/content/stacks---queues@wcw4QurFUczUKnyBPpnr5.md +++ b/src/data/roadmaps/ruby/content/stacks---queues@wcw4QurFUczUKnyBPpnr5.md @@ -1,3 +1,10 @@ # Stacks & Queues -Stacks and queues are fundamental data structures used to manage collections of items. A stack operates on the Last-In, First-Out (LIFO) principle, where the last element added is the first one removed, like a stack of plates. Conversely, a queue follows the First-In, First-Out (FIFO) principle, where the first element added is the first one removed, similar to a waiting line. In Ruby, these can be implemented using arrays or custom classes to manage data in a specific order. \ No newline at end of file +Stacks and queues are fundamental data structures used to manage collections of items. A stack operates on the Last-In, First-Out (LIFO) principle, where the last element added is the first one removed, like a stack of plates. Conversely, a queue follows the First-In, First-Out (FIFO) principle, where the first element added is the first one removed, similar to a waiting line. In Ruby, these can be implemented using arrays or custom classes to manage data in a specific order. + +Visit the following resources to learn more: + +- [@article@Introduction: Stacks and Queues](https://codesignal.com/learn/courses/mastering-complex-data-structures-in-ruby/lessons/exploring-stacks-and-queues-in-ruby) +- [@article@Stack, Queue and Deque Data Structures in Ruby](https://medium.com/@paulndemo/stack-queue-and-deque-data-structures-in-ruby-64ce9a546247) +- [@article@How to Use Stacks in Ruby to Solve Problems](https://www.rubyguides.com/2017/03/computer-science-in-ruby-stacks/) +- [@video@Introduction to Stacks and Queues (Data Structures & Algorithms #12)](https://www.youtube.com/watch?v=A3ZUpyrnCbM) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/standard@Wf6AYAz8gTpaj6ZfOxoZM.md b/src/data/roadmaps/ruby/content/standard@Wf6AYAz8gTpaj6ZfOxoZM.md index c4543e24a..6aa61f38f 100644 --- a/src/data/roadmaps/ruby/content/standard@Wf6AYAz8gTpaj6ZfOxoZM.md +++ b/src/data/roadmaps/ruby/content/standard@Wf6AYAz8gTpaj6ZfOxoZM.md @@ -1,3 +1,9 @@ # Standard -Standard is a Ruby gem that automatically formats and lints Ruby code, aiming to enforce a consistent style across projects. It combines the functionality of linters like RuboCop with an auto-formatter, providing a single tool to ensure code adheres to a predefined set of style rules. By automatically fixing style issues, Standard helps developers focus on writing code rather than debating formatting preferences. \ No newline at end of file +Standard is a Ruby gem that automatically formats and lints Ruby code, aiming to enforce a consistent style across projects. It combines the functionality of linters like RuboCop with an auto-formatter, providing a single tool to ensure code adheres to a predefined set of style rules. By automatically fixing style issues, Standard helps developers focus on writing code rather than debating formatting preferences. + +Visit the following resources to learn more: + +- [@opensource@standard](https://github.com/standardrb/standard) +- [@article@Getting Started with StandardRB](https://betterstack.com/community/guides/scaling-ruby/standardrb-explained/) +- [@video@Lint & Format Messy Ruby Code Using Standard](https://www.youtube.com/watch?v=zQ4BiObOf2U&t=28s) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/testunit@Tzf1uJDIeIjPAVleVe_yx.md b/src/data/roadmaps/ruby/content/testunit@Tzf1uJDIeIjPAVleVe_yx.md index 1b9bce206..d529558e2 100644 --- a/src/data/roadmaps/ruby/content/testunit@Tzf1uJDIeIjPAVleVe_yx.md +++ b/src/data/roadmaps/ruby/content/testunit@Tzf1uJDIeIjPAVleVe_yx.md @@ -1,3 +1,8 @@ # Test::Unit -Test::Unit is a testing framework for Ruby, providing a structure for writing and running tests. It allows developers to define test cases as methods within classes, making it easy to organize and execute tests to verify the correctness of their code. Test::Unit includes assertions to check expected outcomes and report failures, helping ensure code quality and reliability. \ No newline at end of file +Test::Unit is a testing framework for Ruby, providing a structure for writing and running tests. It allows developers to define test cases as methods within classes, making it easy to organize and execute tests to verify the correctness of their code. Test::Unit includes assertions to check expected outcomes and report failures, helping ensure code quality and reliability. + +Visit the following resources to learn more: + +- [@article@Test::Unit](https://ruby-doc.org/stdlib-3.1.0/libdoc/test-unit/rdoc/Test/Unit.html) +- [@article@TestUnit - Writing Test Code In Ruby (1/3)](https://dev.to/exampro/testunit-writing-test-code-in-ruby-part-1-of-3-44m2) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/threads@xJ_F95dKmaRKE42yQ2R-r.md b/src/data/roadmaps/ruby/content/threads@xJ_F95dKmaRKE42yQ2R-r.md new file mode 100644 index 000000000..926470bb4 --- /dev/null +++ b/src/data/roadmaps/ruby/content/threads@xJ_F95dKmaRKE42yQ2R-r.md @@ -0,0 +1,10 @@ +# Threads + +Threads allow you to run multiple blocks of code seemingly at the same time within a single program. Think of them as lightweight processes that share the same memory space. This means they can access the same variables and objects, making it easier to share data, but also requiring careful management to avoid conflicts when multiple threads try to modify the same data simultaneously. + +Visit the following resources to learn more: + +- [@official@Thread](https://docs.ruby-lang.org/en/master/Thread.html) +- [@article@How to Use Ruby Threads: An Easy To Understand Tutorial](https://www.rubyguides.com/2015/07/ruby-threads/) +- [@article@Untangling Ruby Threads](https://thoughtbot.com/blog/untangling-ruby-threads) +- [@video@Magesh, "Concurrency in Ruby: Threads, Fibers, and Ractors Demystified"](https://www.youtube.com/watch?v=LVHiq_SbQOE) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/vs-code@9_KhHCWRDTNl1nroot_Ri.md b/src/data/roadmaps/ruby/content/vs-code@9_KhHCWRDTNl1nroot_Ri.md index c81b5d9b8..5d5f3bed8 100644 --- a/src/data/roadmaps/ruby/content/vs-code@9_KhHCWRDTNl1nroot_Ri.md +++ b/src/data/roadmaps/ruby/content/vs-code@9_KhHCWRDTNl1nroot_Ri.md @@ -1,3 +1,10 @@ # VS Code Ruby Extension -The VS Code Ruby extension enhances the Visual Studio Code editor with features specifically designed for Ruby development. It provides functionalities like syntax highlighting, code completion, debugging support, linting, and formatting, making it easier for developers to write, test, and maintain Ruby code within the VS Code environment. This extension streamlines the development workflow and improves code quality by offering real-time feedback and assistance. \ No newline at end of file +The VS Code Ruby extension enhances the Visual Studio Code editor with features specifically designed for Ruby development. It provides functionalities like syntax highlighting, code completion, debugging support, linting, and formatting, making it easier for developers to write, test, and maintain Ruby code within the VS Code environment. This extension streamlines the development workflow and improves code quality by offering real-time feedback and assistance. + +Visit the following resources to learn more: + +- [@official@Ruby in Visual Studio Code](https://code.visualstudio.com/docs/languages/ruby) +- [@article@Best Visual Studio Code extensions and settings for Ruby and Rails](https://achris.me/posts/setup-ruby-vscode/) +- [@article@Ruby Development with VS Code](https://medium.com/@terrenceong/ruby-development-with-vs-code-fab258db5f1d) +- [@video@How to Set Up VS Code for Ruby](https://www.youtube.com/watch?v=Zw4wdDLMAIw) \ No newline at end of file diff --git a/src/data/roadmaps/ruby/content/yard@EDfqLvVxq-PIqb1eGYL20.md b/src/data/roadmaps/ruby/content/yard@EDfqLvVxq-PIqb1eGYL20.md index cac72cbd4..1859174f4 100644 --- a/src/data/roadmaps/ruby/content/yard@EDfqLvVxq-PIqb1eGYL20.md +++ b/src/data/roadmaps/ruby/content/yard@EDfqLvVxq-PIqb1eGYL20.md @@ -1,3 +1,10 @@ # YARD -YARD (Yet Another Ruby Documentation) is a documentation generation tool for the Ruby programming language. It allows developers to create comprehensive and consistent documentation for their Ruby projects by parsing source code and extracting information based on specially formatted comments. YARD generates output in various formats, including HTML, making it easy to browse and share project documentation. \ No newline at end of file +YARD (Yet Another Ruby Documentation) is a documentation generation tool for the Ruby programming language. It allows developers to create comprehensive and consistent documentation for their Ruby projects by parsing source code and extracting information based on specially formatted comments. YARD generates output in various formats, including HTML, making it easy to browse and share project documentation. + +Visit the following resources to learn more: + +- [@official@YARD](https://yardoc.org/) +- [@official@Getting Started](https://rubydoc.info/gems/yard/file/docs/GettingStarted.md) +- [@opensource@yard](https://github.com/lsegal/yard) +- [@article@YARD for Ruby Beginners: A Documentation Guide](https://medium.com/@swastik.thapaliya/yard-for-ruby-beginners-a-documentation-guide-d276b919fc12) \ No newline at end of file