diff --git a/src/data/roadmaps/scala/content/akka--pekko@vsfwt3tvLDhJoRyA82bM1.md b/src/data/roadmaps/scala/content/akka--pekko@vsfwt3tvLDhJoRyA82bM1.md
new file mode 100644
index 000000000..c302d58b4
--- /dev/null
+++ b/src/data/roadmaps/scala/content/akka--pekko@vsfwt3tvLDhJoRyA82bM1.md
@@ -0,0 +1,11 @@
+# Akka / Pekko
+
+Akka and Pekko are toolkits for building concurrent, distributed, and resilient applications on the JVM using Scala. Akka, originally developed by Lightbend, introduced an actor model for managing concurrency, inspired by Erlang. It provides abstractions for building scalable and fault-tolerant systems. Pekko is an open-source fork of Akka, created after Akka's licensing changes, and continues to provide similar functionality under the Apache License. Both toolkits support the actor model, which simplifies the development of highly concurrent and distributed applications. They also offer additional modules for HTTP, streaming, clustering, and persistence, making them suitable for a wide range of applications, from microservices to large-scale distributed systems.
+ Resources
+
+Visit the following resources to learn more:
+
+- [@official@Apache Pekko Official Website](https://pekko.apache.org/)
+- [@course@Akka/Pekko Essentials Course on Rock the JVM](https://rockthejvm.com/courses/akka-apache-pekko-essentials-with-scala)
+- [@article@Akka Documentation on Wikipedia](https://en.wikipedia.org/wiki/Akka_(toolkit))
+- [@article@Introduction to Apache Pekko on Baeldung](https://www.baeldung.com/scala/apache-pekko)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/anonymous-func--lambda@jkV_FWlv79nxyNiT_WFOr.md b/src/data/roadmaps/scala/content/anonymous-func--lambda@jkV_FWlv79nxyNiT_WFOr.md
new file mode 100644
index 000000000..b73b905dc
--- /dev/null
+++ b/src/data/roadmaps/scala/content/anonymous-func--lambda@jkV_FWlv79nxyNiT_WFOr.md
@@ -0,0 +1,9 @@
+# Anonymous Functions / Lambdas
+
+Anonymous functions, also known as lambdas, are functions without names. You define them inline where you need them, typically to pass them as arguments to other functions. They're essentially a concise way to represent small, single-expression functions. Scala uses a special syntax to define them, making it easy to create functions on the fly.
+
+Visit the following resources to learn more:
+
+- [@official@Anonymous Functions | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/fun-anonymous-functions.html)
+- [@article@Lambda Expressions in Scala | Baeldung on Scala](https://www.baeldung.com/scala/lambda-expressions)
+- [@article@Anonymous Functions in Scala: How to Use Lambda Functions Effectively](https://www.developerindian.com/articles/anonymous-functions-in-scala-how-to-use-lambda-functions-effectively)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/apply-method@v6KrScCfuNH8i1aTBGVI4.md b/src/data/roadmaps/scala/content/apply-method@v6KrScCfuNH8i1aTBGVI4.md
new file mode 100644
index 000000000..dd40ec67d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/apply-method@v6KrScCfuNH8i1aTBGVI4.md
@@ -0,0 +1,9 @@
+# The apply method
+
+The apply function is a so-called smart constructor. It's the most popular way in Scala to create new instances of data types. It's more flexible than a standard constructor because it allows for running certain logic before deciding whether an instance should be created, and, if yes, it can create an instance of a certain subtype while returning it as an instance of a supertype.
+
+Visit the following resources to learn more:
+
+- [@official@Universal Apply Methods](https://docs.scala-lang.org/scala3/reference/other-new-features/creator-applications.html)
+- [@article@What is the apply function in Scala? - Stack Overflow](https://stackoverflow.com/questions/9737352/what-is-the-apply-function-in-scala)
+- [@article@Apply Method in Scala | Baeldung on Scala](https://www.baeldung.com/scala/apply-method)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/array@D_2hxCGaYnaQf1Tu0Y-ty.md b/src/data/roadmaps/scala/content/array@D_2hxCGaYnaQf1Tu0Y-ty.md
new file mode 100644
index 000000000..12f7e9e93
--- /dev/null
+++ b/src/data/roadmaps/scala/content/array@D_2hxCGaYnaQf1Tu0Y-ty.md
@@ -0,0 +1,8 @@
+# Array
+
+An array is a fixed-size data structure that stores elements of the same data type. Arrays in Scala are mutable, meaning their elements can be updated. Arrays provide fast and constant-time access to elements based on their indices.
+
+Visit the following resources to learn more:
+
+- [@official@Arrays | Collections (Scala 2.8 - 2.12) | Scala Documentation](https://docs.scala-lang.org/overviews/collections/arrays.html)
+- [@article@Guide to Arrays in Scala | Baeldung on Scala](https://www.baeldung.com/scala/arrays-guide)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/books@kXP-YrnwQ1zPuBuTHA35l.md b/src/data/roadmaps/scala/content/books@kXP-YrnwQ1zPuBuTHA35l.md
new file mode 100644
index 000000000..20629b2c3
--- /dev/null
+++ b/src/data/roadmaps/scala/content/books@kXP-YrnwQ1zPuBuTHA35l.md
@@ -0,0 +1,3 @@
+# Books
+
+Books offer a structured and comprehensive way to learn a new programming language. They typically cover fundamental concepts in detail, building upon previous knowledge to provide a solid understanding. Good books often include examples, exercises, and practice problems that allow you to reinforce what you've learned and apply it to real-world scenarios. They're often curated and reviewed, providing reliable and accurate information.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/booleans@bOSckrStDRgoLAGWi6QfZ.md b/src/data/roadmaps/scala/content/booleans@bOSckrStDRgoLAGWi6QfZ.md
new file mode 100644
index 000000000..9d5674cf0
--- /dev/null
+++ b/src/data/roadmaps/scala/content/booleans@bOSckrStDRgoLAGWi6QfZ.md
@@ -0,0 +1,3 @@
+# Booleans
+
+Booleans represent truth values: either `true` or `false`. They are fundamental for decision-making in programs, allowing you to control the flow of execution based on conditions. You use booleans with logical operators like `&&` (and), `||` (or), and `!` (not) to create more complex expressions that evaluate to either `true` or `false`. These are often used in conditional statements (like `if` and `else`) and loops.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/build-tools@TYW3j_DfD6DsrHE6MjJ8N.md b/src/data/roadmaps/scala/content/build-tools@TYW3j_DfD6DsrHE6MjJ8N.md
new file mode 100644
index 000000000..bd311a7c1
--- /dev/null
+++ b/src/data/roadmaps/scala/content/build-tools@TYW3j_DfD6DsrHE6MjJ8N.md
@@ -0,0 +1,3 @@
+# Build Tools
+
+Build tools automate tasks like compiling code, running tests, and packaging applications. They streamline the development process and ensure consistency across projects. In the Scala ecosystem, popular build tools include `scalacli`, a newer option emphasizing simplicity and speed, `sbt`, a widely used and powerful tool with a large plugin ecosystem, and `mill`, known for its fast builds and reliance on Scala itself for configuration.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/by-name-parameters@_GMHFAt8BulTAb9msdUb9.md b/src/data/roadmaps/scala/content/by-name-parameters@_GMHFAt8BulTAb9msdUb9.md
new file mode 100644
index 000000000..e73a9190c
--- /dev/null
+++ b/src/data/roadmaps/scala/content/by-name-parameters@_GMHFAt8BulTAb9msdUb9.md
@@ -0,0 +1,9 @@
+# By-name parameters
+
+By-name parameters are defined using the => symbol before the parameter type. Such a parameter will be evaluated only when it is used inside the method's body. You can think of it as syntactic sugar over a zero-parameter function passed to a method.
+
+Visit the following resources to learn more:
+
+- [@official@By-name Parameters | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/by-name-parameters.html)
+- [@article@How to Use By-Name Parameters in Scala | alvinalexander.com](https://alvinalexander.com/scala/fp-book/how-to-use-by-name-parameters-scala-functions/)
+- [@article@By-Name Parameters in Scala](https://tpolecat.github.io/2014/06/26/call-by-name.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/capabilities@kRM_HTRUvZ7xXjffu53Aw.md b/src/data/roadmaps/scala/content/capabilities@kRM_HTRUvZ7xXjffu53Aw.md
new file mode 100644
index 000000000..01881e683
--- /dev/null
+++ b/src/data/roadmaps/scala/content/capabilities@kRM_HTRUvZ7xXjffu53Aw.md
@@ -0,0 +1,7 @@
+# Capabilities
+
+Scala 3 introduces a new feature called "capabilities" as an alternative way to model effects. In short, a capability is an implicit function passed as a parameter. The function that requires a capability as a parameter declares in this way, that it will only work if in its scope is a capability to perform a certain task.
+
+Visit the following resources to learn more:
+
+- [@article@https://nrinaudo.github.io/articles/capabilities.html](https://nrinaudo.github.io/articles/capabilities.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/capture-checking@kbO0eO3UhUzPGaPvZKc_N.md b/src/data/roadmaps/scala/content/capture-checking@kbO0eO3UhUzPGaPvZKc_N.md
new file mode 100644
index 000000000..ef9e40404
--- /dev/null
+++ b/src/data/roadmaps/scala/content/capture-checking@kbO0eO3UhUzPGaPvZKc_N.md
@@ -0,0 +1,9 @@
+# Capture checking
+
+Capture Checking is an experimental feature in Scala that allows you to track which designated values are captured (i.e., stored as references) by arbitrary other values. This tracking happens at compile time and is currently an opt-in mechanism that can be enabled via an import. Capture checking helps ensure resource safety and prevent capability leakage by verifying at compile-time that capabilities (representing resources, effects, or permissions) are properly managed and do not escape their intended scope.
+
+Visit the following resources to learn more:
+
+- [@official@Capture Checking](https://docs.scala-lang.org/scala3/reference/experimental/cc.html)
+- [@article@Understanding Capture Checking in Scala | SoftwareMill](https://softwaremill.com/understanding-capture-checking-in-scala/)
+- [@article@Capture Checking Basics](https://nightly.scala-lang.org/docs/reference/experimental/capture-checking/basics.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/case-classes@EnTEDC1dzHf6H7P73Tlv5.md b/src/data/roadmaps/scala/content/case-classes@EnTEDC1dzHf6H7P73Tlv5.md
new file mode 100644
index 000000000..e9da5b607
--- /dev/null
+++ b/src/data/roadmaps/scala/content/case-classes@EnTEDC1dzHf6H7P73Tlv5.md
@@ -0,0 +1,9 @@
+# Case classes
+
+Case classes are a special type of class that is particularly useful for modeling immutable data. They provide several conveniences over regular classes, including immutability, several synthetic methods like toString, equals, and copy, as well as synthetic apply and unapply methods, which make case classes very useful for pattern matching.
+
+Visit the following resources to learn more:
+
+- [@official@Case Classes | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/case-classes.html)
+- [@official@Case Classes | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/case-classes.html)
+- [@article@Difference Between Class and Case Class in Scala | Baeldung on Scala](https://www.baeldung.com/scala/case-class)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/case-objects@0dptTJpHmNf_Nyo-ib20m.md b/src/data/roadmaps/scala/content/case-objects@0dptTJpHmNf_Nyo-ib20m.md
new file mode 100644
index 000000000..bb7f7f088
--- /dev/null
+++ b/src/data/roadmaps/scala/content/case-objects@0dptTJpHmNf_Nyo-ib20m.md
@@ -0,0 +1,9 @@
+# Case Objects
+
+Case objects are similar to regular Scala objects but with additional features that they share with case classes - immutable and with synthetic methods. They are often used for creating singleton objects and are particularly useful in pattern matching and message passing.
+
+Visit the following resources to learn more:
+
+- [@official@Case Objects | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/case-objects.html)
+- [@article@Difference between case object and object - Stack Overflow](https://stackoverflow.com/questions/5270752/difference-between-case-object-and-object)
+- [@article@Difference Between Case Object and Object | Baeldung on Scala](https://www.baeldung.com/scala/case-object-vs-object)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/category-theory@1mSU2_4W0bAMAph5jf7KC.md b/src/data/roadmaps/scala/content/category-theory@1mSU2_4W0bAMAph5jf7KC.md
new file mode 100644
index 000000000..4f6a880b0
--- /dev/null
+++ b/src/data/roadmaps/scala/content/category-theory@1mSU2_4W0bAMAph5jf7KC.md
@@ -0,0 +1,7 @@
+# Category Theory
+
+Category Theory is a branch of mathematics that deals with structures and relationships between them. In the context of Scala and functional programming, Category Theory provides a framework for understanding and designing functional programs. Key concepts include categories, functors, monads, and natural transformations, which are essential for writing maintainable functional code.
+
+Visit the following resources to learn more:
+
+- [@article@"Category Theory for Programmers" by Bartosz Milewski](https://bartoszmilewski.com/2014/10/28/category-theory-for-programmers-the-preface/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/cats@5A-62SFAXUd4OAEGd_RRz.md b/src/data/roadmaps/scala/content/cats@5A-62SFAXUd4OAEGd_RRz.md
new file mode 100644
index 000000000..a04fcc346
--- /dev/null
+++ b/src/data/roadmaps/scala/content/cats@5A-62SFAXUd4OAEGd_RRz.md
@@ -0,0 +1,11 @@
+# Cats
+
+Cats provides core abstractions for functional programming in Scala. It aims to be modular, approachable, and efficient, while providing a foundation for an ecosystem of pure, typeful libraries. Cats Effect, a part of the Cats ecosystem, offers a pure asynchronous runtime for Scala, enabling developers to build scalable and resilient applications. The ecosystem includes libraries for streaming frameworks, database layers, HTTP servers and clients, and more.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Cats Effect Documentation](https://typelevel.org/cats-effect/)
+- [@opensource@Cats GitHub Repository](https://github.com/typelevel/cats)
+- [@course@Cats Course on Rock the JVM](https://rockthejvm.com/courses/cats)
+- [@article@Cats Tutorial on Baeldung](https://www.baeldung.com/scala/cats-intro)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/class@UmX7kymkWSROjDZjnoEFg.md b/src/data/roadmaps/scala/content/class@UmX7kymkWSROjDZjnoEFg.md
new file mode 100644
index 000000000..993ce4d3b
--- /dev/null
+++ b/src/data/roadmaps/scala/content/class@UmX7kymkWSROjDZjnoEFg.md
@@ -0,0 +1,9 @@
+# Class
+
+A class is a blueprint for creating objects. Classes can contain methods, values, variables, types, objects, and traits. The primary constructor is defined in the class signature. Classes are defined using the class keyword followed by the class name.
+
+Visit the following resources to learn more:
+
+- [@official@Classes | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/classes.html)
+- [@article@Scala - Classes & Objects](https://www.tutorialspoint.com/scala/scala_classes_objects.htm)
+- [@article@Classes and Objects in Scala | Baeldung on Scala](https://www.baeldung.com/scala/classes-objects)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/collect--collectfirst@nCPJKbcDfc4w4c4TroBRe.md b/src/data/roadmaps/scala/content/collect--collectfirst@nCPJKbcDfc4w4c4TroBRe.md
new file mode 100644
index 000000000..f0e5b80be
--- /dev/null
+++ b/src/data/roadmaps/scala/content/collect--collectfirst@nCPJKbcDfc4w4c4TroBRe.md
@@ -0,0 +1,9 @@
+# collect / collectFirst
+
+The collect and collectFirst methods are used to apply a partial function to elements of a collection. The collect method takes a partial function as its parameter and applies it to all the elements in the collection to create a new collection. The new collection contains only those elements that were successfully mapped by the partial function. The collectFirst method applies the partial function to the first element in the collection for which the function is defined and returns its result wrapped with Some, or None if the function is not defined for any element in the collection.
+
+Visit the following resources to learn more:
+
+- [@article@Scala Tutorial - Collect Function](https://allaboutscala.com/tutorials/chapter-8-beginner-tutorial-using-scala-collection-functions/scala-collect-function/)
+- [@article@collect vs collectFirst - why the return values are of different type - Scala - Stack Overflow](https://stackoverflow.com/questions/40773529/collect-vs-collectfirst-why-the-return-values-are-of-different-type-scala)
+- [@article@tech: Scala : collectFirst example](http://thushw.blogspot.com/2015/09/scala-collectfirst-example.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/conditionals@PDoJZATYO9SmMfebmvORn.md b/src/data/roadmaps/scala/content/conditionals@PDoJZATYO9SmMfebmvORn.md
new file mode 100644
index 000000000..98707b022
--- /dev/null
+++ b/src/data/roadmaps/scala/content/conditionals@PDoJZATYO9SmMfebmvORn.md
@@ -0,0 +1,10 @@
+# Conditionals
+
+Conditional statements are primarily handled using if/else and match/case constructs. The if/else construct is straightforward and similar to other programming languages, allowing for simple conditional branching. The match/case construct is more powerful and can handle multiple conditions, pattern matching, and even include guards (additional conditions using if expressions within each case).
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@match Expressions | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/match-expressions.html)
+- [@article@Mastering Conditional Statements in Scala: If-Else and Match Explained](https://www.developerindian.com/articles/mastering-conditional-statements-in-scala-if-else-and-match-explained)
+- [@article@Scala: How to add ‘if’ expressions (guards) to match/case expressions](https://alvinalexander.com/scala/how-to-use-if-then-expressions-guards-in-case-statements-scala/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/context-bounds@96F_G2PY8VG_Et9g4DFX2.md b/src/data/roadmaps/scala/content/context-bounds@96F_G2PY8VG_Et9g4DFX2.md
new file mode 100644
index 000000000..f578139f4
--- /dev/null
+++ b/src/data/roadmaps/scala/content/context-bounds@96F_G2PY8VG_Et9g4DFX2.md
@@ -0,0 +1,9 @@
+# Context bounds
+
+Context Bounds in Scala is a feature that provides a shorthand syntax for expressing the common pattern of a context parameter that depends on a type parameter. Context bounds are used to simplify the code for generic types and are particularly useful in the context of type classes.
+
+Visit the following resources to learn more:
+
+- [@official@Context Bounds | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/ca-context-bounds.html)
+- [@article@Demystifying View and Context Bounds | Baeldung on Scala](https://www.baeldung.com/scala/view-context-bounds)
+- [@article@Context Bounds - Scala 3 - EPFL](https://dotty.epfl.ch/docs/reference/contextual/context-bounds.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/conversions@OdcjkyWs3s86CqtUnAdxx.md b/src/data/roadmaps/scala/content/conversions@OdcjkyWs3s86CqtUnAdxx.md
new file mode 100644
index 000000000..ce67cba40
--- /dev/null
+++ b/src/data/roadmaps/scala/content/conversions@OdcjkyWs3s86CqtUnAdxx.md
@@ -0,0 +1,8 @@
+# Conversions
+Implicit conversions allow the compiler to automatically convert one type to another in certain situations. In Scala 3, implicit conversions are defined by a given instance of type scala.Conversion[S, T], where S is the source type and T is the target type. In Scala 3.8+, the into keyword is used to mark types that can be implicitly converted. If the expected type of an expression is into[T], then an implicit conversion to that type can be inserted without the need for a language import.
+
+Visit the following resources to learn more:
+
+- [@official@Implicit Conversions | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/implicit-conversions.html)
+- [@official@Implicit Conversions | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/ca-implicit-conversions.html)
+- [@article@Implicit Conversions | Baeldung on Scala](https://www.baeldung.com/scala/implicit-conversions)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/courses@yzVo7NtvU5HdGqg7T7XAh.md b/src/data/roadmaps/scala/content/courses@yzVo7NtvU5HdGqg7T7XAh.md
new file mode 100644
index 000000000..f971af785
--- /dev/null
+++ b/src/data/roadmaps/scala/content/courses@yzVo7NtvU5HdGqg7T7XAh.md
@@ -0,0 +1,3 @@
+# Courses
+
+Courses offer a structured learning path, typically designed by experts, that guides you through the fundamentals to advanced concepts. They often include hands-on exercises, projects, and assessments to reinforce learning and provide practical experience. Courses come in various formats, like online videos, interactive tutorials, and in-person workshops, catering to different learning preferences and schedules. They can be a great way to stay motivated, track your progress, and gain a recognized credential upon completion.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/data-structures@ACR-ncVRUYN0LXm5x6NhS.md b/src/data/roadmaps/scala/content/data-structures@ACR-ncVRUYN0LXm5x6NhS.md
new file mode 100644
index 000000000..cbb93af37
--- /dev/null
+++ b/src/data/roadmaps/scala/content/data-structures@ACR-ncVRUYN0LXm5x6NhS.md
@@ -0,0 +1,3 @@
+# Data Structures: Class, Trait, and Object
+
+Scala provides three fundamental building blocks for structuring data and behavior: classes, traits, and objects. A class is a blueprint for creating objects, encapsulating data (fields) and behavior (methods). A trait is similar to an interface but can also contain concrete methods and fields, allowing for code reuse through mixins. An object is a singleton instance of a class, useful for creating utility classes or entry points to applications. Together, these structures enable the creation of well-organized and maintainable code.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/docs@I_Bs6mryYyEAnwT_oPQ5A.md b/src/data/roadmaps/scala/content/docs@I_Bs6mryYyEAnwT_oPQ5A.md
new file mode 100644
index 000000000..27eb27f84
--- /dev/null
+++ b/src/data/roadmaps/scala/content/docs@I_Bs6mryYyEAnwT_oPQ5A.md
@@ -0,0 +1,3 @@
+# Docs
+
+Scala's official documentation is a fantastic place to start learning the language and its features. It provides comprehensive guides, tutorials, and API references that cover everything from basic syntax to advanced concepts.  You can find clear explanations, practical examples, and detailed descriptions, making it easy to understand how different parts of Scala work and how to use them effectively.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/early-returns@votWwsha27Bt9i5GhHRvA.md b/src/data/roadmaps/scala/content/early-returns@votWwsha27Bt9i5GhHRvA.md
new file mode 100644
index 000000000..799f6b997
--- /dev/null
+++ b/src/data/roadmaps/scala/content/early-returns@votWwsha27Bt9i5GhHRvA.md
@@ -0,0 +1,7 @@
+# Early returns
+
+This topic brings together several concepts you have already encountered: pattern matching, partial functions, the apply and unapply methods, and lazy collections. Its purpose is to let you see how they work together.
+
+Visit the following resources to learn more:
+
+- [@article@Many Happy Early Returns](https://makingthematrix.wordpress.com/2021/03/09/many-happy-early-returns/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/ecosystems@BIeOReaWlfP0SkFl1B44M.md b/src/data/roadmaps/scala/content/ecosystems@BIeOReaWlfP0SkFl1B44M.md
new file mode 100644
index 000000000..bab957193
--- /dev/null
+++ b/src/data/roadmaps/scala/content/ecosystems@BIeOReaWlfP0SkFl1B44M.md
@@ -0,0 +1,3 @@
+# Know your ecosystem
+
+Ecosystems in Scala are groups of frameworks and libraries that work well together and are often maintained and developed by the same organization. While nothing is stopping you from choosing any framework or library from the wide spectrum of Scala open-source projects, it often makes sense to stick to those that belong to the same ecosystem unless you have a good reason to pick another. Of course, you’re also free to use one ecosystem in one project and another in a different project.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/either@P0Vo-2ShpFVfBxIrupLll.md b/src/data/roadmaps/scala/content/either@P0Vo-2ShpFVfBxIrupLll.md
new file mode 100644
index 000000000..e0892e26d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/either@P0Vo-2ShpFVfBxIrupLll.md
@@ -0,0 +1,9 @@
+# Either
+
+The Either class in Scala is used to represent a value of one of two possible types (a disjoint union). An instance of Either is either an instance of scala.util.Left or scala.util.Right.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Standard Library 2.13.6 - scala.util.Either](https://www.scala-lang.org/api/2.13.6/scala/util/Either.html)
+- [@article@Scala - Either class | by zeesh.arif | Medium](https://zeesh-arif.medium.com/scala-either-class-ca6cb44c3643)
+- [@article@A Scala Either, Left, and Right example (like Option, Some, and None) | alvinalexander.com](https://alvinalexander.com/scala/scala-either-left-right-example-option-some-none-null/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/emacs@JSzlu4UNQA016AtE5xxml.md b/src/data/roadmaps/scala/content/emacs@JSzlu4UNQA016AtE5xxml.md
new file mode 100644
index 000000000..9b316e967
--- /dev/null
+++ b/src/data/roadmaps/scala/content/emacs@JSzlu4UNQA016AtE5xxml.md
@@ -0,0 +1,8 @@
+# Emacs
+
+Emacs is a highly extensible and customizable text editor known for its features and flexibility. When equipped with the Metals plugin, Emacs becomes a robust environment for Scala development, offering features like code completion, refactoring, and debugging.
+
+Visit the following resources to learn more:
+
+- [@official@Emacs Main Page](https://www.gnu.org/software/emacs/)
+- [@official@Emacs | Scalameta](https://scalameta.org/metals/docs/editors/emacs/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/enums@bSZbsqY1yzq9uKbFlgwkF.md b/src/data/roadmaps/scala/content/enums@bSZbsqY1yzq9uKbFlgwkF.md
new file mode 100644
index 000000000..d48114715
--- /dev/null
+++ b/src/data/roadmaps/scala/content/enums@bSZbsqY1yzq9uKbFlgwkF.md
@@ -0,0 +1,9 @@
+# Enums
+
+In Scala 3, enums are used to define a type consisting of a set of named values. They provide a more concise and safer way to define enumerations compared to the traditional Enumeration class in Scala 2.
+
+Visit the following resources to learn more:
+
+- [@official@Enumerations | Scala documentation](https://docs.scala-lang.org/scala3/reference/enums/enums.html)
+- [@article@Enums in Scala 3: Quickly Explained | Rock the JVM](https://rockthejvm.com/articles/enums-in-scala-3)
+- [@article@Guide to Scala Enumerations | Baeldung on Scala](https://www.baeldung.com/scala/enumerations)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/error-handling@1T7yhzZMoFKUvgS4ZWiPc.md b/src/data/roadmaps/scala/content/error-handling@1T7yhzZMoFKUvgS4ZWiPc.md
new file mode 100644
index 000000000..978c2babe
--- /dev/null
+++ b/src/data/roadmaps/scala/content/error-handling@1T7yhzZMoFKUvgS4ZWiPc.md
@@ -0,0 +1,9 @@
+# Error handling
+
+Scala offers multiple ways to handle errors, including try/catch/finally blocks, Option, Either, and Try. These methods allow developers to handle exceptions and errors in a functional and composable way.
+
+Visit the following resources to learn more:
+
+- [@official@Functional Error Handling in Scala | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/functional-error-handling.html)
+- [@official@Error Handling in Scala](https://docs.scala-lang.org/overviews/scala-book/functional-error-handling.html)
+- [@article@Idiomatic Error Handling in Scala | Rock the JVM](https://rockthejvm.com/articles/idiomatic-error-handling-in-scala)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/filter@hK_E1meVZkK6ICUs5qmIP.md b/src/data/roadmaps/scala/content/filter@hK_E1meVZkK6ICUs5qmIP.md
new file mode 100644
index 000000000..a4967d481
--- /dev/null
+++ b/src/data/roadmaps/scala/content/filter@hK_E1meVZkK6ICUs5qmIP.md
@@ -0,0 +1,8 @@
+# Filter
+
+The `filter` method in Scala collections lets you pick out the elements you want based on a condition. You give it a function that takes an element and returns `true` if you want to keep it, and `false` if you want to discard it. The `filter` method then returns a new collection containing only the elements for which the function returned `true`.
+
+Visit the following resources to learn more:
+
+- [@official@Collections Methods | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/collections-methods.html)
+- [@article@Different Ways to Filter Elements From a Scala Collection | Baeldung on Scala](https://www.baeldung.com/scala/filter-collections)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/find@qU8svc-H5L2-QeBSXgp_8.md b/src/data/roadmaps/scala/content/find@qU8svc-H5L2-QeBSXgp_8.md
new file mode 100644
index 000000000..4049c356d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/find@qU8svc-H5L2-QeBSXgp_8.md
@@ -0,0 +1,8 @@
+# find
+
+The `find` method is used on collections (like Lists, Sets, or Maps) to locate the first element that satisfies a given condition.  You provide `find` with a function that checks each element, and if the function returns `true` for an element, `find` immediately returns `Some(element)`. If no element matches the condition, it returns `None`. Think of it as a targeted search that stops as soon as it finds a match.
+
+Visit the following resources to learn more:
+
+- [@official@Collections Methods | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/collections-methods.html)
+- [@article@Scala Collections Filter | Tutorials Point](https://www.tutorialspoint.com/scala_collections/scala_collections_filter.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/flatmap@zEJeNsQcCz4hk7t7fDuVL.md b/src/data/roadmaps/scala/content/flatmap@zEJeNsQcCz4hk7t7fDuVL.md
new file mode 100644
index 000000000..fdddc9e92
--- /dev/null
+++ b/src/data/roadmaps/scala/content/flatmap@zEJeNsQcCz4hk7t7fDuVL.md
@@ -0,0 +1,9 @@
+# flatMap
+
+The flatMap method is used to apply a function to each element of a collection and then flatten the results into a new collection. It is essentially a combination of the map method followed by the flatten method, but this seemingly very simple property makes it fundamental for Functional Programming.
+
+Visit the following resources to learn more:
+
+- [@article@A collection of Scala 'flatMap' examples](https://alvinalexander.com/scala/collection-scala-flatmap-examples-map-flatten/)
+- [@article@Scala Tutorial - FlatMap Function](https://allaboutscala.com/tutorials/chapter-8-beginner-tutorial-using-scala-collection-functions/scala-flatmap-function/)
+- [@article@Difference Between map() and flatMap() in Scala](https://www.baeldung.com/scala/map-vs-flatmap)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/float@3MO2hkUs5wh1Xkcs1Yr7s.md b/src/data/roadmaps/scala/content/float@3MO2hkUs5wh1Xkcs1Yr7s.md
new file mode 100644
index 000000000..a28352fe1
--- /dev/null
+++ b/src/data/roadmaps/scala/content/float@3MO2hkUs5wh1Xkcs1Yr7s.md
@@ -0,0 +1,3 @@
+# Float
+
+Floats in Scala are used to represent numbers with decimal points. They are like regular numbers but can have a fractional part, such as 3.14 or -2.7. A float uses 32 bits of memory and can store values with a certain level of precision. Because they are stored in binary format with a limited number of bits, they can sometimes have slight inaccuracies when representing certain decimal numbers.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/foldleft@GUvy5sUdY32NJ_9aIzMr9.md b/src/data/roadmaps/scala/content/foldleft@GUvy5sUdY32NJ_9aIzMr9.md
new file mode 100644
index 000000000..55381ed87
--- /dev/null
+++ b/src/data/roadmaps/scala/content/foldleft@GUvy5sUdY32NJ_9aIzMr9.md
@@ -0,0 +1,9 @@
+# foldLeft
+
+The foldLeft method is used to produce a single result by "folding" all the elements of a collection. The algorithm starts with a "zero" element which is paired with the first element of the collection to create an intermediate result element. Then that intermediate result is paired with the second element of the collection to create a new intermediate result, and so on, until the algorithm reaches the end of the collection. Then the final result is returned.
+
+Visit the following resources to learn more:
+
+- [@article@Scala Collections - FoldLeft Method](https://www.tutorialspoint.com/scala_collections/scala_collections_foldleft.htm)
+- [@article@Folding Lists in Scala | Baeldung on Scala](https://www.baeldung.com/scala/folding-lists)
+- [@article@Scala Tutorial - FoldLeft Function Example](https://allaboutscala.com/tutorials/chapter-8-beginner-tutorial-using-scala-collection-functions/scala-foldleft-example/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/for-comprehension@pk6KQObR5AhAXj0wf5a3p.md b/src/data/roadmaps/scala/content/for-comprehension@pk6KQObR5AhAXj0wf5a3p.md
new file mode 100644
index 000000000..f232043ca
--- /dev/null
+++ b/src/data/roadmaps/scala/content/for-comprehension@pk6KQObR5AhAXj0wf5a3p.md
@@ -0,0 +1,9 @@
+# for-comprehensions
+
+For-comprehensions in Scala are used to evaluate expressions and return a sequence of values. They have the form for (enumerators) yield e, where enumerators refer to a list of enumerators. They are basically syntax sugar over flatMap but they help a lot in making your code both safe and.
+
+Visit the following resources to learn more:
+
+- [@official@For Comprehensions | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/for-comprehensions.html)
+- [@article@A Comprehensive Guide to For-Comprehension in Scala | Baeldung on Scala](https://www.baeldung.com/scala/for-comprehension)
+- [@article@Scala: comprehending the for-comprehension | by Linas Medžiūnas | Wix Engineering | Medium](https://medium.com/wix-engineering/scala-comprehending-the-for-comprehension-67c9f7953655)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/foreach@MEwfeQ3yolH5bLVtHocaA.md b/src/data/roadmaps/scala/content/foreach@MEwfeQ3yolH5bLVtHocaA.md
new file mode 100644
index 000000000..e41dab6ee
--- /dev/null
+++ b/src/data/roadmaps/scala/content/foreach@MEwfeQ3yolH5bLVtHocaA.md
@@ -0,0 +1,9 @@
+# foreach
+
+The foreach method is used to apply a function to each element of a collection for its side effects. Unlike methods like map or filter, foreach does not return a value; it is used primarily for operations that have side effects, such as printing elements or modifying external state.
+
+Visit the following resources to learn more:
+
+- [@official@for Loops | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/for-loops.html)
+- [@article@Scala Tutorial - Foreach Function Example](https://allaboutscala.com/tutorials/chapter-8-beginner-tutorial-using-scala-collection-functions/scala-foreach-example/)
+- [@article@Using foreach() Method in Scala Collections | Baeldung on Scala](https://www.baeldung.com/scala/foreach-collections)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/funcs-returning-funcs@eSzfUe1nYv7TA3Nl9h2aN.md b/src/data/roadmaps/scala/content/funcs-returning-funcs@eSzfUe1nYv7TA3Nl9h2aN.md
new file mode 100644
index 000000000..faa9b5cf7
--- /dev/null
+++ b/src/data/roadmaps/scala/content/funcs-returning-funcs@eSzfUe1nYv7TA3Nl9h2aN.md
@@ -0,0 +1,10 @@
+# Functions returning functions
+
+In Scala, functions can return other functions. Currying is the process of converting a function with multiple arguments into a sequence of functions that take one argument each. Function composition is the process of combining two or more functions to create a new function.
+Resources
+
+Visit the following resources to learn more:
+
+- [@article@Currying in Scala | Baeldung on Scala](https://www.baeldung.com/scala/currying)
+- [@article@Currying Functions in Scala](https://www.tutorialspoint.com/scala/currying_functions.htm)
+- [@article@Partially Applied Functions and Currying](https://www.scalamatters.io/post/partially-applied-functions-and-currying)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/functions--methods@e1dvY1Wd6ZYw2ULKETc49.md b/src/data/roadmaps/scala/content/functions--methods@e1dvY1Wd6ZYw2ULKETc49.md
new file mode 100644
index 000000000..3c43d7ed0
--- /dev/null
+++ b/src/data/roadmaps/scala/content/functions--methods@e1dvY1Wd6ZYw2ULKETc49.md
@@ -0,0 +1,9 @@
+# Functions & Methods
+
+Functions and methods are fundamental building blocks for organizing and reusing code. A function is essentially a block of code that performs a specific task. You give it some input (arguments), and it returns an output (return value). A method is very similar to a function, but it's associated with an object or class. It operates on the data within that object or class. In practice, the distinction between functions and methods in Scala is often blurred, but the key is they both allow you to break down complex problems into smaller, manageable pieces.
+
+Visit the following resources to learn more:
+
+- [@official@Functions](https://docs.scala-lang.org/tour/basics.html#functions)
+- [@official@Methods](https://docs.scala-lang.org/tour/basics.html#methods)
+- [@article@Functions and Methods in Scala](https://www.baeldung.com/scala/functions-methods)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/gradle@tYMRMVFon8V--pXLeye0U.md b/src/data/roadmaps/scala/content/gradle@tYMRMVFon8V--pXLeye0U.md
new file mode 100644
index 000000000..546f7df7a
--- /dev/null
+++ b/src/data/roadmaps/scala/content/gradle@tYMRMVFon8V--pXLeye0U.md
@@ -0,0 +1,11 @@
+# Gradle
+
+Gradle is widely used for building, testing, publishing, and deploying software packages. It is known for its flexibility and efficiency in managing dependencies and resolving version conflicts. Gradle uses a Groovy-based Domain Specific Language (DSL) for writing build scripts, making it more flexible and readable compared to XML-based build tools like Maven. Gradle supports incremental builds and build caching, which can significantly speed up the build process. It is commonly used for Java, Kotlin, and Android projects but can also be used for Scala.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Gradle Guides](https://gradle.org/guides/)
+- [@official@Gradle User Manual](https://docs.gradle.org/current/userguide/userguide.html)
+- [@course@Gradle Fundamentals on Udemy](https://www.udemy.com/course/gradle-fundamentals/)
+- [@article@Gradle Tutorial on TutorialsPoint](https://www.tutorialspoint.com/gradle/index.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/implicit-parameter@9PiyO8DlNgas10ZjZJCkA.md b/src/data/roadmaps/scala/content/implicit-parameter@9PiyO8DlNgas10ZjZJCkA.md
new file mode 100644
index 000000000..e143e15ae
--- /dev/null
+++ b/src/data/roadmaps/scala/content/implicit-parameter@9PiyO8DlNgas10ZjZJCkA.md
@@ -0,0 +1,9 @@
+# Implicit parameters
+
+Implicit parameters are passed to functions without having to explicitly specify them at the call site. This can make your code more concise and readable, especially when dealing with common or boilerplate code. In Scala 2, they were declared with the implicit keyword. In Scala 3, we use keywords given and using. The given keyword is used to define instances of implicit values, and the using keyword is used to declare context parameters.
+
+Visit the following resources to learn more:
+
+- [@official@Using Clauses | Scala documentation](https://docs.scala-lang.org/scala3/reference/contextual/using-clauses.html)
+- [@article@Scala 3: Given and Using Clauses | Rock the JVM](https://rockthejvm.com/articles/scala-3-given-and-using-clauses)
+- [@article@Scala 3: Using Term Inference with Given and Using (and extension methods) | alvinalexander.com](https://alvinalexander.com/scala/scala-3-given-using-term-inference-context/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/integers@xNMXubCcKuaSkYIgz0YVk.md b/src/data/roadmaps/scala/content/integers@xNMXubCcKuaSkYIgz0YVk.md
new file mode 100644
index 000000000..ba8533247
--- /dev/null
+++ b/src/data/roadmaps/scala/content/integers@xNMXubCcKuaSkYIgz0YVk.md
@@ -0,0 +1,3 @@
+# Integers
+
+Integers are whole numbers, meaning they don't have any fractional or decimal parts. In Scala, integers can be positive (like 5), negative (like -10), or zero (0). They are used for counting and performing arithmetic calculations that involve only whole numbers. Scala provides several integer types, each with a different range of values they can represent, allowing you to choose the most appropriate type based on the size of the numbers you need to work with.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/intellij-idea@zDXDdfzObrUlrIkgxCouq.md b/src/data/roadmaps/scala/content/intellij-idea@zDXDdfzObrUlrIkgxCouq.md
new file mode 100644
index 000000000..e8395b548
--- /dev/null
+++ b/src/data/roadmaps/scala/content/intellij-idea@zDXDdfzObrUlrIkgxCouq.md
@@ -0,0 +1,8 @@
+# IntelliJ IDEA
+
+IntelliJ IDEA is a popular integrated development environment (IDE) that offers support for Scala through its Scala Plugin. This plugin provides essential features for Scala development, including code completion, refactoring, debugging, and seamless integration with build tools like sbt and Maven.
+
+Visit the following resources to learn more:
+
+- [@official@Scala IDE | The Landing Page](https://www.jetbrains.com/pages/scala/)
+- [@official@Get Started With Scala | IntelliJ IDEA Documentation](https://www.jetbrains.com/help/idea/get-started-with-scala.html#new-scala-project)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/introduction@ojvTMCBlgUf6ywgsgCQM1.md b/src/data/roadmaps/scala/content/introduction@ojvTMCBlgUf6ywgsgCQM1.md
new file mode 100644
index 000000000..a7260f9b2
--- /dev/null
+++ b/src/data/roadmaps/scala/content/introduction@ojvTMCBlgUf6ywgsgCQM1.md
@@ -0,0 +1,3 @@
+# Introduction
+
+Scala is a programming language that blends object-oriented and functional programming ideas. It runs on the Java Virtual Machine (JVM) and can also be compiled to JavaScript. This makes it possible to use Scala for a wide variety of tasks, from building large-scale systems to writing web applications and scripts. It is designed to be concise, elegant, and type-safe, aiming to provide developers with powerful tools for creating robust and scalable applications.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/iterators@jMqwWE2Aebd7wT4iogIIW.md b/src/data/roadmaps/scala/content/iterators@jMqwWE2Aebd7wT4iogIIW.md
new file mode 100644
index 000000000..f1b3de4e3
--- /dev/null
+++ b/src/data/roadmaps/scala/content/iterators@jMqwWE2Aebd7wT4iogIIW.md
@@ -0,0 +1,8 @@
+# Iterators
+
+An iterator is a mechanism to access a collection's elements sequentially in a performant way. They are often used in loops. On the other hand, they are mutable, and careless use can lead to non-trivial bugs.
+
+Visit the following resources to learn more:
+
+- [@official@Iterators | Collections (Scala 2.8 - 2.12) | Scala Documentation](https://docs.scala-lang.org/overviews/collections/iterators.html)
+- [@article@Scala - Iterators](https://www.tutorialspoint.com/scala/scala_iterators.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/jvm@Gy7AaiqSL_38yB73C5W5B.md b/src/data/roadmaps/scala/content/jvm@Gy7AaiqSL_38yB73C5W5B.md
new file mode 100644
index 000000000..f9a816c73
--- /dev/null
+++ b/src/data/roadmaps/scala/content/jvm@Gy7AaiqSL_38yB73C5W5B.md
@@ -0,0 +1,9 @@
+# JVM
+
+Scala's primary platform is the Java Virtual Machine (JVM). Scala code is compiled into Java bytecode, allowing it to run on any device with a JVM, independent of the underlying machine configuration. This setup ensures compatibility with Java libraries and tools, making Scala a versatile choice for developers familiar with the Java ecosystem. The JVM's backward compatibility ensures that Scala code compiled on older versions can run on newer JVMs without issues.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Documentation on JDK Compatibility](https://docs.scala-lang.org/overviews/jdk-compatibility/overview.html)
+- [@article@TutorialsPoint: Understanding Java JDK, JRE, and JVM](https://www.tutorialspoint.com/java/java-jdk-jre-jvm.htm)
+- [@article@Scala and JVM Basics on Toptal](https://www.toptal.com/scala/scala-bytecode-and-the-jvm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/laziness@YqAClVg7U1mb-Be_rnv-L.md b/src/data/roadmaps/scala/content/laziness@YqAClVg7U1mb-Be_rnv-L.md
new file mode 100644
index 000000000..729e1acba
--- /dev/null
+++ b/src/data/roadmaps/scala/content/laziness@YqAClVg7U1mb-Be_rnv-L.md
@@ -0,0 +1,9 @@
+# Laziness
+
+Laziness is a feature that allows you to defer the evaluation of an expression until it is needed. This can be useful for optimizing performance and avoiding unnecessary computations.
+
+Visit the following resources to learn more:
+
+- [@official@Let Them Be Lazy! | The Scala Programming Language](https://www.scala-lang.org/blog/2017/11/28/view-based-collections.html)
+- [@article@Understand and implement laziness with examples in Scala, JavaScript, Swift and Racket](https://matt.might.net/articles/implementing-laziness/)
+- [@article@Laziness in Scala | InfoWorld](https://www.infoworld.com/article/2072680/laziness-in-scala.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/lazy-collections@kRdh-HUAWJi7d8gdynGUS.md b/src/data/roadmaps/scala/content/lazy-collections@kRdh-HUAWJi7d8gdynGUS.md
new file mode 100644
index 000000000..125ab0dd1
--- /dev/null
+++ b/src/data/roadmaps/scala/content/lazy-collections@kRdh-HUAWJi7d8gdynGUS.md
@@ -0,0 +1,7 @@
+# Lazy collections
+
+Lazy collections are used to describe successive transformation operations without evaluating intermediate transformations. They are particularly useful for creating infinite collections without blowing the memory.
+
+Visit the following resources to learn more:
+
+- [@official@Let Them Be Lazy!](https://www.scala-lang.org/blog/2017/11/28/view-based-collections.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/lazy-vals@iMe2czy5d7uNpB2Uv2KTK.md b/src/data/roadmaps/scala/content/lazy-vals@iMe2czy5d7uNpB2Uv2KTK.md
new file mode 100644
index 000000000..b4ae712d2
--- /dev/null
+++ b/src/data/roadmaps/scala/content/lazy-vals@iMe2czy5d7uNpB2Uv2KTK.md
@@ -0,0 +1,9 @@
+# Lazy vals
+
+Lazy vals are used to defer the initialization of a variable until it is accessed for the first time. This can be useful for optimizing performance and avoiding unnecessary computations.
+
+Visit the following resources to learn more:
+
+- [@official@Lazy Vals Initialization](https://docs.scala-lang.org/scala3/reference/changed-features/lazy-vals-init.html)
+- [@article@Guide to lazy val in Scala | Baeldung on Scala](https://www.baeldung.com/scala/lazy-val)
+- [@article@scala - What does a lazy val do? - Stack Overflow](https://stackoverflow.com/questions/7484928/what-does-a-lazy-val-do)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/lazylist@zk07chk34XuM1mac4oe4-.md b/src/data/roadmaps/scala/content/lazylist@zk07chk34XuM1mac4oe4-.md
new file mode 100644
index 000000000..aef486783
--- /dev/null
+++ b/src/data/roadmaps/scala/content/lazylist@zk07chk34XuM1mac4oe4-.md
@@ -0,0 +1,9 @@
+# LazyList
+
+A lazy list is an immutable linked list that computes its elements only when they are needed. Elements are memoized, meaning the value of each element is computed at most once.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Standard Library 2.13.4 - scala.collection.immutable.LazyList](https://www.scala-lang.org/api/2.13.4/scala/collection/immutable/LazyList.html)
+- [@article@LazyList - Scala 3 - EPFL](https://dotty.epfl.ch/api/scala/collection/immutable/LazyList.html)
+- [@article@LazyList in Scala | Baeldung on Scala](https://www.baeldung.com/scala/lazylist)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/li-haoyi@OYiz0dgiVjYilNRSjh9la.md b/src/data/roadmaps/scala/content/li-haoyi@OYiz0dgiVjYilNRSjh9la.md
new file mode 100644
index 000000000..761f96bcb
--- /dev/null
+++ b/src/data/roadmaps/scala/content/li-haoyi@OYiz0dgiVjYilNRSjh9la.md
@@ -0,0 +1,10 @@
+# Li Haoyi
+
+The Li Haoyi ecosystem is centered around making Scala easy to use and productive. It includes libraries like Ammonite REPL, Mill Build Tool, os-lib, uPickle, Cask, and Scalatags. This ecosystem emphasizes executable pseudocode, ease of use, and productivity. It is designed to allow developers to write Scala in a way that is easy and productive, delivering real business value. The ecosystem is maintained by Li Haoyi and is known for its simplicity and practicality.
+
+Visit the following resources to learn more:
+
+- [@official@Li Haoyi's Programming Blog](http://www.lihaoyi.com/)
+- [@opensource@com-lihaoyi GitHub Repository](https://github.com/com-lihaoyi)
+- [@article@12 Years of the com.lihaoyi Scala Platform](https://www.lihaoyi.com/post/12yearsofthecomlihaoyiScalaPlatform.html)
+- [@article@Hands-on Scala Programming](https://www.handsonscala.com/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/list@HCXshB5qPYlYmyg3ufA4a.md b/src/data/roadmaps/scala/content/list@HCXshB5qPYlYmyg3ufA4a.md
new file mode 100644
index 000000000..99f69968c
--- /dev/null
+++ b/src/data/roadmaps/scala/content/list@HCXshB5qPYlYmyg3ufA4a.md
@@ -0,0 +1,9 @@
+# List
+
+Lists are ordered, immutable collections of elements of the same type. Once a list is created, you can't change its elements directly; instead, you create a new list with the desired modifications. They're useful for storing sequences of items where the order matters, like a to-do list or a series of events. Common operations include adding elements to the beginning of the list (using `::`), accessing elements by index, and iterating through the list.
+
+Visit the following resources to learn more:
+
+- [@official@Collection Types - Lists](https://docs.scala-lang.org/scala3/book/collections-classes.html#list)
+- [@official@List](https://www.scala-lang.org/api/3.x/scala/collection/immutable/List.html)
+- [@article@Scala - Lists](https://www.tutorialspoint.com/scala/scala_lists.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/loops@VVO1Cmn0HwVKeMZNJiixa.md b/src/data/roadmaps/scala/content/loops@VVO1Cmn0HwVKeMZNJiixa.md
new file mode 100644
index 000000000..75b77749d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/loops@VVO1Cmn0HwVKeMZNJiixa.md
@@ -0,0 +1,9 @@
+# Loops
+
+Loops are used to execute a block of code repeatedly. Scala supports the following types of loops. **while loop**: Repeats a statement or group of statements while a given condition is true. It tests the condition before executing the loop body. **for loop**: Used to iterate over collections or ranges. It is often used for its readability and conciseness. **do-while loop**: Deprecated in Scala 3. Similar to the while loop, but the condition is tested at the end of the loop body, ensuring that the loop body is executed at least once.
+
+Visit the following resources to learn more:
+
+- [@official@for loops | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/for-loops.html)
+- [@official@Scala - while loop](https://docs.scala-lang.org/overviews/scala-book/for-loops.html)
+- [@article@Scala | Loops (while, do..while, for, nested loops)](https://www.geeksforgeeks.org/scala/scala-loopswhile-do-while-for-nested-loops/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/macros@mq3uKXW57PdAkbuSBsznD.md b/src/data/roadmaps/scala/content/macros@mq3uKXW57PdAkbuSBsznD.md
new file mode 100644
index 000000000..b8c423b4a
--- /dev/null
+++ b/src/data/roadmaps/scala/content/macros@mq3uKXW57PdAkbuSBsznD.md
@@ -0,0 +1,10 @@
+# Macros
+
+Macros enable advanced metaprogramming capabilities, such as code generation, optimizations, and the creation of domain-specific languages (DSLs). Scala 3 macros were redesigned to be more intuitive and flexible than the previous version.
+
+Visit the following resources to learn more:
+
+- [@official@Scala 3 Macros | Macros in Scala 3 | Scala Documentation](https://docs.scala-lang.org/scala3/guides/macros/macros.html)
+- [@official@Tutorial | Macros in Scala 3 | Scala Documentation](https://docs.scala-lang.org/scala3/guides/macros/)
+- [@article@Scala 3 macros tips & tricks | SoftwareMill Blog](https://softwaremill.com/scala-3-macros-tips-and-tricks/)
+- [@article@Guide to Scala 3 Macros | Rock the JVM](https://rockthejvm.com/articles/scala-3-macros-comprehensive-guide)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/map@i4gSxrJSki5um_6dfLUYK.md b/src/data/roadmaps/scala/content/map@i4gSxrJSki5um_6dfLUYK.md
new file mode 100644
index 000000000..0a0163871
--- /dev/null
+++ b/src/data/roadmaps/scala/content/map@i4gSxrJSki5um_6dfLUYK.md
@@ -0,0 +1,8 @@
+# Map
+
+A Map is a collection that holds key-value pairs. Think of it like a dictionary where each key is associated with a specific value. Keys are unique within a map, and you use a key to quickly retrieve its corresponding value. Maps are useful for storing and accessing data based on a unique identifier.
+
+Visit the following resources to learn more:
+
+- [@official@Maps | Collections (Scala 2.8 - 2.12) | Scala Documentation](https://docs.scala-lang.org/overviews/collections-2.13/maps.html)
+- [@article@Scala - Maps](https://www.tutorialspoint.com/scala/scala_maps.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/map@zhRrfAotX8wq6HjR3s13B.md b/src/data/roadmaps/scala/content/map@zhRrfAotX8wq6HjR3s13B.md
new file mode 100644
index 000000000..a952e6af1
--- /dev/null
+++ b/src/data/roadmaps/scala/content/map@zhRrfAotX8wq6HjR3s13B.md
@@ -0,0 +1,10 @@
+# map
+
+The map method is used to apply a function to each element of a collection and create a new collection with the same number of elements, where each element is the result of applying that function to the original element.
+ Resources
+
+Visit the following resources to learn more:
+
+- [@official@Write Your Own map Method | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/fun-write-map-function.html)
+- [@official@A Guide to Scala Maps | Baeldung on Scala](https://docs.scala-lang.org/scala3/book/fun-write-map-function.html)
+- [@article@How to Write a 'map' Function in Scala](https://www.baeldung.com/scala/maps-guide)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/maven@6D5cj3ekHNkZPy1Z8ONaQ.md b/src/data/roadmaps/scala/content/maven@6D5cj3ekHNkZPy1Z8ONaQ.md
new file mode 100644
index 000000000..f732127fb
--- /dev/null
+++ b/src/data/roadmaps/scala/content/maven@6D5cj3ekHNkZPy1Z8ONaQ.md
@@ -0,0 +1,10 @@
+# Maven
+
+Maven is a build automation and dependency management tool primarily used for Java projects. It simplifies the build process by using a Project Object Model (POM) file, typically named pom.xml, which centralizes project configuration and manages dependencies. Maven follows best practices and conventions to ensure consistent project setups, making it easier for developers to understand and manage projects. It integrates well with other tools like IDEs (Eclipse, IntelliJ IDEA) and version control systems (Git). Maven's key features include dependency management, build automation, and a large repository of libraries and metadata.
+
+Visit the following resources to learn more:
+
+- [@official@Maven in 5 Minutes](https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html)
+- [@article@Maven Tutorial on TutorialsPoint](https://www.tutorialspoint.com/maven/index.htm)
+- [@article@Apache Maven Tutorial on Baeldung](https://www.baeldung.com/maven)
+- [@article@Maven Complete Tutorial for Beginners on DEV Community](https://dev.to/saiupadhyayula/maven-complete-tutorial-for-beginners-1jek)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/method-calls@w_GDO8UjtaM-XTbyQOBsQ.md b/src/data/roadmaps/scala/content/method-calls@w_GDO8UjtaM-XTbyQOBsQ.md
new file mode 100644
index 000000000..a378dd3c2
--- /dev/null
+++ b/src/data/roadmaps/scala/content/method-calls@w_GDO8UjtaM-XTbyQOBsQ.md
@@ -0,0 +1,9 @@
+# Method calls
+
+Method calls can be made using different syntaxes and conventions. Methods can be called using the standard dot notation (e.g., obj.method(params)) or using the infix notation (e.g., obj method params). Scala also allows the omission of parentheses on methods of arity-0 (no arguments), but this syntax should only be used when the method in question has no side effects. Additionally, Scala supports named parameters, which can be used to make method calls more readable.
+
+Visit the following resources to learn more:
+
+- [@official@Method Invocation | Style Guide | Scala Documentation](https://docs.scala-lang.org/style/method-invocation.html)
+- [@article@Functions and Methods in Scala | Baeldung on Scala](https://www.baeldung.com/scala/functions-methods)
+- [@article@Scala - method call syntax - Stack Overflow](https://stackoverflow.com/questions/11899177/scala-method-call-syntax)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/mill@SY6uRGxuo_sXA_R0t8uLJ.md b/src/data/roadmaps/scala/content/mill@SY6uRGxuo_sXA_R0t8uLJ.md
new file mode 100644
index 000000000..5bcdfaead
--- /dev/null
+++ b/src/data/roadmaps/scala/content/mill@SY6uRGxuo_sXA_R0t8uLJ.md
@@ -0,0 +1,7 @@
+# Mill
+
+Mill is a build tool designed for Java, Scala, and Kotlin projects. It focuses on speed and efficiency by automatically caching and parallelizing build tasks and tests. Mill uses a long-lived daemon to keep the JVM warm, which helps in maintaining fast build times. It also supports selective test execution to shorten CI times. Mill is designed to be simple and intuitive, making it a good choice for both small and medium-sized projects.
+
+Visit the following resources to learn more:
+
+- [@article@Mill Official Documentation](https://mill-build.org/mill/index.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/monads@PEQNPOy-j2BdL_NQYoq7g.md b/src/data/roadmaps/scala/content/monads@PEQNPOy-j2BdL_NQYoq7g.md
new file mode 100644
index 000000000..c509ff756
--- /dev/null
+++ b/src/data/roadmaps/scala/content/monads@PEQNPOy-j2BdL_NQYoq7g.md
@@ -0,0 +1,9 @@
+# Monads
+
+Monads in Scala are constructs that augment a value with additional features, known as effects. These effects can include managing the nullability of a variable or handling the asynchronicity of its computation. In Scala, common monads include Option[T], Future[T], Either, List, and more. A monad adds an effect to a value by wrapping it around a context. The key functions a monad must implement are unit (which lifts a value into the monadic context) and flatMap (which allows for chaining operations within the monadic context).
+
+Visit the following resources to learn more:
+
+- [@article@Monads in Scala | Baeldung on Scala](https://www.baeldung.com/scala/monads)
+- [@article@An Introduction to Monads in Scala | Rock the JVM](https://rockthejvm.com/articles/an-introduction-to-monads-in-scala)
+- [@article@Demystifying the Monad in Scala](https://medium.com/free-code-camp/demystifying-the-monad-in-scala-cc716bb6f534)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/mutable-collections@Dfrh1gTS7CiCSqXGW-APm.md b/src/data/roadmaps/scala/content/mutable-collections@Dfrh1gTS7CiCSqXGW-APm.md
new file mode 100644
index 000000000..53e7db39e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/mutable-collections@Dfrh1gTS7CiCSqXGW-APm.md
@@ -0,0 +1,10 @@
+# Mutable collections
+
+Mutable collections are used when you need collections that can be updated or extended in place, usually for better performance. After the computations are done, you can transform it to its immutable counterpart. Scala provides several mutable collection classes, including ArrayBuffer, ListBuffer, HashSet, and HashMap.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Concrete Mutable Collection Classes | Collections (Scala 2.8 - 2.12) | Scala Documentation](https://docs.scala-lang.org/overviews/collections/concrete-mutable-collection-classes.html)
+- [@official@Concrete Mutable Collection Classes | Collections | Scala Documentation](https://docs.scala-lang.org/overviews/collections-2.13/concrete-mutable-collection-classes.html)
+- [@article@Scala mutable collections on waitingforcode.com - articles about Scala collections](https://www.waitingforcode.com/scala-collections/scala-mutable-collections/read)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/no-ecosystem@1pq3RFK0DokxqYAuwfdF8.md b/src/data/roadmaps/scala/content/no-ecosystem@1pq3RFK0DokxqYAuwfdF8.md
new file mode 100644
index 000000000..e07ee5d43
--- /dev/null
+++ b/src/data/roadmaps/scala/content/no-ecosystem@1pq3RFK0DokxqYAuwfdF8.md
@@ -0,0 +1,3 @@
+# No ecosystem
+
+The Scala open-source landscape outside of the major ecosystems often focuses on niche use cases or innovative ideas that may not be covered by the larger frameworks. Projects in this space can range from specialized tools for data science, machine learning, and web development to unique solutions for testing, build management, and database connectivity. These projects are frequently driven by individual developers or small communities.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/nothing@MVNwvGwzYyse8YUc9fwnL.md b/src/data/roadmaps/scala/content/nothing@MVNwvGwzYyse8YUc9fwnL.md
new file mode 100644
index 000000000..22426f5fe
--- /dev/null
+++ b/src/data/roadmaps/scala/content/nothing@MVNwvGwzYyse8YUc9fwnL.md
@@ -0,0 +1,3 @@
+# Nothing
+
+`Nothing` is a special type in Scala that sits at the bottom of the type hierarchy. It's a subtype of every other type, meaning it can be used anywhere any other type is expected. However, `Nothing` has no instances (no actual values), which essentially means that a function returning `Nothing` will never return normally; it either throws an exception, enters an infinite loop, or the program exits. You can think of it as a "dead end" type that signals a point of no return in your code.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/object@_Ggnf67Ye0kFvroqqSg_D.md b/src/data/roadmaps/scala/content/object@_Ggnf67Ye0kFvroqqSg_D.md
new file mode 100644
index 000000000..2f2e983ef
--- /dev/null
+++ b/src/data/roadmaps/scala/content/object@_Ggnf67Ye0kFvroqqSg_D.md
@@ -0,0 +1,9 @@
+# Object
+
+The object keyword is used to create a singleton object. A singleton object is a class that has only one instance. Singleton objects are often used to define methods and values that are not specific to instances of a class, similar to static methods in Java.
+
+Visit the following resources to learn more:
+
+- [@official@Singleton Objects | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/singleton-objects.html)
+- [@article@Scala - Classes & Objects | Tutorials Point](https://www.tutorialspoint.com/scala/scala_classes_objects.htm)
+- [@article@Classes and Objects in Scala | Baeldung on Scala](https://www.baeldung.com/scala/classes-objects)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/operators@9sYmBVtJhOegHWE8mgs5c.md b/src/data/roadmaps/scala/content/operators@9sYmBVtJhOegHWE8mgs5c.md
new file mode 100644
index 000000000..2d4309093
--- /dev/null
+++ b/src/data/roadmaps/scala/content/operators@9sYmBVtJhOegHWE8mgs5c.md
@@ -0,0 +1,10 @@
+# Standard operators
+
+Operators are methods that can be used in a more readable and intuitive way. Scala supports standard arithmetic operators (+, -, *, /), relational operators (==, !=, >, <, >=, <=), and logical operators (&&, ||, !). Additionally, Scala has specific operators like the arrow (->) and fat arrow (=>). The arrow operator (->) is used to create tuples, which are pairs of values. For example, 1 -> 2 creates a tuple (1, 2). The fat arrow (=>) is used in function definitions and pattern matching.
+Resources
+
+Visit the following resources to learn more:
+
+- [@article@Introduction to Scala Operators | Baeldung on Scala](https://www.baeldung.com/scala/operators-intro)
+- [@article@What do all of Scala's symbolic operators mean? - Stack Overflow](https://stackoverflow.com/questions/7888944/what-do-all-of-scalas-symbolic-operators-mean)
+- [@article@Working with Arrows in Scala](https://blog.ssanj.net/posts/2017-07-02-working-with-arrows-in-scala.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/option@PPrcoA800FmTFT48H789J.md b/src/data/roadmaps/scala/content/option@PPrcoA800FmTFT48H789J.md
new file mode 100644
index 000000000..1ea336de4
--- /dev/null
+++ b/src/data/roadmaps/scala/content/option@PPrcoA800FmTFT48H789J.md
@@ -0,0 +1,8 @@
+# Option
+
+The Option class in Scala is used to represent optional values. It is a carrier of single or no element for a stated type, and is particularly useful for handling cases where a value might be null.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Standard Library 2.13.3 - scala.Option](https://www.scala-lang.org/api/2.13.3/scala/Option.html)
+- [@article@The Option Type in Scala | Baeldung on Scala](https://www.baeldung.com/scala/option-type)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/package@RVwd5ZY4e_RUhsIi1NZFu.md b/src/data/roadmaps/scala/content/package@RVwd5ZY4e_RUhsIi1NZFu.md
new file mode 100644
index 000000000..b840c12bb
--- /dev/null
+++ b/src/data/roadmaps/scala/content/package@RVwd5ZY4e_RUhsIi1NZFu.md
@@ -0,0 +1,9 @@
+# package
+
+The package keyword is used to create namespaces that can contain entities such as classes, objects, and other packages. In Scala 2, package objects allow defining functions, variables, and types that are accessible to all members of a package. In Scala 3, it's possible to define all those elements at the top-level, so there is no longer any need to declare package objects.
+
+Visit the following resources to learn more:
+
+- [@official@Top Level Definitions in Packages | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/package-objects.html)
+- [@article@Packaging, Importing and Package Objects in Scala | Baeldung on Scala](https://www.baeldung.com/scala/package-import)
+- [@article@Scala Package Objects](https://www.tutorialspoint.com/scala/scala_package_objects.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/pattern-matching@5BGQb1CZQwDwYxDA9bvn4.md b/src/data/roadmaps/scala/content/pattern-matching@5BGQb1CZQwDwYxDA9bvn4.md
new file mode 100644
index 000000000..92ea2194b
--- /dev/null
+++ b/src/data/roadmaps/scala/content/pattern-matching@5BGQb1CZQwDwYxDA9bvn4.md
@@ -0,0 +1,8 @@
+# Pattern Matching
+
+Pattern matching is a way to check a value against a set of patterns. Think of it like a more powerful `switch` statement. You provide a value and then define different "cases" or patterns that the value might match.  When a match is found, the code associated with that pattern is executed.  It's often used to deconstruct data structures or identify specific conditions within your code.
+
+Visit the following resources to learn more:
+
+- [@official@Pattern Matching | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/pattern-matching.html)
+- [@article@Pattern Matching in Scala | Baeldung on Scala](https://www.baeldung.com/scala/pattern-matching)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/platforms@pYZHgxBvh3Au3bCFuLWn2.md b/src/data/roadmaps/scala/content/platforms@pYZHgxBvh3Au3bCFuLWn2.md
new file mode 100644
index 000000000..176b95c42
--- /dev/null
+++ b/src/data/roadmaps/scala/content/platforms@pYZHgxBvh3Au3bCFuLWn2.md
@@ -0,0 +1,3 @@
+# Know your platform
+
+A platform is a runtime environment in which code is compiled and executed. Scala is primarily known as a JVM language, alongside Java and Kotlin. Scala code is compiled into the same bytecode as these languages and runs in the Java Runtime Environment (JRE), which provides independence from specific machine configurations and features such as garbage collection. However, there are at least two other platforms where Scala code can be run: Scala Native, which aims to compile Scala directly to machine code, bypassing the JRE, and Scala.js, which transpiles Scala code to JavaScript, allowing it to run in web browsers.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/private--protected@mHdNAYbL4yCZZYv0Z_s1w.md b/src/data/roadmaps/scala/content/private--protected@mHdNAYbL4yCZZYv0Z_s1w.md
new file mode 100644
index 000000000..cd83ac7ae
--- /dev/null
+++ b/src/data/roadmaps/scala/content/private--protected@mHdNAYbL4yCZZYv0Z_s1w.md
@@ -0,0 +1,9 @@
+# private / protected
+
+The private and protected keywords are used to control the visibility of members (variables and methods) in classes, objects, or packages. If no access modifier is specified, the default access level is public.
+
+Visit the following resources to learn more:
+
+- [@article@Understanding Scala Access Modifiers](https://www.tutorialspoint.com/scala/scala_access_modifiers.htm)
+- [@article@How to control Scala method scope with private, package, and more](https://alvinalexander.com/scala/how-to-control-scala-method-scope-object-private-package/)
+- [@article@Scala access modifiers and qualifiers in detail](https://www.jesperdj.com/2016/01/08/scala-access-modifiers-and-qualifiers-in-detail/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/pure-functions@glMo7kvwKxS3M6pBrGhNn.md b/src/data/roadmaps/scala/content/pure-functions@glMo7kvwKxS3M6pBrGhNn.md
new file mode 100644
index 000000000..1bea4ea16
--- /dev/null
+++ b/src/data/roadmaps/scala/content/pure-functions@glMo7kvwKxS3M6pBrGhNn.md
@@ -0,0 +1,10 @@
+# Pure functions
+
+Pure functions in Scala are functions that always return the same output for the same input and do not have any side effects. They are fundamental to functional programming and provide predictability and reliability.
+
+Visit the following resources to learn more:
+
+- [@official@Pure Functions - Scala 3 Documentation](https://docs.scala-lang.org/scala3/book/fp-pure-functions.html)
+- [@article@Pure Function vs Referential Transparency](https://edward-huang.com/functional-programming/tech/programming/scala/2020/01/30/pure-function-vs-referential-transparency/)
+- [@article@Referential Transparency in Scala Pt. I - Pure functions](https://rafaelvindelamor.dev/posts/referential-transparency-in-scala-pt-i-pure-functions/)
+- [@article@Scala best practice: Create methods that have no side effects (pure functions)](https://alvinalexander.com/scala/how-to-create-scala-methods-no-side-effects-pure-functions/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/range@IN_mRFxfaDiW2_iNDdrHk.md b/src/data/roadmaps/scala/content/range@IN_mRFxfaDiW2_iNDdrHk.md
new file mode 100644
index 000000000..af14c5231
--- /dev/null
+++ b/src/data/roadmaps/scala/content/range@IN_mRFxfaDiW2_iNDdrHk.md
@@ -0,0 +1,8 @@
+# Range
+
+A `Range` in Scala represents an ordered sequence of integers (or other numeric types) with a consistent step size. You define a range by specifying its start, end (inclusive or exclusive), and the increment between elements. Ranges are memory-efficient because they don't store all the numbers; instead, they calculate each element on demand, making them ideal for iterating over large sequences or generating arithmetic progressions without the overhead of storing every single value.
+
+Visit the following resources to learn more:
+
+- [@official@Range](https://www.scala-lang.org/api/3.x/scala/collection/immutable/Range.html)
+- [@article@Range in Scala](https://www.baeldung.com/scala/range)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/recursion@Hrl2L3vdhAub1jnQVuTRF.md b/src/data/roadmaps/scala/content/recursion@Hrl2L3vdhAub1jnQVuTRF.md
new file mode 100644
index 000000000..411d7b444
--- /dev/null
+++ b/src/data/roadmaps/scala/content/recursion@Hrl2L3vdhAub1jnQVuTRF.md
@@ -0,0 +1,9 @@
+# Recursion basics
+
+Recursion is a fundamental concept in computer science and mathematics where a function or process calls itself as part of its execution. This approach is particularly useful for tasks that can be defined in terms of similar subtasks, such as traversing tree structures, calculating factorials, or solving problems that exhibit self-similarity. In Scala, recursion is supported on many levels. It is possible for a function to recursively call itself. Additionally, the Scala compiler uses tail recursion to rewrite a subset of recursive functions into flat loops, and the Scala standard library contains "trampolines" - a mechanism to simulate recursion without the risk of stack overflow. On top of that, Scala pattern matching helps to write recursive functions in a readable way, and implicit parameters help to keep the code concise.
+
+Visit the following resources to learn more:
+
+- [@article@Scala Recursion Functions](https://www.tutorialspoint.com/scala/recursion_functions.htm)
+- [@article@Simple Scala recursion examples (recursive programming) | alvinalexander.com](https://alvinalexander.com/scala/scala-recursion-examples-recursive-programming/)
+- [@article@Scala Tutorial | Tail Recursion](https://www.scala-exercises.org/scala_tutorial/tail_recursion)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/referencial-transparency@Qm2AQa8AJtmMo_eidqCrz.md b/src/data/roadmaps/scala/content/referencial-transparency@Qm2AQa8AJtmMo_eidqCrz.md
new file mode 100644
index 000000000..3a545d13e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/referencial-transparency@Qm2AQa8AJtmMo_eidqCrz.md
@@ -0,0 +1,11 @@
+# Referential Transparency
+
+Referential transparency is a fundamental concept in functional programming where an expression can be replaced by its value without changing the behavior of the program. In Scala, this concept is closely tied to pure functions, which always return the same output for the same input and do not have any side effects.
+
+Visit the following resources to learn more:
+
+- [@book@Scala Functional Programming Patterns book](https://www.oreilly.com/library/view/scala-functional-programming/9781783985845/ch01s05.html)
+- [@article@Scala Best Practices - Referential transparency](https://nrinaudo.github.io/scala-best-practices/definitions/referential_transparency.html)
+- [@article@Referential Transparency in Scala - liveBook by Manning](https://livebook.manning.com/concept/scala/referential-transparency)
+- [@article@Referential Transparency - Learning Journal](https://www.learningjournal.guru/article/scala/functional-programming/referential-transparency/)
+- [@article@Scala Tutorials Part #21 - Referential transparency](https://madusudanan.com/blog/scala-tutorials-part-21-referential-transparency/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/regex@P607jVa4002JaBDku4V4O.md b/src/data/roadmaps/scala/content/regex@P607jVa4002JaBDku4V4O.md
new file mode 100644
index 000000000..3b14d0a01
--- /dev/null
+++ b/src/data/roadmaps/scala/content/regex@P607jVa4002JaBDku4V4O.md
@@ -0,0 +1,9 @@
+# Regex
+Regular expressions are supported through the Regex class in the scala.util.matching package. Regular expressions (regex) are patterns used to match character combinations in strings. They are useful for text processing, pattern matching, and data validation.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Regular Expression Patterns | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/regular-expression-patterns.html)
+- [@official@Regular Expressions in Scala | Baeldung on Scala](https://docs.scala-lang.org/tour/regular-expression-patterns.html)
+- [@article@Scala Regular Expressions | Tutorials Point](https://www.tutorialspoint.com/scala/scala_regular_expressions.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/sbt@V0zIDfz8b2LBrNwz81xlR.md b/src/data/roadmaps/scala/content/sbt@V0zIDfz8b2LBrNwz81xlR.md
new file mode 100644
index 000000000..210a8a4e6
--- /dev/null
+++ b/src/data/roadmaps/scala/content/sbt@V0zIDfz8b2LBrNwz81xlR.md
@@ -0,0 +1,10 @@
+# sbt
+
+sbt (Scala Build Tool) is a build tool designed for Scala and Java projects. It allows developers to define tasks in Scala and run them in parallel from an interactive shell. sbt is known for its incremental compilation feature, which updates only the parts of the project that have changed, saving time and improving efficiency. It supports a wide range of plugins for tasks like packaging, releasing, and deploying software. sbt is highly configurable and extensible, making it suitable for projects of all sizes, from small applications to large, complex systems.
+
+Visit the following resources to learn more:
+
+- [@official@sbt Official Documentation](https://www.scala-sbt.org/learn.html)
+- [@official@Scala Book: sbt Overview](https://docs.scala-lang.org/overviews/scala-book/scala-build-tool-sbt.html)
+- [@book@sbt in Action Book](https://www.manning.com/books/sbt-in-action)
+- [@article@Introduction to SBT on Baeldung](https://www.baeldung.com/scala/sbt-intro)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/scala-native@4_gOylCtzBT6n1_GBzZdD.md b/src/data/roadmaps/scala/content/scala-native@4_gOylCtzBT6n1_GBzZdD.md
new file mode 100644
index 000000000..0473c3b7e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/scala-native@4_gOylCtzBT6n1_GBzZdD.md
@@ -0,0 +1,10 @@
+# Scala Native
+
+Scala Native is an optimizing ahead-of-time compiler and lightweight managed runtime designed specifically for Scala. By leveraging LLVM, Scala Native compiles Scala code directly to native executables, eliminating the need for a Java Virtual Machine (JVM). This results in faster startup times and smaller memory footprints, making it suitable for environments where performance and resource efficiency are critical. Scala Native also offers interoperability with C libraries, allowing developers to integrate with existing native libraries seamlessly. The compilation process involves converting Scala code to an intermediate format called Native Intermediate Representation (NIR), which is then transformed into an LLVM IR file for execution. The project is supported by the École polytechnique fédérale de Lausanne (EPFL) and has a growing community of contributors.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Native Documentation](https://scala-native.org/)
+- [@opensource@Scala Native GitHub Repository](https://github.com/scala-native/scala-native)
+- [@article@Getting Started with Scala Native: A Comprehensive Guide for Beginners](https://medium.com/@diehardankush/getting-started-with-scala-native-a-comprehensive-guide-for-beginners-dedafeed7f25)
+- [@article@Building Native Applications in Scala Using Scala Native | Baeldung on Scala](https://www.baeldung.com/scala/native-apps-scala-native)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/scalacli@AleJKnVNfSoksZxhR-oXc.md b/src/data/roadmaps/scala/content/scalacli@AleJKnVNfSoksZxhR-oXc.md
new file mode 100644
index 000000000..c1daa0dc7
--- /dev/null
+++ b/src/data/roadmaps/scala/content/scalacli@AleJKnVNfSoksZxhR-oXc.md
@@ -0,0 +1,11 @@
+# ScalaCLI 
+
+ScalaCLI is a command-line tool designed to simplify the process of learning and using Scala. It is optimized for speed and ease of use, making it ideal for scripts, playgrounds, and single-module projects. ScalaCLI manages its own dependencies and supports features like incremental compilation and dependency resolution. It does not require a configuration file, and all configurations can be provided through directives embedded in Scala files or via command-line arguments.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Scala CLI Official Documentation](https://scala-cli.virtuslab.org/)
+- [@official@Getting Started with Scala CLI](https://scala-cli.virtuslab.org/docs/getting_started/)
+- [@opensource@Scala CLI GitHub Repository](https://github.com/VirtusLab/scala-cli)
+- [@article@Introduction to Scala-CLI on Baeldung](https://www.baeldung.com/scala/scala-cli-intro)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/scalajs@phv4IeRtLcWcLJuiradiv.md b/src/data/roadmaps/scala/content/scalajs@phv4IeRtLcWcLJuiradiv.md
new file mode 100644
index 000000000..9136b5686
--- /dev/null
+++ b/src/data/roadmaps/scala/content/scalajs@phv4IeRtLcWcLJuiradiv.md
@@ -0,0 +1,10 @@
+# Scala.js
+
+Scala.js is a Scala compiler that compiles Scala code to JavaScript, enabling Scala programs to run in web browsers or Node.js. It optimizes Scala code into highly efficient JavaScript, ensuring fast turnaround times with incremental compilation. Scala.js provides strong typing, which catches typos and type errors immediately, making the development process more reliable and efficient. It also offers seamless interoperability with JavaScript libraries, allowing developers to use popular libraries like React and AngularJS directly from their Scala.js code. This makes it easier to leverage existing JavaScript ecosystems while benefiting from Scala's type system and tooling. Additionally, Scala.js supports full-stack development by allowing code to be shared between the frontend and backend, ensuring consistency and reducing the risk of mismatches.
+
+Visit the following resources to learn more:
+
+- [@official@Scala.js Official Website](https://www.scala-js.org/)
+- [@article@Hands-on Scala.js](https://www.lihaoyi.com/hands-on-scala-js/)
+- [@article@Introduction to Scala.js | Baeldung on Scala](https://www.baeldung.com/scala/scala-js)
+- [@article@The importance of Scala.js](https://www.scalawilliam.com/importance-scalajs/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/scope--visibility@w59GmNK0wHo6tADDTaaQS.md b/src/data/roadmaps/scala/content/scope--visibility@w59GmNK0wHo6tADDTaaQS.md
new file mode 100644
index 000000000..961504283
--- /dev/null
+++ b/src/data/roadmaps/scala/content/scope--visibility@w59GmNK0wHo6tADDTaaQS.md
@@ -0,0 +1,3 @@
+# Scope & Visibility
+
+Scope and visibility in Scala determine where variables, methods, and classes can be accessed within your code. Scope defines the region of code where a variable is valid and accessible, while visibility controls whether a member (variable or method) of a class or object can be accessed from outside that class or object. Understanding these concepts is crucial for writing well-structured, maintainable, and secure Scala programs.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/sealed-traits@-5hM5DFinTWjkzlubUclR.md b/src/data/roadmaps/scala/content/sealed-traits@-5hM5DFinTWjkzlubUclR.md
new file mode 100644
index 000000000..18b0b578c
--- /dev/null
+++ b/src/data/roadmaps/scala/content/sealed-traits@-5hM5DFinTWjkzlubUclR.md
@@ -0,0 +1,8 @@
+# Sealed traits
+
+Sealed traits are used to define closed hierarchies where all possible subclasses are known. They can be extended only in the same file as their declaration, allowing the compiler to perform exhaustiveness checking. This feature is particularly useful for pattern matching.
+
+Visit the following resources to learn more:
+
+- [@article@What is a sealed trait? - Stack Overflow](https://stackoverflow.com/questions/11203268/what-is-a-sealed-trait)
+- [@article@Sealed Keyword in Scala | Baeldung on Scala](https://www.baeldung.com/scala/sealed-keyword)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/seq@IBkdiusI08JFfHDS6VKsO.md b/src/data/roadmaps/scala/content/seq@IBkdiusI08JFfHDS6VKsO.md
new file mode 100644
index 000000000..c13f0f9af
--- /dev/null
+++ b/src/data/roadmaps/scala/content/seq@IBkdiusI08JFfHDS6VKsO.md
@@ -0,0 +1,8 @@
+# Seq
+
+A `Seq` in Scala represents an ordered collection of elements. Think of it like a list where the order in which you add items matters. You can access elements by their position (index), and `Seq` offers a variety of methods for manipulating the sequence, such as adding, removing, and searching for items. It's a fundamental data structure in Scala for working with ordered data.
+
+Visit the following resources to learn more:
+
+- [@official@Seq](https://www.scala-lang.org/api/current/scala/collection/Seq.html)
+- [@video@Linear Collections in Scala: Seq, List, Array, Vector, Set, Range](https://www.youtube.com/watch?v=UvUkpduo6uE)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/set@4yYOxlOkQgkxZS6_94CT-.md b/src/data/roadmaps/scala/content/set@4yYOxlOkQgkxZS6_94CT-.md
new file mode 100644
index 000000000..d80a9bb07
--- /dev/null
+++ b/src/data/roadmaps/scala/content/set@4yYOxlOkQgkxZS6_94CT-.md
@@ -0,0 +1,9 @@
+# Set
+
+A Set in Scala is a collection that holds unique elements. This means no duplicates are allowed. Sets are useful when you need to ensure that each item is only present once, like a group of unique user IDs or distinct product names. Scala provides both mutable and immutable Set implementations, allowing you to choose the behavior that best fits your needs.
+
+Visit the following resources to learn more:
+
+- [@official@Sets](https://docs.scala-lang.org/overviews/collections-2.13/sets.html)
+- [@article@Scala - Sets](https://www.tutorialspoint.com/scala/scala_sets.htm)
+- [@article@Scala: Whats the difference between "Map" vs "Set"? - Stack Overflow](https://stackoverflow.com/questions/45133364/scala-whats-the-difference-between-map-vs-set)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/setting-up-scala@D5djqvuGs8v__c9DrfOIT.md b/src/data/roadmaps/scala/content/setting-up-scala@D5djqvuGs8v__c9DrfOIT.md
new file mode 100644
index 000000000..3c5c24b5e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/setting-up-scala@D5djqvuGs8v__c9DrfOIT.md
@@ -0,0 +1,3 @@
+# Setting Up Scala
+
+Setting up Scala involves installing the Scala compiler and build tools on your system. This allows you to write, compile, and run Scala programs. Typically, this includes downloading the Scala SDK, which contains the compiler and essential libraries, and often using a build tool like sbt (Simple Build Tool) to manage dependencies and build projects. The setup also frequently involves configuring your Integrated Development Environment (IDE) for Scala development, providing features like code completion and debugging.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/strings@cwhAAcKtzUKcXBSEUdIAQ.md b/src/data/roadmaps/scala/content/strings@cwhAAcKtzUKcXBSEUdIAQ.md
new file mode 100644
index 000000000..4142aa363
--- /dev/null
+++ b/src/data/roadmaps/scala/content/strings@cwhAAcKtzUKcXBSEUdIAQ.md
@@ -0,0 +1,3 @@
+# Strings
+
+Strings represent sequences of characters. They're used to store and manipulate text. You create them by enclosing characters within double quotes, like `"Hello, world!"`. Strings are immutable, meaning you can't change them directly; operations on strings produce new strings. Scala provides a rich set of methods for string manipulation, including concatenation, substring extraction, searching, and replacement.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/sublime@RXBh4SW__eVXjiTP8v07G.md b/src/data/roadmaps/scala/content/sublime@RXBh4SW__eVXjiTP8v07G.md
new file mode 100644
index 000000000..6823e1e72
--- /dev/null
+++ b/src/data/roadmaps/scala/content/sublime@RXBh4SW__eVXjiTP8v07G.md
@@ -0,0 +1,9 @@
+# Sublime Text
+
+Sublime Text is a sophisticated text editor known for its speed, ease of use, and features. It supports a wide range of programming languages, including Scala, through plugins and packages. Sublime Text offers features like multiple selections, a command palette, and extensive customization options, making it a popular choice for developers. With the Metals plugin, Sublime Text provides intelligent code completion, diagnostics, and refactoring capabilities for Scala.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Sublime Text](https://www.sublimetext.com/)
+- [@official@Sublime Text | Scalameta](https://scalameta.org/metals/docs/editors/sublime/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/tail-recursion@qEdusMVJk68GRdH-vP6ts.md b/src/data/roadmaps/scala/content/tail-recursion@qEdusMVJk68GRdH-vP6ts.md
new file mode 100644
index 000000000..78dd18464
--- /dev/null
+++ b/src/data/roadmaps/scala/content/tail-recursion@qEdusMVJk68GRdH-vP6ts.md
@@ -0,0 +1,9 @@
+# Tail recursion
+
+Tail recursion is a special form of recursion where the recursive call is the last operation in the function. This allows the Scala compiler to optimize the recursion to prevent stack overflow and improve performance.
+
+Visit the following resources to learn more:
+
+- [@article@Tail Recursion in Scala | Baeldung on Scala](https://www.baeldung.com/scala/tail-recursion)
+- [@article@Scala Tutorial | Tail Recursion](https://www.scala-exercises.org/scala_tutorial/tail_recursion)
+- [@article@Writing Tail-Recursive Algorithms in Scala (and the tailrec annotation) | alvinalexander.com](https://alvinalexander.com/scala/fp-book/tail-recursive-algorithms/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/testing@B-akazRqoFzc1EOuF7qQx.md b/src/data/roadmaps/scala/content/testing@B-akazRqoFzc1EOuF7qQx.md
new file mode 100644
index 000000000..05e496dfa
--- /dev/null
+++ b/src/data/roadmaps/scala/content/testing@B-akazRqoFzc1EOuF7qQx.md
@@ -0,0 +1,3 @@
+# Testing
+
+Testing is the process of checking if a piece of software works as expected. It involves running the software with different inputs and conditions to find any errors, bugs, or unexpected behavior. The goal is to make sure the software is reliable, stable, and meets the requirements it was designed for.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/totalpartial-funcs@eje4CLMuZobVwd0EBwwim.md b/src/data/roadmaps/scala/content/totalpartial-funcs@eje4CLMuZobVwd0EBwwim.md
new file mode 100644
index 000000000..35a21e716
--- /dev/null
+++ b/src/data/roadmaps/scala/content/totalpartial-funcs@eje4CLMuZobVwd0EBwwim.md
@@ -0,0 +1,10 @@
+# Total / partial functions
+
+A total function is a function that is defined for every possible input value it can be given. In contrast, a partial function is a function that is only defined for a subset of possible input values. Partial functions can be used with collection methods like collect and collectFirst to manipulate and transform data.
+Resources
+
+Visit the following resources to learn more:
+
+- [@article@Partial Functions in Scala | Baeldung on Scala](https://www.baeldung.com/scala/partial-functions)
+- [@article@How to create and use partial functions in Scala | alvinalexander.com](https://alvinalexander.com/scala/how-to-define-use-partial-functions-in-scala-syntax-examples/)
+- [@article@Scala Partial Function - Ways to Define Partial Functions in Scala - DataFlair](https://data-flair.training/blogs/scala-partial-function/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/trait@vKPb5IZgfciKwUZismkHJ.md b/src/data/roadmaps/scala/content/trait@vKPb5IZgfciKwUZismkHJ.md
new file mode 100644
index 000000000..addebabcf
--- /dev/null
+++ b/src/data/roadmaps/scala/content/trait@vKPb5IZgfciKwUZismkHJ.md
@@ -0,0 +1,9 @@
+# trait
+
+A trait is a type that defines a contract of fields and methods, which can be either abstract (unimplemented) or concrete (implemented). Traits are used to share behavior across classes, enabling code reuse without relying on single inheritance. Traits are similar to Java 8’s interfaces. Classes and objects can extend traits using the extends keyword, but traits cannot be instantiated and therefore have no parameters.
+
+Visit the following resources to learn more:
+
+- [@official@Traits | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/traits.html)
+- [@article@Scala - Traits](https://www.tutorialspoint.com/scala/scala_traits.htm)
+- [@article@Introduction to Traits in Scala | Baeldung on Scala](https://www.baeldung.com/scala/traits)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/trampolines@VV-Drj_JlIppItHq4PRFc.md b/src/data/roadmaps/scala/content/trampolines@VV-Drj_JlIppItHq4PRFc.md
new file mode 100644
index 000000000..7623feda7
--- /dev/null
+++ b/src/data/roadmaps/scala/content/trampolines@VV-Drj_JlIppItHq4PRFc.md
@@ -0,0 +1,9 @@
+# Trampolines
+
+Trampolines in Scala are used to avoid stack overflow errors in deep recursion by moving the computation from the stack to the heap. The TailRec class is part of the scala.util.control.TailCalls are used to implement trampolining.
+
+Visit the following resources to learn more:
+
+- [@article@Recursion and Trampolines in Scala · GitHub](https://gist.github.com/eamelink/4466932a11d8d92a6b76e80364062250)
+- [@article@Tail calls, @tailrec and trampolines](https://rd.nz/2009/04/tail-calls-tailrec-and-trampolines.html)
+- [@article@How Trampoline Works in Scala](https://free.cofree.io/2017/08/24/trampoline/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/try@y4sElb6dWw0vpGNPgRrvC.md b/src/data/roadmaps/scala/content/try@y4sElb6dWw0vpGNPgRrvC.md
new file mode 100644
index 000000000..8bc5bb318
--- /dev/null
+++ b/src/data/roadmaps/scala/content/try@y4sElb6dWw0vpGNPgRrvC.md
@@ -0,0 +1,9 @@
+# Try
+
+The Try class in Scala represents a computation that may fail during evaluation by raising an exception. It holds either a successfully computed value or the exception that was thrown.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Standard Library 2.13.6 - scala.util.Try](https://www.scala-lang.org/api/2.13.6/scala/util/Try.html)
+- [@article@A Scala Try, Success, and Failure example | alvinalexander.com](https://alvinalexander.com/source-code/scala/scala-try-success-and-failure-example/)
+- [@article@Handling Exceptions using Try/Catch/Finally in Scala | ScalaJobs.com](https://scalajobs.com/blog/handling-exceptions-using-try-catch-finally-in-scala)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/trycatch@4NPM4TQawMx6-uD0E2blP.md b/src/data/roadmaps/scala/content/trycatch@4NPM4TQawMx6-uD0E2blP.md
new file mode 100644
index 000000000..3a711d3c7
--- /dev/null
+++ b/src/data/roadmaps/scala/content/trycatch@4NPM4TQawMx6-uD0E2blP.md
@@ -0,0 +1,8 @@
+# Try/catch
+
+Exception handling is done using the try/catch/finally construct, similar to Java. The try block contains code that might throw an exception, the catch block handles the exception, and the finally block is used for cleanup or other operations that must be performed regardless of whether an exception was thrown. Scala also encourages the use of functional error handling with monads like Try, Option, and Either, which provide a more composable and functional way to handle errors and exceptional cases.
+
+Visit the following resources to learn more:
+
+- [@official@try/catch/finally Expressions | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/try-catch-finally.html)
+- [@article@Handling Exceptions using Try/Catch/Finally in Scala | ScalaJobs.com](https://scalajobs.com/blog/handling-exceptions-using-try-catch-finally-in-scala)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/type-hierarchy@3zKEn33pENf2eNDGvjEAP.md b/src/data/roadmaps/scala/content/type-hierarchy@3zKEn33pENf2eNDGvjEAP.md
new file mode 100644
index 000000000..7526dcfb3
--- /dev/null
+++ b/src/data/roadmaps/scala/content/type-hierarchy@3zKEn33pENf2eNDGvjEAP.md
@@ -0,0 +1,9 @@
+# Type hierarchy
+
+Generic types allow you to write code that can work with different types while maintaining type safety. Generic classes and traits take a type as a parameter within square brackets. For example, Stack[A] is a generic class that can be used to create stacks of any type A. Scala's type hierarchy is unified, with Any as the top type, which is the supertype of all types, and Nothing as the bottom type, which is the subtype of all types.
+
+Visit the following resources to learn more:
+
+- [@official@Generic Classes | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/generic-classes.html)
+- [@official@Generics | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/types-generics.html)
+- [@article@Basics of Generics in Scala | Baeldung on Scala](https://www.baeldung.com/scala/generics-basics)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/type-parameters@_6s7NV9qbJj_Y4z4_ge4f.md b/src/data/roadmaps/scala/content/type-parameters@_6s7NV9qbJj_Y4z4_ge4f.md
new file mode 100644
index 000000000..c56992942
--- /dev/null
+++ b/src/data/roadmaps/scala/content/type-parameters@_6s7NV9qbJj_Y4z4_ge4f.md
@@ -0,0 +1,9 @@
+# Type parameters
+
+Type parameters are used to create generic classes, traits, and methods. Type parameters are enclosed in square brackets and can be used to define methods and classes that work with different types while maintaining type safety.
+
+Visit the following resources to learn more:
+
+- [@official@Polymorphic Methods | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/polymorphic-methods.html)
+- [@official@Generic Classes | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/generic-classes.html)
+- [@article@Basics of Generics in Scala | Baeldung on Scala](https://www.baeldung.com/scala/generics-basics)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/type-system@pvYS9XusP0WPCMvrOtHgr.md b/src/data/roadmaps/scala/content/type-system@pvYS9XusP0WPCMvrOtHgr.md
new file mode 100644
index 000000000..0d327c686
--- /dev/null
+++ b/src/data/roadmaps/scala/content/type-system@pvYS9XusP0WPCMvrOtHgr.md
@@ -0,0 +1,9 @@
+# Type system
+
+The Scala type system supports both object-oriented and functional programming paradigms. It is designed to be expressive and flexible, allowing developers to write concise and type-safe code. The type system includes features such as type inference, generics, variance annotations, type bounds, abstract types, higher-kinded types, type classes, and implicit resolutions. It is one of the most sophisticated type systems in any programming language, combining comprehensive ideas from both functional programming and object-oriented programming.
+
+Visit the following resources to learn more:
+
+- [@official@Types and the Type System | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/types-introduction.html)
+- [@article@Type Hierarchies in Scala | Baeldung on Scala](https://www.baeldung.com/scala/type-hierarchies)
+- [@article@Chapter 6. The Type System · Scala in Depth](https://livebook.manning.com/book/scala-in-depth/chapter-6)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/typeclasses@RNBawkn6jQsX4fAjMBfo2.md b/src/data/roadmaps/scala/content/typeclasses@RNBawkn6jQsX4fAjMBfo2.md
new file mode 100644
index 000000000..204fb6f44
--- /dev/null
+++ b/src/data/roadmaps/scala/content/typeclasses@RNBawkn6jQsX4fAjMBfo2.md
@@ -0,0 +1,10 @@
+# Typeclasses
+
+Typeclasses are a concept used in functional programming to achieve ad-hoc polymorphism. They define a set of functions that can be implemented for a type fulfilling certain requirements, providing a way to add functionality to existing types without modifying their source code. Typeclasses are not natively supported in Scala but can be implemented using traits and implicit classes.
+
+Visit the following resources to learn more:
+
+- [@official@Type Classes | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/ca-type-classes.html)
+- [@article@Type classes in Scala - Ad-hoc polymorphism - Scalac.io](https://scalac.io/blog/typeclasses-in-scala/)
+- [@article@Demystifying Type Classes in Scala: A Simple Guide | by Remis Haroon | Medium](https://medium.com/@remisharoon/demystifying-type-classes-in-scala-a-simple-guide-3a4766a59818)
+- [@article@Type Classes in Scala | Baeldung on Scala](https://www.baeldung.com/scala/type-classes)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/unapply-method@NcGlkEvp1t46EmX5GQRkD.md b/src/data/roadmaps/scala/content/unapply-method@NcGlkEvp1t46EmX5GQRkD.md
new file mode 100644
index 000000000..4c7b4d69d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/unapply-method@NcGlkEvp1t46EmX5GQRkD.md
@@ -0,0 +1,10 @@
+# The unapply method
+
+The unapply method is used to deconstruct instances through pattern matching. It is often used in extractor objects to extract data values compacted in objects.
+Resources
+
+Visit the following resources to learn more:
+
+- [@official@Extractor Objects | Tour of Scala | Scala Documentation](https://docs.scala-lang.org/tour/extractor-objects.html)
+- [@article@Understand how to use apply and unapply - Stack Overflow](https://stackoverflow.com/questions/18468786/understand-how-to-use-apply-and-unapply)
+- [@article@Scala pattern matching: apply the unapply | by Linas Medžiūnas | Wix Engineering | Medium](https://medium.com/wix-engineering/scala-pattern-matching-apply-the-unapply-7237f8c30b41)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/unit@nvUwMAiZdkKbMsFzc2h3r.md b/src/data/roadmaps/scala/content/unit@nvUwMAiZdkKbMsFzc2h3r.md
new file mode 100644
index 000000000..731a77b58
--- /dev/null
+++ b/src/data/roadmaps/scala/content/unit@nvUwMAiZdkKbMsFzc2h3r.md
@@ -0,0 +1,3 @@
+# Unit
+
+Unit is a data type in Scala that represents a placeholder when no meaningful value needs to be returned. It's similar to `void` in languages like Java or C. The unit type has only one possible value, written as `()`. You'll often see it used as the return type of functions that perform side effects but don't produce a result, or when a function is required to return a value but there's no logical value to return.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/variables--constants@-qLeSRC44_V-c8hoHyMqA.md b/src/data/roadmaps/scala/content/variables--constants@-qLeSRC44_V-c8hoHyMqA.md
new file mode 100644
index 000000000..620eda56d
--- /dev/null
+++ b/src/data/roadmaps/scala/content/variables--constants@-qLeSRC44_V-c8hoHyMqA.md
@@ -0,0 +1,9 @@
+# Variables & Constants
+
+Variables are named storage locations that hold data, and their values can be changed during the program's execution. In Scala, variables are declared using the `var` keyword. On the other hand, constants are also named storage locations, but their values cannot be modified once they are assigned. Constants are declared using the `val` keyword in Scala, making them immutable. Choosing between `var` and `val` depends on whether you need to change the value of a data item during the program's runtime.
+
+Visit the following resources to learn more:
+
+- [@official@Two Types of Variables | Scala Book | Scala Documentation](https://docs.scala-lang.org/overviews/scala-book/two-types-variables.html)
+- [@article@Def, Var & Val in Scala | Baeldung on Scala](https://www.baeldung.com/scala/def-var-val)
+- [@article@Difference between var, val, and def in Scala? Examples | Java67](https://www.java67.com/2017/05/difference-between-var-val-and-def-in-Scala.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/variance@upZK3qxWKokNL3tlFKhK6.md b/src/data/roadmaps/scala/content/variance@upZK3qxWKokNL3tlFKhK6.md
new file mode 100644
index 000000000..f578139f4
--- /dev/null
+++ b/src/data/roadmaps/scala/content/variance@upZK3qxWKokNL3tlFKhK6.md
@@ -0,0 +1,9 @@
+# Context bounds
+
+Context Bounds in Scala is a feature that provides a shorthand syntax for expressing the common pattern of a context parameter that depends on a type parameter. Context bounds are used to simplify the code for generic types and are particularly useful in the context of type classes.
+
+Visit the following resources to learn more:
+
+- [@official@Context Bounds | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/ca-context-bounds.html)
+- [@article@Demystifying View and Context Bounds | Baeldung on Scala](https://www.baeldung.com/scala/view-context-bounds)
+- [@article@Context Bounds - Scala 3 - EPFL](https://dotty.epfl.ch/docs/reference/contextual/context-bounds.html)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/vector@p3FdTk1pqQoBK3_NKmLDb.md b/src/data/roadmaps/scala/content/vector@p3FdTk1pqQoBK3_NKmLDb.md
new file mode 100644
index 000000000..779bb5fb1
--- /dev/null
+++ b/src/data/roadmaps/scala/content/vector@p3FdTk1pqQoBK3_NKmLDb.md
@@ -0,0 +1,8 @@
+# Vector
+
+Vectors in Scala are indexed, immutable sequences. Think of them as similar to arrays, but with the key advantage of being immutable – meaning their contents cannot be changed after creation. This makes them very useful in concurrent programming and for data structures where you want to guarantee that data isn't accidentally modified. Vectors provide fast access to elements by index (like arrays), making them efficient for lookups and various data manipulations.
+
+Visit the following resources to learn more:
+
+- [@article@Collection types - Vector](https://docs.scala-lang.org/scala3/book/collections-classes.html#vector)
+- [@article@Benefits of Using Vector in Scala](https://www.baeldung.com/scala/vector-benefits)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/views@52RX2tDml7raPbQpZCbnx.md b/src/data/roadmaps/scala/content/views@52RX2tDml7raPbQpZCbnx.md
new file mode 100644
index 000000000..3982b3738
--- /dev/null
+++ b/src/data/roadmaps/scala/content/views@52RX2tDml7raPbQpZCbnx.md
@@ -0,0 +1,9 @@
+# Views
+
+Views are used to create lazy versions of collections. They are essentially reusable iterators that implement the same interfaces as regular collections.
+
+Visit the following resources to learn more:
+
+- [@official@Views | Collections | Scala Documentation](https://docs.scala-lang.org/overviews/collections-2.13/views.html)
+- [@official@Views | Collections (Scala 2.8 - 2.12) | Scala Documentation:](https://docs.scala-lang.org/overviews/collections/views.html)
+- [@article@What are views for collections and when would you want to use them? - Stack Overflow](https://stackoverflow.com/questions/3361478/what-are-views-for-collections-and-when-would-you-want-to-use-them)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/vim@ZmrehlOEUkjVJXiejyWt7.md b/src/data/roadmaps/scala/content/vim@ZmrehlOEUkjVJXiejyWt7.md
new file mode 100644
index 000000000..b0608fed8
--- /dev/null
+++ b/src/data/roadmaps/scala/content/vim@ZmrehlOEUkjVJXiejyWt7.md
@@ -0,0 +1,8 @@
+# VIm
+
+Vim is a highly configurable text editor known for its efficiency and features. When equipped with the Metals plugin, Vim becomes a capable environment for Scala development, offering features like code completion, refactoring, and debugging.
+
+Visit the following resources to learn more:
+
+- [@official@Vim Main Page](https://www.vim.org/)
+- [@official@Vim | Scalameta](https://scalameta.org/metals/docs/editors/vim/)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/vs-code@kK2gLsPax0kj_cUlfwaYm.md b/src/data/roadmaps/scala/content/vs-code@kK2gLsPax0kj_cUlfwaYm.md
new file mode 100644
index 000000000..c0105be8c
--- /dev/null
+++ b/src/data/roadmaps/scala/content/vs-code@kK2gLsPax0kj_cUlfwaYm.md
@@ -0,0 +1,8 @@
+# VS Code
+
+Visual Studio Code (VS Code) is a popular IDE known for its lightweight design and extensive customization options. When equipped with the Metals extension, VS Code becomes a powerful tool for Scala development, offering features like code completion, refactoring, debugging, and integration with build tools like sbt and Maven.
+
+Visit the following resources to learn more:
+
+- [@official@Visual Studio Code](https://code.visualstudio.com/)
+- [@official@Install Metals for VS Code](https://marketplace.visualstudio.com/items?itemName=scalameta.metals#overview)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/working-with-strings@Z_cGu1NZ6wh7qkEw2Knyf.md b/src/data/roadmaps/scala/content/working-with-strings@Z_cGu1NZ6wh7qkEw2Knyf.md
new file mode 100644
index 000000000..49b195dab
--- /dev/null
+++ b/src/data/roadmaps/scala/content/working-with-strings@Z_cGu1NZ6wh7qkEw2Knyf.md
@@ -0,0 +1,9 @@
+# Working with Strings
+
+Scala offers various ways to manipulate strings, such as combining them (concatenation), finding their length, or extracting parts of them. String interpolation is a feature that lets you embed variables directly within strings, making it easier to build dynamic text.  For example, you can use `s"My name is $name"` where `name` is a variable, and Scala will replace `$name` with its actual value when the string is created.
+
+Visit the following resources to learn more:
+
+- [@official@String Interpolation | Scala 3 - Book | Scala Documentation](https://docs.scala-lang.org/scala3/book/string-interpolation.html)
+- [@article@String Interpolation in Scala | Baeldung on Scala](https://www.baeldung.com/scala/string-interpolation)
+- [@article@Scala - String Interpolation](https://www.tutorialspoint.com/scala/scala_string_interpolation.htm)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/youtube@ToGJzk3ZpvQsUwOFicxW2.md b/src/data/roadmaps/scala/content/youtube@ToGJzk3ZpvQsUwOFicxW2.md
new file mode 100644
index 000000000..d886eaf9e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/youtube@ToGJzk3ZpvQsUwOFicxW2.md
@@ -0,0 +1,3 @@
+# YouTube
+
+YouTube can be a fantastic resource for learning Scala. On the platform, you can find a wide variety of content, from beginner-friendly tutorials introducing basic concepts to in-depth explanations of advanced topics. Many experienced Scala developers and educators create and share their knowledge on YouTube, often demonstrating practical examples and real-world applications, allowing learners to visually grasp the concepts and follow along with code demonstrations.
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/zed@uvw1H2RybuU979G7yZWy6.md b/src/data/roadmaps/scala/content/zed@uvw1H2RybuU979G7yZWy6.md
new file mode 100644
index 000000000..af790328e
--- /dev/null
+++ b/src/data/roadmaps/scala/content/zed@uvw1H2RybuU979G7yZWy6.md
@@ -0,0 +1,7 @@
+# Zed
+
+Zed is a modern, lightweight, and highly performant code editor designed for efficiency and ease of use. It offers features like real-time collaboration, a minimalistic interface, and editing capabilities. While Zed is not specifically designed for Scala development, its extensibility and support for various programming languages make it a versatile tool for developers. With the Metals plugin, Zed provides intelligent code completion, diagnostics, and refactoring capabilities for Scala.
+
+Visit the following resources to learn more:
+
+- [@official@Scala Editor - Zed](https://zed.dev/languages/scala)
\ No newline at end of file
diff --git a/src/data/roadmaps/scala/content/zio@e7zcJd-SAYV_LGAZPCnSa.md b/src/data/roadmaps/scala/content/zio@e7zcJd-SAYV_LGAZPCnSa.md
new file mode 100644
index 000000000..d264f3dac
--- /dev/null
+++ b/src/data/roadmaps/scala/content/zio@e7zcJd-SAYV_LGAZPCnSa.md
@@ -0,0 +1,10 @@
+# ZIO
+
+ZIO is a Scala framework designed for asynchronous and concurrent programming. It emphasizes type safety, composability, and resource safety, making it suitable for building scalable and resilient applications. The ZIO ecosystem includes libraries for HTTP, logging, configuration, streams, and testing, all built on top of ZIO's effect system. ZIO's fibers are lightweight and non-blocking, providing high performance and scalability.
+
+Visit the following resources to learn more:
+
+- [@official@ZIO Official Website](https://zio.dev/)
+- [@opensource@ZIO GitHub Repository](https://github.com/zio/zio)
+- [@course@ZIO Course on Rock the JVM](https://rockthejvm.com/courses/zio)
+- [@article@Introduction to ZIO on Baeldung](https://www.baeldung.com/scala/zio-intro)
\ No newline at end of file