diff --git a/scripts/roadmap-content.cjs b/scripts/roadmap-content.cjs index 4f741321c..bde5375f9 100644 --- a/scripts/roadmap-content.cjs +++ b/scripts/roadmap-content.cjs @@ -59,9 +59,9 @@ function writeTopicContent(currTopicUrl) { const roadmapTitle = roadmapId.replace(/-/g, ' '); - let prompt = `I am reading a guide about "${roadmapTitle}". I am on the topic "${parentTopic}". I want to know more about "${childTopic}". Write me a brief paragraph for that. Content should be in markdown. I already know the benefits of each so do not add benefits in the output.`; + let prompt = `I am reading a guide about "${roadmapTitle}". I am on the topic "${parentTopic}". I want to know more about "${childTopic}". Write me a brief paragraph for that. Your output should be strictly markdown. Do not include anything other than the description in your output. I already know the benefits of each so do not add benefits in the output.`; if (!childTopic) { - prompt = `I am reading a guide about "${roadmapTitle}". I am on the topic "${parentTopic}". I want to know more about "${parentTopic}". Write me a brief paragraph for that. Content should be in markdown. I already know the benefits of each so do not add benefits in the output.`; + prompt = `I am reading a guide about "${roadmapTitle}". I am on the topic "${parentTopic}". I want to know more about "${parentTopic}". Write me a brief paragraph for that. Your output should be strictly markdown. Do not include anything other than the description in your output. I already know the benefits of each so do not add benefits in the output.`; } console.log(`Generating '${childTopic || parentTopic}'...`); diff --git a/src/data/roadmaps/rust/content/100-introduction/100-what-is-rust.md b/src/data/roadmaps/rust/content/100-introduction/100-what-is-rust.md index 7721b7b1c..9adb08d02 100644 --- a/src/data/roadmaps/rust/content/100-introduction/100-what-is-rust.md +++ b/src/data/roadmaps/rust/content/100-introduction/100-what-is-rust.md @@ -1 +1,3 @@ -# What is rust \ No newline at end of file +# What is Rust? + +Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/101-why-rust.md b/src/data/roadmaps/rust/content/100-introduction/101-why-rust.md index 4159f9f72..29a23fc68 100644 --- a/src/data/roadmaps/rust/content/100-introduction/101-why-rust.md +++ b/src/data/roadmaps/rust/content/100-introduction/101-why-rust.md @@ -1 +1,3 @@ -# Why rust \ No newline at end of file +# Why use Rust? + +Rust is a systems programming language that aims to provide memory safety, concurrency, and performance with a focus on zero cost abstractions. It was originally created by Graydon Hoare at Mozilla Research, with contributions from Brendan Eich, the creator of JavaScript. Rust is appreciated for the solutions it provides to common programming language issues. Its emphasis on safety and speed, the support for concurrent programming, along with a robust type system are just a few reasons why developers choose Rust. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/102-memory-safety.md b/src/data/roadmaps/rust/content/100-introduction/102-memory-safety.md index 479297547..314e3fd30 100644 --- a/src/data/roadmaps/rust/content/100-introduction/102-memory-safety.md +++ b/src/data/roadmaps/rust/content/100-introduction/102-memory-safety.md @@ -1 +1,3 @@ -# Memory safety \ No newline at end of file +# Memory Safety and Zero-Cost Abstractions + +Rust, a systems programming language that runs blazingly fast, prevents segfaults, and guarantees thread safety. It is graced with the feature of "memory safety without garbage collection", an attribute that makes Rust one of its kind. Memory safety is ensuring that software, while accessing the system's memory, is not causing any leaks, or dangling pointers. In Rust, memory safety is accomplished through a system of ownership with a set of rules that the compiler checks at compile time. This system eliminates the need of garbage collection or manual memory management, hence ensuring swift execution of software along with a safer memory environment. This memory management feature in Rust even provides concurrent programming guaranteeing thread safety with options for shared and mutable state access that makes it harder to cause thread unsafety. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/103-installing-rust.md b/src/data/roadmaps/rust/content/100-introduction/103-installing-rust.md index ccf691aba..e62279923 100644 --- a/src/data/roadmaps/rust/content/100-introduction/103-installing-rust.md +++ b/src/data/roadmaps/rust/content/100-introduction/103-installing-rust.md @@ -1 +1,3 @@ -# Installing rust \ No newline at end of file +# Installing Rust and Cargo + +To install Rust, navigate to the official website at [https://www.rust-lang.org](https://www.rust-lang.org) and download the appropriate installation file for your operating system. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with a '.exe' installer which you need to execute. Further instructions can be found on the download page of the website. Keep in mind that you'll also need a linker of your operating system such as 'gcc'. You can update your Rust version at any time by running `rustup update` in the terminal. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/104-ides-and-rust.md b/src/data/roadmaps/rust/content/100-introduction/104-ides-and-rust.md index 59495047a..530394073 100644 --- a/src/data/roadmaps/rust/content/100-introduction/104-ides-and-rust.md +++ b/src/data/roadmaps/rust/content/100-introduction/104-ides-and-rust.md @@ -1 +1,3 @@ -# Ides and rust \ No newline at end of file +# IDEs and Rust Toolchains + +For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. [Visual Studio Code](https://code.visualstudio.com) is highly preferred among Rust developers due to its support for Rust via the "Rust Language Server" or "rust-analyzer" plugins. [IntelliJ-based IDEs](https://www.jetbrains.com/idea/) also support Rust through their plugin. Additionally, [Sublime Text](https://www.sublimetext.com) and [Atom](https://atom.io) with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, [Vim](https://www.vim.org) and [Emacs](https://www.gnu.org/software/emacs/) are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and tools for debugging which prove useful for Rust programming. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/105-rust-repl.md b/src/data/roadmaps/rust/content/100-introduction/105-rust-repl.md index bbce92630..3bddf6d46 100644 --- a/src/data/roadmaps/rust/content/100-introduction/105-rust-repl.md +++ b/src/data/roadmaps/rust/content/100-introduction/105-rust-repl.md @@ -1 +1,3 @@ -# Rust repl \ No newline at end of file +# Rust REPL (Rust Playground) + +`Rust REPL` (Read-Eval-Print-Loop) is an interactive shell in which you can write and test Rust snippets in real-time. Unlike running a program normally in Rust where you have to manually compile and then run the program, in REPL the inputs are automatically evaluated, and the result is returned immediately after execution. This is helpful when experimenting with Rust code, learning the language, and debugging. REPL isn't built into Rust directly but is available via third-party tools such as `evcxr_repl`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/100-introduction/index.md b/src/data/roadmaps/rust/content/100-introduction/index.md index f6ecaa676..4ab6f2aed 100644 --- a/src/data/roadmaps/rust/content/100-introduction/index.md +++ b/src/data/roadmaps/rust/content/100-introduction/index.md @@ -1 +1,4 @@ -# Introduction \ No newline at end of file +# Introduction + +Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance. + diff --git a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/101-variables.md b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/101-variables.md index bb79b115c..b9bf02d58 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/101-variables.md +++ b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/101-variables.md @@ -1 +1,3 @@ -# Variables \ No newline at end of file +# Variables, Constants, and Data Types + +In Rust, variables are declared using the `let` keyword. They are immutable by default, which means once a value is bound to a variable, it cannot be changed. If you want to make a variable mutable, the `mut` keyword is used. So, if you wanted to declare a mutable variable `x` and assign it the value `5`, you would write `let mut x = 5;`. Variables can also be patterned. By default in Rust, variables are block-scoped. Rust also supports several types of variable attributes. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/102-control-flow.md b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/102-control-flow.md index 5c18d7b9a..879a3f648 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/102-control-flow.md +++ b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/102-control-flow.md @@ -1 +1,3 @@ -# Control flow \ No newline at end of file +# Control Flow Constructs + +In Rust, control flow is managed through various structures like `if`, `else`, `while`, `for`, and `match`. The `if` and `else` structures are used to execute different blocks of code based on certain conditions. Similar to other languages, `while` and `for` are used for looping over a block of code. The `while` loop repeats a block of code until the condition is false, and the `for` loop is used to iterate over a collection of values like an array or a range. The `match` structure is a powerful tool in Rust which can be used for pattern matching. It goes through different cases and executes the block where the match is found. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/103-functions.md b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/103-functions.md index cebcc2697..4ab5dc17d 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/103-functions.md +++ b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/103-functions.md @@ -1 +1,3 @@ -# Functions \ No newline at end of file +# Functions and Method Syntax + +In Rust, functions are declared using the `fn` keyword. Each function takes a set of input variables with their specified types and may optionally return a type. The body of the function is contained within curly braces `{}`. Unlike other languages, in Rust you don't need to end the statement with a semicolon if it’s the last one in a block, making it the implicit return. If we want to return a value, we simply write the expression we want to return. An example of a function in Rust is `fn add(one: i32, two: i32) -> i32 { one + two }` where `one` and `two` are parameters of type `i32` and the function returns an integer of type `i32`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/104-pattern-matching.md b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/104-pattern-matching.md index 863fc4095..a8b2c3179 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/104-pattern-matching.md +++ b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/104-pattern-matching.md @@ -1 +1,3 @@ -# Pattern matching \ No newline at end of file +# Pattern Matching and Destructuring + +In Rust, `pattern matching` is a robust tool that allows you to destructure data types and perform conditional checks in a succinct and clear way. The main structures used for pattern matching are `match` and `if let`. The `match` keyword can be used to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The `if let` allows you to combine `if` and `let` into a less verbose way to handle values that match a specific pattern. It's basically a nice syntax sugar over a `match` statement. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/index.md b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/index.md index bb29c1dbe..de0943044 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/100-syntax/index.md +++ b/src/data/roadmaps/rust/content/101-language-basics/100-syntax/index.md @@ -1 +1,3 @@ -# Syntax \ No newline at end of file +# Syntax and Semantics + +Rust's syntax aims for readability and avoids visual clutter. It places a great deal of importance on forward compatibility, even when it occasionally hinders feature additions. Most Rust syntax is based on the same basic principles. Understanding a handful of concepts allows a broad understanding of the structure of most Rust programs. Some of these concepts include item declarations and pattern matching. In Rust, you typically declare an item once and then refer to it by its name. Pattern matching is a fundamental and powerful part of Rust’s syntax, allowing you to branch your code based on the structure of data, not just its value or type. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/100-rules.md b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/100-rules.md index c55cf49db..ba932493f 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/100-rules.md +++ b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/100-rules.md @@ -1 +1,3 @@ -# Rules \ No newline at end of file +# Ownership Rules and Memory Safety + +In Rust, the concept of ownership is described by three main rules. Firstly, each value in Rust has a variable that is called its owner. Secondly, there can only ever be one owner at a time. This prevents multiple parts of the code from trying to modify the data at once, potentially causing data races and inconsistencies. Lastly, when the owner goes out of scope, the value will be dropped. This ensures that Rust cleans up the allocated memory and other resources once they’re no longer required, thereby avoiding memory leaks. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/101-borrowing.md b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/101-borrowing.md index 61ae49f79..459a30b0e 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/101-borrowing.md +++ b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/101-borrowing.md @@ -1 +1,3 @@ -# Borrowing \ No newline at end of file +# Borrowing, References, and Slices + +In Rust, "borrowing" is a technique which allows you to access the data of a particular value while the owner retains control. There are two types of borrowing: mutable and immutable. Immutable borrowing means an owner can fondly permit several read-only borrows of a value at the same time as long as the value doesn't change. On the other hand, mutable borrowing allows only a single borrower at a time who can potentially modify the value. This practice is essential in maintaining the concept of ownership without violating any of its rules and avoiding the problem of dangling references. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/102-stack-heap.md b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/102-stack-heap.md index aaf037290..81bde473f 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/102-stack-heap.md +++ b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/102-stack-heap.md @@ -1 +1,3 @@ -# Stack heap \ No newline at end of file +# Deep Dive: Stack vs Heap + +In most modern computer systems, memory management is split into two main parts: the stack and the heap. The **stack** is a section of memory that grows and shrinks automatically as functions are called and return. The data stored on the stack must have a known, fixed size. The **heap** is a section of memory that is used for data that needs to persist for longer than a single function-call. Data with dynamic size is stored on the heap. Rust, like many languages, has facilities for using these two types of memory, allowing developers fine-tuned control over memory usage. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/index.md b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/index.md index c69bfc774..e1eae440d 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/101-ownership/index.md +++ b/src/data/roadmaps/rust/content/101-language-basics/101-ownership/index.md @@ -1 +1,3 @@ -# Ownership \ No newline at end of file +# Onwnership System + +In Rust, the concept of `Ownership` is a key feature that governs how memory management works. Each value in Rust has its own designated owner and there can be only one owner for a value at a time. When the owner goes out of scope, the value would be automatically dropped. The three main facets of ownership include ownership rules, `borrowing` and `slices`. Ownership rules play a key role in system performance and prevention of issues like null or dangling references. `Borrowing` is a mechanism where we allow something to reference a value without taking ownership. Finally, `slices` are a data type that does not have ownership and helps in making a reference to a portion of a collection. diff --git a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/100-enums.md b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/100-enums.md index 1cf9f0037..3f4166cfa 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/100-enums.md +++ b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/100-enums.md @@ -1 +1,3 @@ -# Enums \ No newline at end of file +# Enums + +Enums, short for enumerations, allow you to define a type by enumerating its possible variants. An instance of an enum type could be any one of these variants, and in Rust, enums are incredibly versatile. Unlike enumerations in some other languages, these variants aren't restricted to a singular data type. You can attach data to each variant of the enum, and the data could have different types and amounts for each variant. It's also possible to embed structs and even other enums. Enums in Rust also enable pattern-matching, which allows you to compare a value to a series of patterns, handle it if it matches one of them, and execute code based on which pattern has been matched. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/101-structs.md b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/101-structs.md index 17c24f6c0..a72abe861 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/101-structs.md +++ b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/101-structs.md @@ -1 +1,3 @@ -# Structs \ No newline at end of file +# Structs + +In Rust, `struct` is a custom data type used for grouping related values together into one entity. It is similar to classes in other programming languages. Essentially, they create a new type that we can use to streamline complex data handling. There are three types of `struct` in Rust - classic `C` structs, tuple structs, and unit structs. Classic `C` structs are named-field struct and are the most commonly used. Tuple struct, while not being common, are useful when you want to couple together a few data points. Unit structs are useful in situations where you want to implement a trait on some type but don’t have any data that you want to store in the type itself. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/102-traits.md b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/102-traits.md index d67a15118..b5672bb79 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/102-traits.md +++ b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/102-traits.md @@ -1 +1,3 @@ -# Traits \ No newline at end of file +# Traits + +Traits in Rust programming language define shared behaviors. They are a way to group method signatures together to define a set of behaviors required by a type. Anything with a certain trait will have the behavior of that trait's methods. Traits are abstract, and it's not possible as such to create instances of traits. However, we can define pointers of trait types, and these can hold any implementer of the trait. A trait is implemented for something else, which can be a concrete type or another trait. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/103-impl-blocks.md b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/103-impl-blocks.md new file mode 100644 index 000000000..703be4ad7 --- /dev/null +++ b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/103-impl-blocks.md @@ -0,0 +1,3 @@ +# Impl Blocks + +Impl Block in rust is used to implement a trait or a struct. It is used to define the behavior of a trait or a struct. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/index.md b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/index.md index 95a56890f..b71c60ec9 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/102-constructs/index.md +++ b/src/data/roadmaps/rust/content/101-language-basics/102-constructs/index.md @@ -1 +1,3 @@ -# Constructs \ No newline at end of file +# Constructs + +In Rust, "constructs" refer to different elements used to build the structure of the program. This includes variables, functions, data types, control flow statements, and more. **Variables** store data, and their mutable or immutable status is determined at their declaration. **Functions** are reusable blocks of code defined by the `fn` keyword. Data types in Rust are static and must be declared upfront. These include simple ones like integers, boolean, float, etc, and complex types like arrays, tuples etc. **Control Flow** structures help direct the flow of execution. These include `if`, `else`, `loop`, `while`, `for`, and more. Exception handling uses the `Result` and `Option` enums along with the `match` construct. Rust's constructs like these come together to structure your program in a safe yet efficient manner. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/100-integers.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/100-integers.md index 26a3d668d..3f5e5546a 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/100-integers.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/100-integers.md @@ -1 +1,3 @@ -# Integers \ No newline at end of file +# Integers + +In Rust, integers are a primitive data type that hold whole number values, both positive and negative. Integer types in Rust can be divided into two subcategories: signed and unsigned. Signed integers are those that can hold negative, zero, and positive values whereas unsigned integers only hold zero and positive values. They are denoted by "i" and "u" respectively followed by a number which represents the number of bits they occupy in memory. The available integer types are `i8`, `i16`, `i32`, `i64`, `i128` and `isize` (signed), and `u8`, `u16`, `u32`, `u64`, `u128` and `usize` (unsigned). In these types, the number after "i" or "u" denotes the size of the integer type in bits. The `isize` and `usize` types depend on the kind of computer your program is running on: 64 bits on a 64-bit architecture and 32 bits on a 32-bit architecture. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/101-floats.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/101-floats.md index 9923d7900..5e4942892 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/101-floats.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/101-floats.md @@ -1 +1,3 @@ -# Floats \ No newline at end of file +# Floats + +In Rust, `floats` are used to represent floating-point numbers. They are defined as numerical values with fractional components. Rust supports two types of floating-point numbers: `f32` and `f64`. These are 32-bit and 64-bit in size, respectively. `f32` is a single-precision float, while `f64` has double precision. The default type is `f64` because on modern CPUs it’s roughly the same speed as `f32` but allows more precision. You can define a float in Rust like so: `let x: f32 = 3.0;`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/102-boolean.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/102-boolean.md index 522544a96..9665d3a13 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/102-boolean.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/102-boolean.md @@ -1 +1,3 @@ -# Boolean \ No newline at end of file +# Boolean + +`Boolean` in Rust is a basic data type that encapsulates the truth value. It is represented by `bool` keyword and can hold two values either `true` or `false`. Rust includes `boolean` as its primitive data type and operations like logical `AND (&&)`, logical `OR (||)`, and logical `NOT (!)` can be performed on these types of values. Boolean is primarily used in conditional statements like `if`, `while` etc. For example, `let is_raining: bool = true;` where `is_raining` is a boolean variable holding the value `true`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/103-character.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/103-character.md index 1acbeabbe..83b6cb9f4 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/103-character.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/103-character.md @@ -1 +1,3 @@ -# Character \ No newline at end of file +# Character + +In Rust, the `char` keyword is used to denote a character type. A `char` in Rust represents a Unicode Scalar Value, which means it can represent a lot more than just ASCII. Accented letters, Chinese/Japanese/Korean ideographs, emoji, and zero width spaces are all valid `char` Types in Rust. It uses 4 bytes to store a single character. It is defined with single quotes like `let x: char = 'z';`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/104-tuple.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/104-tuple.md index f37bec8cb..b91493836 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/104-tuple.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/104-tuple.md @@ -1 +1,3 @@ -# Tuple \ No newline at end of file +# Tuple + +In Rust, a **Tuple** is a type of data structure that holds a finite number of elements, each having potentially different types. Elements in a tuple are accessed using a dot (`.`) followed by the index of the value we want to get. For example, to declare a tuple that includes a `32-bit integer`, a `single-byte unsigned integer`, and a `floating point number`, we would write `let my_tuple: (i32, u8, f64) = (500, 2, 20.5);` The index of elements in a tuple start from `0`. So, to access the first element, use `my_tuple.0`, the second element `my_tuple.1`, and so on. Tuples can also be used for multiple declarations and assignments. Tuples are particularly useful when you want to group together items of different types. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/105-array.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/105-array.md index 0a0e30ae6..15d230bed 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/105-array.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/105-array.md @@ -1 +1,3 @@ -# Array \ No newline at end of file +# Array + +In Rust, an `array` is a collection of elements of the same type, organized consecutively in memory. Unlike some other data structures in Rust, the size of an array must be known at compile time. This gives it a distinct advantage in memory efficiency. The size of the array cannot be changed after it has been declared. The syntax to declare an array in Rust is as follows: `let array_name: [type; size] = [elements];`. Here, `type` represents the data type of the elements, `size` is the number of elements and `elements` are the data held in the array. For example: `let numbers: [i32; 5] = [1, 2, 3, 4, 5];`. Elements in an array can be accessed using their indices, starting from 0. For instance, `numbers[0]` will return the first element `1` in the `numbers` array. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/106-vector.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/106-vector.md index e93e6fb9c..30b5e8374 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/106-vector.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/106-vector.md @@ -1 +1,3 @@ -# Vector \ No newline at end of file +# Vector + +A `Vector` in Rust, often referred to as `Vec`, is a growable, or dynamically-sized, array-like data structure that can store homogeneous types. It stores elements of the same type in a contiguous block of memory, with the count of elements and capacity managed automatically by Rust. Unlike arrays, vectors do not need to have a predetermined size at compile time and their size can be increased or decreased at runtime. The `Vec` holds its data on the heap. It maintains a pointer to the data, a length, and a capacity. The length is the number of elements currently stored in the vector, while the capacity is the total allocation in the memory. The key methods for a `Vec` include `push()`, `pop()`, and `len()`, among others. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/107-string.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/107-string.md index f3ad14fe7..1c458d995 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/107-string.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/107-string.md @@ -1 +1,3 @@ -# String \ No newline at end of file +# String + +In Rust, `String` is a growable, mutable, owned, UTF-8 encoded string type. When Rustaceans refer to 'strings' in Rust, they usually mean the `String` and the string slice `str` types, not just one of those types. Both types are UTF-8 encoded. A `String` in Rust is similar to a string in other languages, but is not null-terminated at the end. Creation of a `String` can be done from a literal string with `String::from("Hello, world!")` or by converting a string slice with `"Hello, world!".to_string()`. String concatenations and manipulations are achieved via a multitude of methods such as `push_str()`, `push()`, `+` operator, `format!()` macro, etc. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/108-hashmap.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/108-hashmap.md index 4bfbb3744..398a3ac60 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/108-hashmap.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/108-hashmap.md @@ -1 +1,3 @@ -# Hashmap \ No newline at end of file +# Hashmap + +The `HashMap` in Rust is part of the standard library's collections framework and it's a generic collection of key-value pairs. It allows for the quick lookup, insertion, and removal of items using hashing. A `HashMap` holds a mapping of keys of type `K` to values of type `V`. The keys are unique and when a key gets inserted for the second time with a different value, the new value replaces the old value. Rust's `HashMap` uses a cryptographically strong hashing algorithm which can help avoid denial-of-service (DoS) attacks. It is however not ordered, so items may not be in the same order as they were inserted. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/109-hashset.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/109-hashset.md index c1a169eb4..daa4b4f4e 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/109-hashset.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/109-hashset.md @@ -1 +1,3 @@ -# Hashset \ No newline at end of file +# Hashset + +`HashSet` in Rust is a collection of unique elements. It's a data structure which stores details in the form of key and value, and it uses `hashing` to store elements. It's implemented as a `hash table`, as it makes use of a hasher to make the structure more secure against collision attacks. A `HashSet` only contains keys, associating the value portion of the map with a dummy unit. The value of `HashSet` returns an iterator over the elements of the set and these elements are arbitrary and not in any specific order. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/110-linked-list.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/110-linked-list.md index f91856f34..f4f702d15 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/110-linked-list.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/110-linked-list.md @@ -1 +1,3 @@ -# Linked list \ No newline at end of file +# LinkedList + +The **Linked List** in Rust is a sequence of nodes where each node consists of a value and a pointer/reference to the next node in the sequence. Linked Lists are primarily used for implementing higher level data structures such as stacks, queues and associative arrays. Rust's `std::collections` provides a `LinkedList` struct that is a doubly-linked list with O(1) insertion and removal at both the front and back, but with O(n) indexing. diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/111-binary-heap.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/111-binary-heap.md index 1291390d0..43c7f189d 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/111-binary-heap.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/111-binary-heap.md @@ -1 +1,3 @@ -# Binary heap \ No newline at end of file +# BinaryHeap + +A `Binary Heap` is a complete binary tree which is either Min Heap or Max Heap. In a Max Binary Heap, the key at root must be maximum among all other keys present in Binary Heap. The same property must be recursively true for all nodes in Binary Tree. Min Binary Heap is similar to Max Binary Heap. But in a Min Binary Heap, the key at root must be minimum among all other keys present in Binary Heap. This property must be recursively true for all nodes in Binary Tree. Binary Heaps have efficient implementations on arrays. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/112-stack.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/112-stack.md index 463aa833c..ced610a36 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/112-stack.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/112-stack.md @@ -1 +1,3 @@ -# Stack \ No newline at end of file +# Stack + +The **Stack** is a fundamental data structure in Rust, which is based on the principle of Last-In-First-Out (LIFO). In other words, elements that are added last are the first ones to be removed. This is functionally similar to a real-world stack, such as a stack of plates. One key aspect of stacks in Rust is that they are bounded to a certain size at compile-time. This implies that stack size does not grow or shrink dynamically. In Rust, function calls are operated using stack with each call pushing a new stack frame to the end, and each return statement popping one off. Stack Overflow occurs when too much of the stack is used. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/113-queue.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/113-queue.md index b3125c93f..4085c165c 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/113-queue.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/113-queue.md @@ -1 +1,3 @@ -# Queue \ No newline at end of file +# Queue + +In Rust, a Queue is another important linear data structure which follows a particular order in which the operations are performed. The order given to the elements follows the FIFO (First In First Out) approach. There are no direct standard library data structures meant solely to act as a Queue in Rust, but we can obtain queue-like behaviors using other provided data structures. More commonly, the VecDeque structure is used as a Queue. It supports constant time element insertion and removal at both ends. The 'push_back' and 'pop_front' functions essentially form a Queue structure. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/114-btree-map.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/114-btree-map.md index ae72df255..dc88ad220 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/114-btree-map.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/114-btree-map.md @@ -1 +1,3 @@ -# Btree map \ No newline at end of file +# BTreeMap + +In Rust, `BTreeMap` is a generic collection that stores data in a sorted tree structure. More specifically, it uses a self-balancing binary search tree (a type of `B+-tree`). `BTreeMap`s implement the `Map` trait, including methods such as `get`, `insert`, `remove`, and many others. The data stored in a `BTreeMap` will be sorted by key, which allows efficient lookup, insertions, and removals. The keys of the `BTreeMap` must implement the `Ord` trait, which means they must be orderable. Because `BTreeMap`s store data in a sorted order, the iteration of keys and values will be in sorted order as well. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/115-btree-set.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/115-btree-set.md index 0c79690c0..3223ef5de 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/115-btree-set.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/115-btree-set.md @@ -1 +1,3 @@ -# Btree set \ No newline at end of file +# BTreeSet + +`BTreeSet` in Rust is a data structure that implements a set backed by a BTree. Its functionality is similar to that of other set data structures in that it maintains a collection of unique elements and allows for operations like insertion, removal, and querying. But the elements in a `BTreeSet` are sorted according to an ordering relation, which may be customized by the user. The sorting enables efficient range queries as well as other operations such as finding the minimum or maximum element. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/116-rc.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/116-rc.md index 2b50c2e7e..644fb4231 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/116-rc.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/116-rc.md @@ -1 +1,3 @@ -# Rc \ No newline at end of file +# Rc + +`Rc` stands for Reference Counting, a data type in Rust that allows multiple owners for the same data on the heap while keeping track of the number of references to that data. If there are zero references to data, the value can be cleaned up without any references becoming invalid. Avoiding these problems comes at the cost of some memory overhead, because `Rc` keeps track of the total number of references which means it needs to allocate memory to keep the count. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/117-arc.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/117-arc.md index 5ccfd67f5..6e420efc0 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/117-arc.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/117-arc.md @@ -1 +1,3 @@ -# Arc \ No newline at end of file +# Arc + +`Arc` in Rust stands for "Atomic Reference Counting". It is a thread-safe reference-counting type used for sharing immutable data between multiple parts of the system. With `Arc`, we can have multiple references to the same data which is useful for concurrent programming. When the last reference to a type is gone, the `Arc` will clean up the underlying data. Unlike `Rc` (Reference Counting), which is single-threaded, `Arc` uses atomic operations for incrementing and decrementing the reference count hence making it safe to share across threads. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/118-mutex.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/118-mutex.md index 5bcc47da4..bafe461cd 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/118-mutex.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/118-mutex.md @@ -1 +1,3 @@ -# Mutex \ No newline at end of file +# Mutex + +`Mutex` or "Mutual Exclusion" in Rust is a concurrency primitive that is used to protect shared data from being concurrently accessed by multiple threads. When one thread starts using a `Mutex`, other threads have to wait until the Mutex is unlocked. When a thread has finished handling the shared data, it should unlock the `Mutex` to allow other threads to access the shared data. If not properly handled, it could lead to a software deadlock or other timing-related issues. Rust's Mutex has a built-in safeguard against these problems – if a thread that is holding a Mutex crashes, Rust will automatically unlock the Mutex. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/119-rwlock.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/119-rwlock.md index cc7074e3f..cc3e8d328 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/119-rwlock.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/119-rwlock.md @@ -1 +1,3 @@ -# Rwlock \ No newline at end of file +# RwLock + +`RwLock` in Rust stands for Read/Write lock, which is a type of synchronization primitive. It is an advanced version of the Mutex data structure. Unlike Mutex, which only allows one thread to access the data, `RwLock` allows multiple threads to read data at the same time but only one thread to write. If a thread is writing, no other thread can read or write. The syntax for declaring `RwLock` is `let lock = RwLock::new(value)`. Please remember that a potential downside of `RwLock` is lock contention, making sure to properly manage read-write access. The appropriate use of `RwLock` can enable better performance for workloads that involve heavy reading. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/120-channels.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/120-channels.md index bf27c3575..ea742f7e1 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/120-channels.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/120-channels.md @@ -1 +1,3 @@ -# Channels \ No newline at end of file +# Channels + +Channels in Rust allow communication between threads. They are a programming paradigm that is part of the message passing concurrency model. Channels are used to send and receive values between threads, ensuring thread safety by avoiding shared state. Rust channels have two parts - `Sender` and `Receiver`. `Sender` is used for sending data, and `Receiver` is used to read the data. This model follows the 'multiple producer, single consumer' rule, meaning it can have multiple sending ends but only one receiving end. Channels in Rust are provided by the `std::sync::mpsc` module, where mpsc stands for Multiple Producer, Single Consumer. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/index.md b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/index.md index 3affd1f57..43b10b4f8 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/index.md +++ b/src/data/roadmaps/rust/content/101-language-basics/103-data-structures/index.md @@ -1 +1,11 @@ -# Data structures \ No newline at end of file +# Data Structures + +In Rust, there are different types of data structures for organizing and storing data. Some of the primary types include: + +- **Structures (structs)**: These are custom data types that allow you to combine multiple related values of different types. Structs implement methods and can also maintain private fields. Structs come in three types: classic C-style structs, tuple structs, and unit structs. +- **Tuples**: These are a sequence of fixed-size elements of possibly differing types. The elements of a tuple can be accessed using dot notation followed by the index starting from 0. +- **Enums (enumerations)**: These are data structures that allow you to define a type by enumerating its possible variants. Enum variants can be simple values or complex ones with fields. +- **Arrays** and **Vectors**: These are collections of items with the same type. An array is fixed-sized, while a vector can grow or shrink its size. Arrays and vectors store elements in contiguous memory locations. +- **Hash Maps**: A Hash Map keeps track of elements in key-value pairs, similar to a dictionary or a JavaScript object. They are great for quick lookups. + +The Rust language also provides powerful reference and borrowing mechanism to control memory, data read/write access, and mutation to avoid problems like data races in concurrent scenarios. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/101-language-basics/index.md b/src/data/roadmaps/rust/content/101-language-basics/index.md index 95394dde6..d85d1ae5d 100644 --- a/src/data/roadmaps/rust/content/101-language-basics/index.md +++ b/src/data/roadmaps/rust/content/101-language-basics/index.md @@ -1 +1,3 @@ -# Language basics \ No newline at end of file +# Language Basics + +The "language basics" of Rust encompass the fundamental elements you'll need to grasp to get your programming underway. This commences with understanding Rust's syntax and semantics, followed by grasping variables and data types, which are essential in creating effective code. Rust language basics also incorporate concepts of control flow, such as loops and conditional statements. Lastly, functions are another vital element, providing you the ability to structure your code and reuse segments of it. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/102-error-handling/100-option.md b/src/data/roadmaps/rust/content/102-error-handling/100-option.md index bdc90e902..0eabfd79c 100644 --- a/src/data/roadmaps/rust/content/102-error-handling/100-option.md +++ b/src/data/roadmaps/rust/content/102-error-handling/100-option.md @@ -1 +1,3 @@ -# Option \ No newline at end of file +# Option & Result Enumerations + +`Option` is an enumeration, also known as an `enum`, in Rust with two variants: `Some(T)` and `None`. It is a flexible and safe alternative to using `null` values or exceptions for indicating that a value might not be present. If a function may not return a value for all possible input, it should return an `Option` value. `Some(T)` variant contains the valid value of type `T` and `None` variant indicates the absence of a value. You can perform various operations on `Option` values, such as method chaining and pattern matching, to effectively handle both states (value present or absent). The `Option` enum encourages you to consciously deal with the possibility of missing values and helps prevent unforeseen runtime errors. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/102-error-handling/101-propagating.md b/src/data/roadmaps/rust/content/102-error-handling/101-propagating.md index 5c8e26e83..297fba83b 100644 --- a/src/data/roadmaps/rust/content/102-error-handling/101-propagating.md +++ b/src/data/roadmaps/rust/content/102-error-handling/101-propagating.md @@ -1 +1,3 @@ -# Propagating \ No newline at end of file +# Propagating Errors and `?` Operator + +Propagating errors in Rust is about passing the error information from the function that failed to the function that called it. Using the `?` operator is one way to achieve this. This operator can only be used in functions that return `Result` or `Option` or another type that implements `std::ops::Try`. If the value of the `Result` is `Ok`, the value inside the `Ok` will get returned. If the value is `Err`, the `Err` will be returned from the whole function. Consequently, the error gets propagated to the calling function. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/102-error-handling/102-custom-error.md b/src/data/roadmaps/rust/content/102-error-handling/102-custom-error.md index ae7d4a760..909a6319d 100644 --- a/src/data/roadmaps/rust/content/102-error-handling/102-custom-error.md +++ b/src/data/roadmaps/rust/content/102-error-handling/102-custom-error.md @@ -1 +1,3 @@ -# Custom error \ No newline at end of file +# Custom Error Types and Traits + +In Rust, you can define your own types of errors using the `enum` construct. This gives you the ability to specify different types of errors that your code can encounter, and attach additional information to them. To make your custom error type compatible with the rest of Rust's error handling machinery, you need to implement two traits: `std::fmt::Debug` and `std::fmt::Display`. There is also a third trait, `std::error::Error`, which can provide backtraces and the ability to have chained errors or causes. Furthermore, the `thiserror` library provides a convenient way to define custom error types with a simple annotation. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/102-error-handling/index.md b/src/data/roadmaps/rust/content/102-error-handling/index.md index 6742011d4..686f08018 100644 --- a/src/data/roadmaps/rust/content/102-error-handling/index.md +++ b/src/data/roadmaps/rust/content/102-error-handling/index.md @@ -1 +1,3 @@ -# Error handling \ No newline at end of file +# Error Handling + +Error handling in Rust is achieved primarily through two types of results: the `Result` and `Option`. The `Result` variant is used for functions that can result in an error. It has two variants, `Ok(T)` which indicates operation was successful and `Err(E)` when an error occurred. On the other hand, `Option` is used for functions that can return a `none` value but not cause an error. This result type also has two variants, `Some(T)` indicates that the operation was successful and `None` specifies absence of a value. Rust's pattern matching features can be used to handle different types of errors thrown by these results. Furthermore, propagation of errors in Rust can be achieved using the `?` operator that returns early if the function fails. It's important to note that Rust does not have exceptions, thus eliminates the common problems associated with them. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/103-modules-and-crates/100-code-organization.md b/src/data/roadmaps/rust/content/103-modules-and-crates/100-code-organization.md index 2fef0e766..0987a4aa7 100644 --- a/src/data/roadmaps/rust/content/103-modules-and-crates/100-code-organization.md +++ b/src/data/roadmaps/rust/content/103-modules-and-crates/100-code-organization.md @@ -1 +1,3 @@ -# Code organization \ No newline at end of file +# Code Organization and Namespacing + +In Rust, the fundamental structure for organizing your code is through using a **module** system and **crates**. A module in Rust allows grouping of related function definitions and struct definitions in a named scope. It’s defined using the `mod` keyword. The modules can also be nested and make code more concise, readable, and manageable. On the other hand, a **crate** is a binary or a library project in Rust. It's the largest compilation unit of Rust. It's a tree of modules that produces a library or executable. The crate root is a source file which the Rust compiler starts from and makes up the root module of your crate (e.g. `main.rs` or `lib.rs`). \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/103-modules-and-crates/101-dependency-mgmt.md b/src/data/roadmaps/rust/content/103-modules-and-crates/101-dependency-mgmt.md index 79d6c0891..0f15c0738 100644 --- a/src/data/roadmaps/rust/content/103-modules-and-crates/101-dependency-mgmt.md +++ b/src/data/roadmaps/rust/content/103-modules-and-crates/101-dependency-mgmt.md @@ -1 +1,3 @@ -# Dependency mgmt \ No newline at end of file +# Dependency Management with Cargo.toml + +Dependency management in Rust is handled by a tool called Cargo. Cargo helps you manage your Rust projects, providing functionalities for building your code, downloading the libraries your project depends on, and building those libraries. These libraries are called *crates*. A crate is a package of Rust code. In your `Cargo.toml`, you list your dependencies in a [dependencies] section. You list libraries from crates.io by their name and version number. Cargo understands Semantic Versioning, a standard for writing version numbers. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/103-modules-and-crates/102-publishing.md b/src/data/roadmaps/rust/content/103-modules-and-crates/102-publishing.md index abe6c2ff5..e173c98dd 100644 --- a/src/data/roadmaps/rust/content/103-modules-and-crates/102-publishing.md +++ b/src/data/roadmaps/rust/content/103-modules-and-crates/102-publishing.md @@ -1 +1,3 @@ -# Publishing \ No newline at end of file +# Publishing to crates.io + +Publishing in Rust involves packaging up your library or executable and making it available for others to use. To publish a crate, you'll need to create an account on [crates.io](https://crates.io/), the Rust package repository. If you haven't already, you'll need to format your project in a specific way, detailing needed information in a `Cargo.toml` file. Then, use the command `cargo publish` to upload your crate to the registry. Updates to your crate can be published with the same command, but be mindful that crates.io does not allow you to delete or overwrite an existing version of a crate. Make sure that everything is in order before you publish! \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/103-modules-and-crates/index.md b/src/data/roadmaps/rust/content/103-modules-and-crates/index.md index d390f13a0..2b6db44dd 100644 --- a/src/data/roadmaps/rust/content/103-modules-and-crates/index.md +++ b/src/data/roadmaps/rust/content/103-modules-and-crates/index.md @@ -1 +1,3 @@ -# Modules and crates \ No newline at end of file +# Modules and Crates + +In Rust, a module is a namespace that contains definitions of functions or types. You can choose to make the definitions visible in other modules or not. This provides a method of encapsulation for your code. On the other hand, a crate is a binary or library. It is the smallest unit of compilation in Rust. A crate can link to other crates, and it is composed of many modules. Therefore, the module system allows for code organization within a crate, and the crate system allows for building and sharing functionality among multiple projects. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/104-concurrency-parallelism/100-futures.md b/src/data/roadmaps/rust/content/104-concurrency-parallelism/100-futures.md index a15149f0a..0ff87189e 100644 --- a/src/data/roadmaps/rust/content/104-concurrency-parallelism/100-futures.md +++ b/src/data/roadmaps/rust/content/104-concurrency-parallelism/100-futures.md @@ -1 +1,3 @@ -# Futures \ No newline at end of file +# Futures and Async/Await Paradigm + +Futures in Rust represent values that might not have been computed yet. They are a way for the program to describe an operation that will be completed at some point in the future, or will complete asynchronously. They are a cornerstone of many async applications in Rust. A Future is an asynchronous computation that can produce a value (Ok-type) or an error (Err-type). The critical idea behind futures is that they can produce their value at some point in time, that "sometime" can be now, in the future, or never. diff --git a/src/data/roadmaps/rust/content/104-concurrency-parallelism/101-atomic-operations.md b/src/data/roadmaps/rust/content/104-concurrency-parallelism/101-atomic-operations.md index 1612c6a6f..966215d5a 100644 --- a/src/data/roadmaps/rust/content/104-concurrency-parallelism/101-atomic-operations.md +++ b/src/data/roadmaps/rust/content/104-concurrency-parallelism/101-atomic-operations.md @@ -1 +1,3 @@ -# Atomic operations \ No newline at end of file +# Atomic Operations and Memory Barriers + +Atomic operations in Rust are low-level types that support lock-free concurrent programming. These operations are atomic because they complete in a single operation rather than being interruptible. In Rust, atomic types provide primitive shared-memory communication between threads, and can also be used for non-blocking data structures and are supported using machine instructions directly. They form the building blocks for other, higher-level concurrency abstractions. It includes variety of atomic operations such as `store`, `load`, `swap`, `fetch_add`, `compare_and_swap` and more, which are operations performed in a single, uninterrupted step. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/104-concurrency-parallelism/102-threads.md b/src/data/roadmaps/rust/content/104-concurrency-parallelism/102-threads.md index e8b5f56d7..70146d11c 100644 --- a/src/data/roadmaps/rust/content/104-concurrency-parallelism/102-threads.md +++ b/src/data/roadmaps/rust/content/104-concurrency-parallelism/102-threads.md @@ -1 +1,3 @@ -# Threads \ No newline at end of file +# Threads, Channels, and Message Passing + +Threads are the smallest unit of computing that can be scheduled by an operating system. They live in the context of a process, and each thread within a process shares the process's resources including memory and file handles. In Rust, the `std::thread` module allows you to have direct control over threads. This model of concurrency is known as 1:1, mapping one operating system thread to one language thread. You can write concurrent programs in Rust using threads in a similar way as most other languages. You start threads with `std::thread::spawn` and wait for them to finish with `join`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/104-concurrency-parallelism/index.md b/src/data/roadmaps/rust/content/104-concurrency-parallelism/index.md index 56127ecda..a27d3a3d4 100644 --- a/src/data/roadmaps/rust/content/104-concurrency-parallelism/index.md +++ b/src/data/roadmaps/rust/content/104-concurrency-parallelism/index.md @@ -1 +1,3 @@ -# Concurrency parallelism \ No newline at end of file +# Concurrency and Parallelism + +Concurrency and parallelism are two terms related to multitasking. In **concurrency**, tasks have the ability to run in an overlapping manner, which does not necessarily mean they run at the same exact time. It means the start and end times of the tasks intersect. On the other hand, **parallelism** is the process where several tasks are executed simultaneously. In the context of programming, especially in systems such as Rust, these concepts are exceptionally important. Understanding them is crucial to implementing complex algorithms and systems that benefit from the efficient use of resources, and most importantly, time. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/105-traits-generics/100-trait-def.md b/src/data/roadmaps/rust/content/105-traits-generics/100-trait-def.md index 79ff5fee3..95592beb6 100644 --- a/src/data/roadmaps/rust/content/105-traits-generics/100-trait-def.md +++ b/src/data/roadmaps/rust/content/105-traits-generics/100-trait-def.md @@ -1 +1,3 @@ -# Trait def \ No newline at end of file +# Trait Definitions and Implementations + +A `trait` definition in Rust is a way to define a set of behaviors necessary for a certain type. It is essentially an interface that types can implement. The `trait` def is created using the `trait` keyword followed by its name and the set of methods it includes enclosed in curly brackets. These methods are defined under the trait with their signature but without their implementation. Once a trait is defined, it can be implemented for any data type. Note that the type that this trait applies to is represented by the keyword `Self`. For example, `trait GetName { fn get_name(&self) -> String; }` defines a trait `GetName` with a method `get_name`. This trait can then be implemented for any type that needs the behaviour `get_name`. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/105-traits-generics/101-trait-bounds.md b/src/data/roadmaps/rust/content/105-traits-generics/101-trait-bounds.md index 726c5ac82..c2c1be79b 100644 --- a/src/data/roadmaps/rust/content/105-traits-generics/101-trait-bounds.md +++ b/src/data/roadmaps/rust/content/105-traits-generics/101-trait-bounds.md @@ -1 +1,3 @@ -# Trait bounds \ No newline at end of file +# Trait Bounds and Associated Types + +Trait Bounds in Rust is a way of specifying that a generic must satisfy a certain trait. Essentially, a trait bound says something like: "T must support the following behavior". In other words, they allow you to use generic type parameters in your function definitions to specify that the function can accept any type as a parameter, as long as that type implements a certain trait. For instance, `T: Display` would constitute a trait bound, requiring the generic `T` to implement the `Display` trait. These trait bounds add a level of control and safety over the types that are passed as parameters, opening the possibility for a higher level of abstraction and code reuse. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/105-traits-generics/102-advanced-generics.md b/src/data/roadmaps/rust/content/105-traits-generics/102-advanced-generics.md index ac45872d5..201a81a26 100644 --- a/src/data/roadmaps/rust/content/105-traits-generics/102-advanced-generics.md +++ b/src/data/roadmaps/rust/content/105-traits-generics/102-advanced-generics.md @@ -1 +1,3 @@ -# Advanced generics \ No newline at end of file +# Advanced Generics and Type-level Programming + +Advanced generics in Rust offer a powerful set of tools for creating reusable and efficient code. The `where` syntax in generics can be used to specify trait and lifetime bounds, creating a more expressive declaration and avoiding numerous `T: Trait` inline annotations. Additionally, the `` syntax allows for using dynamically sized types in generics. Advanced generics also allow for defining methods that apply to a subset of variations of generic types using an associated type. Furthermore, this allows for operator overloading through the use of associated types in traits, enhancing flexibility while retaining strong typing. Another advanced use of generics is 'higher kinded types', allowing a type constructor to take another type constructor as a parameter. This is the system Rust uses for handling `Option`, `Result`, and other similar types. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/105-traits-generics/index.md b/src/data/roadmaps/rust/content/105-traits-generics/index.md index e64f03099..10ac6391f 100644 --- a/src/data/roadmaps/rust/content/105-traits-generics/index.md +++ b/src/data/roadmaps/rust/content/105-traits-generics/index.md @@ -1 +1,3 @@ -# Traits generics \ No newline at end of file +# Traits and Generics + +Traits generics are a notable feature in Rust that pertain to defining shared behavior across data types. With them, you can specify placeholder types in trait definitions, letting you abstract over a range of possibilities. They're a means for defining shared behavior -- abstracting over functionality that types can have in common. You can apply traits to generics to constrain the types passed to the generic, hence permitting trait methods to be called on those types. You identify a generic parameter's type by the trait it implements, making it possible to use generic types in the trait methods. In essence, Rust achieves polymorphism through utilizing traits on generics. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/106-lifetimes-borrow/100-explicit-lifetime.md b/src/data/roadmaps/rust/content/106-lifetimes-borrow/100-explicit-lifetime.md index 753c37428..8461c462b 100644 --- a/src/data/roadmaps/rust/content/106-lifetimes-borrow/100-explicit-lifetime.md +++ b/src/data/roadmaps/rust/content/106-lifetimes-borrow/100-explicit-lifetime.md @@ -1 +1,3 @@ -# Explicit lifetime \ No newline at end of file +# Explicit Lifetime Annotations + +In Rust, lifetimes are explicit and are determined at compile time. An `explicit lifetime` is one where lifetimes are annotated in function signatures. Explicit lifetimes are very important in situations where multiple references exist and Rust's compiler cannot make safe and correct assumptions on its own. They're denoted by a tick mark, followed by a lowercase letter. The most common default names for lifetimes are `'a`, `'b`, `'c`, etc. For example, in a function that borrows two strings, and returns a string, explicit lifetimes are used as: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str`. This allows the compiler to ensure that the references used in your function will remain valid for the entire time they're being used, preventing "dangling references". \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/106-lifetimes-borrow/101-lifetime-elision.md b/src/data/roadmaps/rust/content/106-lifetimes-borrow/101-lifetime-elision.md index 04503560f..0606efcb2 100644 --- a/src/data/roadmaps/rust/content/106-lifetimes-borrow/101-lifetime-elision.md +++ b/src/data/roadmaps/rust/content/106-lifetimes-borrow/101-lifetime-elision.md @@ -1 +1,3 @@ -# Lifetime elision \ No newline at end of file +# Lifetime Elision Rules + +"Lifetime Elision" in Rust is an implicit annotation of lifetimes where the compiler tries to make an educated guess about the appropriate lifetimes. Rust compiler has a few rules that it applies in case of lifetime elision. Basic rules include that each parameter passed by reference gets its own lifetime and if there's exactly one input lifetime, that lifetime is assigned to all output lifetime parameters. The rules become more complex when dealing with methods. In these cases, there's a distinction between "self" and other parameters. With lifetime elision, the Rust compiler eliminates the necessity to specify lifetimes in every situation, producing cleaner and less cluttered code. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/106-lifetimes-borrow/102-covariant.md b/src/data/roadmaps/rust/content/106-lifetimes-borrow/102-covariant.md index 6aba61bc7..42413ca1f 100644 --- a/src/data/roadmaps/rust/content/106-lifetimes-borrow/102-covariant.md +++ b/src/data/roadmaps/rust/content/106-lifetimes-borrow/102-covariant.md @@ -1 +1,3 @@ -# Covariant \ No newline at end of file +# Covariant and Contravariant Lifetimes + +In Rust, lifetime, type, and function parameter types can be covariant, invariant, or contravariant. Specifically, covariant describes the relationship between a complex type and a simpler type when the simpler type varies. Covariant occurs when the ordering of types is preserved, i.e., changing a type T to a subtype T' in a complex type C, changes the complex type to a subtype C. In simpler terms, if type B is a subtype of type A, then a collection of B is a subtype of a collection of A, providing the collection type is covariant. This applies to `&T`, `*const T`, `Box`, `[T]`, `[T; n]`, and `T` when they are function return types in Rust. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/106-lifetimes-borrow/index.md b/src/data/roadmaps/rust/content/106-lifetimes-borrow/index.md index ebe7887a2..4da513227 100644 --- a/src/data/roadmaps/rust/content/106-lifetimes-borrow/index.md +++ b/src/data/roadmaps/rust/content/106-lifetimes-borrow/index.md @@ -1 +1,3 @@ -# Lifetimes borrow \ No newline at end of file +# Lifetimes and Borrow Checker + +In Rust, the concept of "lifetimes" is associated with borrowed references. A lifetime is a scope for which that reference is valid. The Rust compiler uses lifetimes to ensure those references are always valid. That is, the referenced object will not get destroyed while references to that object exist. When you are explicitly working with lifetimes in Rust, you are usually dealing with functions that accept references. Rust requires you to annotate the lifetimes when a function has one or more arguments of the borrowed reference type. The annotation is done using a set of angle brackets (<>), and inside these brackets, you declare your lifetime parameters, prefixed with an apostrophe ('). The Rust compiler uses these annotations to reason about how those references relate, and whether they are valid or not. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/107-macros/100-declarative.md b/src/data/roadmaps/rust/content/107-macros/100-declarative.md index 67bd89656..a54e9bcac 100644 --- a/src/data/roadmaps/rust/content/107-macros/100-declarative.md +++ b/src/data/roadmaps/rust/content/107-macros/100-declarative.md @@ -1 +1,3 @@ -# Declarative \ No newline at end of file +# Declarative Macros with macro_rules! + +Rust supports two types of macros, one of which is known as "declarative macros" (or simply `macro_rules!`). Declarative macros in Rust allow you to define reusable chunks of code that have some variable parts, without having to write a full function or type out the same code every time. They work a lot like functions, except they operate at the syntax level rather than the semantics. The compiler expands declarative macros at compile-time, in essence, taking the code they define and “pasting” it directly into your source code. They are defined using the `macro_rules!` keyword, followed by a name and a block of code. The name is used to invoke the macro later in your code, and the block of code is the code that will get inserted every time the macro is used. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/107-macros/101-procedural.md b/src/data/roadmaps/rust/content/107-macros/101-procedural.md index 92bd147e5..a59f2f718 100644 --- a/src/data/roadmaps/rust/content/107-macros/101-procedural.md +++ b/src/data/roadmaps/rust/content/107-macros/101-procedural.md @@ -1 +1,3 @@ -# Procedural \ No newline at end of file +# Procedural Macros and Custom Derive + +Procedural macros in Rust allow you to define functions, or procedures, that operate on code at compile time. The input to these macros is a stream of tokens from the program text, and the output is a new stream of tokens that replace the macro invocation. They are defined in their own crates with a special crate type. There are three kinds of procedural macros: custom derive, attribute-like macros, and function-like macros. Custom derive macros let you define new behavior for the `derive` attribute. Attribute-like macros are invoked as item attributes, for example `#[foo(…)]`, and can be applied to any item that accepts attributes. Function-like macros look like function calls, but work with arbitrary tokens as input. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/107-macros/102-domain-specific.md b/src/data/roadmaps/rust/content/107-macros/102-domain-specific.md index 9946bc661..2b2ab723f 100644 --- a/src/data/roadmaps/rust/content/107-macros/102-domain-specific.md +++ b/src/data/roadmaps/rust/content/107-macros/102-domain-specific.md @@ -1 +1,3 @@ -# Domain specific \ No newline at end of file +# Domain-Specific Languages (DSLs) in Rust + +Domain Specific Languages (DSLs) are programming languages tailored to solve specific problems or tasks in an efficient manner. They are narrower in application than general-purpose languages because they are optimized for a specific domain or task. In Rust, Macros can be used to create DSLs due to their ability to define reusable syntax patterns and to effectively manipulate Rust syntax trees. This ability has led to a variety of domain-specific languages based on Rust macros, with applications ranging from game development to web application programming. Macros essentially allow Rust programmers to extend the language in ways that are tailor-made for their specific project or domain, hence creating domain-specific languages. diff --git a/src/data/roadmaps/rust/content/107-macros/index.md b/src/data/roadmaps/rust/content/107-macros/index.md index a0715688a..b4256e61f 100644 --- a/src/data/roadmaps/rust/content/107-macros/index.md +++ b/src/data/roadmaps/rust/content/107-macros/index.md @@ -1 +1,3 @@ -# Macros \ No newline at end of file +# Macros and Metaprogramming + +Macros in Rust are a way to define reusable chunks of code. They're similar to functions in that they can accept input and produce output, but macros have a few key differences and advantages. With macros, you can write code that writes other code, which is known as metaprogramming. In comparison to functions, macros are more flexible and can accept a variety of different inputs. Macros are defined using the `macro_rules!` keyword and they use a different syntax than regular Rust functions. When you define a macro, you specify the code that should be inserted at compile time. The compiler then replaces all calls to the macro with the expanded macro code. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/108-web-development/100-rocket.md b/src/data/roadmaps/rust/content/108-web-development/100-rocket.md index cee222efd..358ac8910 100644 --- a/src/data/roadmaps/rust/content/108-web-development/100-rocket.md +++ b/src/data/roadmaps/rust/content/108-web-development/100-rocket.md @@ -1 +1,3 @@ -# Rocket \ No newline at end of file +# Rocket + +"Rocket" is a web framework for the Rust programming language that makes it simple to write fast, secure web applications without sacrificing flexibility, usability, or type safety. It provides a significant amount of functionality out-of-the-box, such as request routing, template rendering, form validation, and more. Rocket's philosophy revolves around usability and intuitiveness; it emphasizes clear and expressive syntax, detailed error messages, and powerful abstractions. Despite these aids, Rocket doesn't shield you from the complexities of web programming, but instead offers tools and interfaces to make these complexities manageable. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/108-web-development/101-warp.md b/src/data/roadmaps/rust/content/108-web-development/101-warp.md index dbf9f8732..81da974ff 100644 --- a/src/data/roadmaps/rust/content/108-web-development/101-warp.md +++ b/src/data/roadmaps/rust/content/108-web-development/101-warp.md @@ -1 +1,3 @@ -# Warp \ No newline at end of file +# Warp + +Warp is a web server framework for Rust that focuses on composability and safety. It's built on top of `hyper`, a low-level HTTP library, but Warp adds a user-friendly layer on top of that, allowing developers to build custom routing logic with ease. Warp's primary concept is the "Filter", which can be combined and nested to create complex HTTP servers. Despite this abstraction, it manages to maintain a high level of performance thanks to Rust's zero-cost abstractions. Another feature of Warp is its capability to handle websockets, streaming bodies, and multipart forms. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/108-web-development/102-actix.md b/src/data/roadmaps/rust/content/108-web-development/102-actix.md index f44c135ca..8bb9ad8e8 100644 --- a/src/data/roadmaps/rust/content/108-web-development/102-actix.md +++ b/src/data/roadmaps/rust/content/108-web-development/102-actix.md @@ -1 +1,3 @@ -# Actix \ No newline at end of file +# Actix + +Actix is a powerful, pragmatic, and extremely fast web framework for Rust. It is based on Actix actor's framework, built around a small and simple API focused on making the creation of web applications straightforward and efficient. Its capable middleware system allows for highly customizable processing of web requests, making it versatile for a wide range of web development tasks. With support for WebSockets and server-sent events included, integration of real-time communication is quite seamless in Actix. Despite its high-level abstractions and ease of use, Actix does not compromise on performance, delivering some of the fastest processing times among Rust web frameworks. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/108-web-development/103-yew.md b/src/data/roadmaps/rust/content/108-web-development/103-yew.md index c562188c1..3e6baee24 100644 --- a/src/data/roadmaps/rust/content/108-web-development/103-yew.md +++ b/src/data/roadmaps/rust/content/108-web-development/103-yew.md @@ -1 +1,3 @@ -# Yew \ No newline at end of file +# Yew + +"Yew" is a modern Rust framework for creating multi-threaded front-end web apps with WebAssembly. It features a component-based framework similar to React and Elm, and supports JavaScript interoperability, allowing the execution of JS code from Rust and vice versa. Yew is able to tap into Rust's powerful ecosystem, providing high-speed rendering and packing a punch when it comes to building rich, high-performing user experiences on the web. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/108-web-development/index.md b/src/data/roadmaps/rust/content/108-web-development/index.md index c595dc39b..f9cc5e3a7 100644 --- a/src/data/roadmaps/rust/content/108-web-development/index.md +++ b/src/data/roadmaps/rust/content/108-web-development/index.md @@ -1 +1,3 @@ -# Web development \ No newline at end of file +# Web Development + +Web Development in Rust is a growing field, given the programming language's emphasis on safety and performance. In Rust, web development may involve using frameworks like Rocket, Actix or Tide to build web applications. There are also powerful web servers like Hyper that are built in Rust. Building web applications in Rust can involve facilitating client-server communication, handling HTTP requests, building routing systems, and managing databases among the other general tasks associated with web development. The Rust ecosystem provides tools to manage all these tasks and more. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/109-async-programming/100-tokio.md b/src/data/roadmaps/rust/content/109-async-programming/100-tokio.md index 507d29732..f5d606dce 100644 --- a/src/data/roadmaps/rust/content/109-async-programming/100-tokio.md +++ b/src/data/roadmaps/rust/content/109-async-programming/100-tokio.md @@ -1 +1,3 @@ -# Tokio \ No newline at end of file +# Tokio + +Tokio, a Rust framework for developing applications, is used primarily for asynchronous programming that enables you to write asynchronous inputs/output, networking, and other features. Its primary function is to deliver high-performance, reliable, and easy-to-use asynchronous event-driven platform. It is built on the futures library and uses the async/await syntax of Rust for readability purposes. Tokio's 'runtime' provides I/O driver functions, scheduling and timers offering a foundation for asynchronous programming. It is designed to handle a high volume of network connections concurrently, making it ideal for building network applications. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/109-async-programming/101-async-std.md b/src/data/roadmaps/rust/content/109-async-programming/101-async-std.md index bb1889c01..bf650c9a1 100644 --- a/src/data/roadmaps/rust/content/109-async-programming/101-async-std.md +++ b/src/data/roadmaps/rust/content/109-async-programming/101-async-std.md @@ -1 +1,3 @@ -# Async std \ No newline at end of file +# async-std + +`async-std` is a Rust library that provides an asynchronous version of the standard library. With the goal of being a drop-in replacement for Rust's standard library, it brings asynchronous programming directly into Rust's native system library, std. The most essential part inside `async-std` is an asynchronous runtime which includes IO and task scheduling. It lets you write asynchronous code that looks like synchronous code without having to worry about using future combinators or remembering to check if futures are ready. This significantly simplifies Rust's asynchronous programming model. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/109-async-programming/102-smol.md b/src/data/roadmaps/rust/content/109-async-programming/102-smol.md index b43cf0195..7d126fc6c 100644 --- a/src/data/roadmaps/rust/content/109-async-programming/102-smol.md +++ b/src/data/roadmaps/rust/content/109-async-programming/102-smol.md @@ -1 +1,3 @@ -# Smol \ No newline at end of file +# smol + +`smol` is a small, fast, and modern async runtime for Rust programming language. It is built on top of async-std and tokio. With very few lines of code, it allows users to perform tasks such as creating async functions, waiting on a future, creating a timer, among others. Although it is feature-rich, smol keeps its API minimal and clean, making it the go-to choice for many developers working with Rust. It supports async/.await natively and is highly efficient due to its superior scheduling capabilities. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/109-async-programming/index.md b/src/data/roadmaps/rust/content/109-async-programming/index.md index f50cda975..d1337054a 100644 --- a/src/data/roadmaps/rust/content/109-async-programming/index.md +++ b/src/data/roadmaps/rust/content/109-async-programming/index.md @@ -1 +1,3 @@ -# Async programming \ No newline at end of file +# Asynchronous Programming + +Async programming, short for asynchronous programming, in Rust allows the execution of tasks concurrently instead of sequentially. This means that you don't have to wait for a function to complete all its tasks before another function starts executing. As Rust is a systems programming language and is quite close to the hardware, async programming can provide efficient usage of resources, especially in IO-heavy applications. To facilitate async programming, `async` and `await` were introduced into Rust. `async` annotifies a function is asynchronous and can return `Future`, while `await` is used to pause and resume an `async` function. To manage tasks efficiently, Rust also provides async runtimes such as Tokio and async-std. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/110-networking/100-reqwest.md b/src/data/roadmaps/rust/content/110-networking/100-reqwest.md index 1ff018e89..59174086e 100644 --- a/src/data/roadmaps/rust/content/110-networking/100-reqwest.md +++ b/src/data/roadmaps/rust/content/110-networking/100-reqwest.md @@ -1 +1,3 @@ -# Reqwest \ No newline at end of file +# reqwest + +`Reqwest` is a Rust library which is designed to make HTTP requests easy and effortless. It offers a mix of convenience methods for both synchronous and asynchronous requests,GET,POST and other HTTP methods. It also supports JSON content and is built on `hyper` for HTTP and `tokio` for asynchronous I/O. This means you can take advantage of the powerful asynchronous features of Rust such as Futures and async/await. Furthermore, `Reqwest` takes care of many tedious aspects of HTTP for you, such as handling cookies and encoding/decoding different formats. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/110-networking/101-hyper.md b/src/data/roadmaps/rust/content/110-networking/101-hyper.md index 70b021a9b..f456bc8dd 100644 --- a/src/data/roadmaps/rust/content/110-networking/101-hyper.md +++ b/src/data/roadmaps/rust/content/110-networking/101-hyper.md @@ -1 +1,3 @@ -# Hyper \ No newline at end of file +# hyper + +"Hyper" is a fast, safe and concurrent HTTP client and server written in Rust. It uses a non-blocking I/O model for efficient execution, leverages the Tokio platform for event-driven, asynchronous I/O, and includes support for HTTP/2. It has a modular design, allowing you to choose the features you need. Hyper also features a server-side framework for building your own HTTP applications. For security and speed, it comes with native support for HTTP/1 and HTTP/2, and automatically negotiates these protocols. Most importantly, it is designed from the ground up to take advantage of Rust's memory safety and concurrency features. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/110-networking/102-quinn.md b/src/data/roadmaps/rust/content/110-networking/102-quinn.md index 835f61c96..d35993e2e 100644 --- a/src/data/roadmaps/rust/content/110-networking/102-quinn.md +++ b/src/data/roadmaps/rust/content/110-networking/102-quinn.md @@ -1 +1,3 @@ -# Quinn \ No newline at end of file +# quinn + +`Quinn` is a Rust networking library providing high-level access to the QUIC protocol. It is built on top of the `tokio` runtime and implements the QUIC transport protocol as specified by the IETF. It provides an async, futures-based API for working with QUIC connections and streams. It is designed to offer high performance with robustness and flexibility, supporting both client and server roles. The QUIC protocol itself is a multiplexed and secure transport protocol positioned as a modern alternative to TCP, offering better performance for many networking applications. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/110-networking/index.md b/src/data/roadmaps/rust/content/110-networking/index.md index e159d196c..264573fd1 100644 --- a/src/data/roadmaps/rust/content/110-networking/index.md +++ b/src/data/roadmaps/rust/content/110-networking/index.md @@ -1 +1,3 @@ -# Networking \ No newline at end of file +# Networking + +In Rust, the `std::net` module provides functionality for networking. This includes types that represent IP addresses (`Ipv4Addr` and `Ipv6Addr`), a socket address (`SocketAddr`), and TCP/UDP networking types (`TcpStream`, `TcpListener`, `UdpSocket`). There's also the `TcpStream` type for connection-oriented sockets, `TcpListener` for a TCP socket that's listening for incoming connections, and `UdpSocket` for connection-less sockets. Rust’s networking interface is built around BSD sockets with methods that closely follow the system's system calls. The types in this module encompass low-level network primitives, which can be used to build networking applications. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/111-serialization/100-serde.md b/src/data/roadmaps/rust/content/111-serialization/100-serde.md index fd1216ae8..2aa208354 100644 --- a/src/data/roadmaps/rust/content/111-serialization/100-serde.md +++ b/src/data/roadmaps/rust/content/111-serialization/100-serde.md @@ -1 +1,3 @@ -# Serde \ No newline at end of file +# Serde + +"Serde" is a framework in Rust that enables the serialization and deserialization of data structures. It provides a way to convert your data structures from Rust into a format that can be stored or sent over the network, and vice versa, in a flexible and straightforward manner. Despite its convenience, Serde avoids compromising on speed, and it is super-efficient. The library supports a variety of data formats, like JSON, Bincode, TOML, YAML, and more. Serde's design allows you to customize serialization and deserialization in intricate ways if the default behavior doesn't suit your application's needs. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/111-serialization/101-json-rust.md b/src/data/roadmaps/rust/content/111-serialization/101-json-rust.md index 027e72240..32f20eb7c 100644 --- a/src/data/roadmaps/rust/content/111-serialization/101-json-rust.md +++ b/src/data/roadmaps/rust/content/111-serialization/101-json-rust.md @@ -1 +1,3 @@ -# Json rust \ No newline at end of file +# json-rust + +`JSON` (JavaScript Object Notation) is a lightweight data-interchange format that is used to store and exchange data. In `Rust`, you can work with `JSON` data using the `serde` and `serde_json` libraries. The `serde` library provides a way for high-performance serialization, and `serde_json` is a `serde` format for handling `JSON` data. The library provides mechanisms for converting between `Rust` data structures and `JSON`. This includes the ability to parse `JSON` data from strings or files, serialize `Rust` data structures to `JSON`, and manipulate `JSON` values directly. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/111-serialization/102-toml-rs.md b/src/data/roadmaps/rust/content/111-serialization/102-toml-rs.md index 810b81eb7..c9e217c05 100644 --- a/src/data/roadmaps/rust/content/111-serialization/102-toml-rs.md +++ b/src/data/roadmaps/rust/content/111-serialization/102-toml-rs.md @@ -1 +1,3 @@ -# Toml rs \ No newline at end of file +# toml-rs + +`toml-rs` is a library in Rust designed to parse and serialize TOML documents. TOML, which stands for Tom's Obvious, Minimal Language, is a straightforward and easy-to-read format often used for configuration files. The `toml-rs` library provides functionalities to convert between TOML documents and Rust structures. It heavily uses Rust's powerful trait system and type inference, to parse a TOML document into Rust's static types for further manipulation. Moreover, by making use of the 'serde' library, it enables automatic serialization and deserialization between TOML and Rust types. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/111-serialization/index.md b/src/data/roadmaps/rust/content/111-serialization/index.md index db5ec04c5..d1f0f3b3a 100644 --- a/src/data/roadmaps/rust/content/111-serialization/index.md +++ b/src/data/roadmaps/rust/content/111-serialization/index.md @@ -1 +1,3 @@ -# Serialization \ No newline at end of file +# Serialization/Deserialization + +Serialization in Rust refers to the process of converting complex data types into a byte stream for transport over a network, storing in a file, or simply for use in a program. It provides a mechanism to maintain the state of an object by saving and restoring its state. To accomplish this, Rust has two prevalent crates known as `serde` and `bincode`. `Serde` is a robust framework for serializing and deserializing data, and `bincode` is one example of a serializer/deserializer that Serde can use. With Serde, we can develop efficient, compact, and customizable representations of Rust data structures. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/112-database-orm/100-diesel.md b/src/data/roadmaps/rust/content/112-database-orm/100-diesel.md index 235d510a5..d77e95d88 100644 --- a/src/data/roadmaps/rust/content/112-database-orm/100-diesel.md +++ b/src/data/roadmaps/rust/content/112-database-orm/100-diesel.md @@ -1 +1,3 @@ -# Diesel \ No newline at end of file +# Diesel + +Diesel is a safe, extensible ORM (Object-Relational Mapping) and query builder for Rust. Diesel is designed to help you move between database schema, SQL queries, and your data in your application with safety and ease. It provides a high-level API and avoids the need to manage database connections manually. It simplifies SQL interfacing, ensuring type safety and connection handling right from the box. Diesel supports PostgreSQL, SQLite, and MySQL databases. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/112-database-orm/101-sqlx.md b/src/data/roadmaps/rust/content/112-database-orm/101-sqlx.md index 6c1cbb83e..26f2518ce 100644 --- a/src/data/roadmaps/rust/content/112-database-orm/101-sqlx.md +++ b/src/data/roadmaps/rust/content/112-database-orm/101-sqlx.md @@ -1 +1,3 @@ -# Sqlx \ No newline at end of file +# sqlx + +`SQLx` is an extensible, async, pure-Rust SQL toolkit and ORM that provides a suite of macros and builders for interacting with databases. It enables you to interact directly with your database without having to write SQL-statements, but with the strong typing of Rust. SQLx supports PostgreSQL, MySQL, SQLite, and MSSQL and is compatible with the `tokio` and `async-std` async runtimes. SQLx ensures compile-time checking of your SQL queries, which significantly reduces runtime errors due to malformed SQL. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/112-database-orm/102-rusqlite.md b/src/data/roadmaps/rust/content/112-database-orm/102-rusqlite.md index 4437df7f0..e45cab8ce 100644 --- a/src/data/roadmaps/rust/content/112-database-orm/102-rusqlite.md +++ b/src/data/roadmaps/rust/content/112-database-orm/102-rusqlite.md @@ -1 +1,3 @@ -# Rusqlite \ No newline at end of file +# rusqlite + +`rusqlite` is a simple and ergonomic library for interacting with SQLite databases in Rust. It is designed to be uncomplicated and easy to fit into existing Rust software. With `rusqlite`, you can execute efficient high-level database operations with minimal SQL knowledge or effort. Built around the `sqlite3` C library, it offers a comprehensive API for executing queries and retrieving results. `rusqlite` also integrates seamlessly with the `serde` crate, allowing for easy, type-safe bidirectional mapping between SQL and Rust data structures. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/112-database-orm/index.md b/src/data/roadmaps/rust/content/112-database-orm/index.md index 0727245a9..9e06be695 100644 --- a/src/data/roadmaps/rust/content/112-database-orm/index.md +++ b/src/data/roadmaps/rust/content/112-database-orm/index.md @@ -1 +1,3 @@ -# Database orm \ No newline at end of file +# Database and ORM + +ORM stands for Object-Relational Mapping. It's a programming technique used to convert data between incompatible type systems using object-oriented programming languages. In Rust, the database ORM provides an abstraction for dealing with SQL queries, where you don't need to write raw SQL queries. Instead, you can create, delete and manipulate database records using Rust's interface. It transforms data from a relational database model (tables, rows, and columns) into objects that can be used in code. Important database ORMs in Rust include Diesel, sqlx, and others. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/113-cryptography/100-ring.md b/src/data/roadmaps/rust/content/113-cryptography/100-ring.md index a324767fa..1dd89cd89 100644 --- a/src/data/roadmaps/rust/content/113-cryptography/100-ring.md +++ b/src/data/roadmaps/rust/content/113-cryptography/100-ring.md @@ -1 +1,3 @@ -# Ring \ No newline at end of file +# ring + +`Ring` is a popular cryptography library in Rust providing a safe, fast and easy-to-use platform for handling a broad range of cryptographic operations. The library supports a variety of cryptographic primitives, including RSA, AES, SHA, and many others. `Ring` is focused on the implementation of TLS protocol and cryptographic algorithm fundamentals, hence it doesn't include functionalities like parsing or serialization. This library excels in eliminating many common pitfalls of crypto usage by asserting on compile-time and runtime checks. One key feature is its limitation to safe, reviewed cryptographic algorithms, which enables it to help prevent accidental usage of insecure ones. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/113-cryptography/101-rust-crypto.md b/src/data/roadmaps/rust/content/113-cryptography/101-rust-crypto.md index 76d11e1ee..d490ec8eb 100644 --- a/src/data/roadmaps/rust/content/113-cryptography/101-rust-crypto.md +++ b/src/data/roadmaps/rust/content/113-cryptography/101-rust-crypto.md @@ -1 +1,3 @@ -# Rust crypto \ No newline at end of file +# rust-crypto + +`Rust Crypto` is a set of cryptographic algorithms implemented in the Rust programming language. Users can utilize these algorithms for encryption, decryption, hashing, and digital signature applications, among others. Notable features in Rust Crypto include ciphers like AES and DES, hash functions like SHA and MD5, and digital signatures such as RSA. It is recognized for its speed and low memory usage, thus making it a suitable option for systems with limited resources. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/113-cryptography/102-sodiumoxide.md b/src/data/roadmaps/rust/content/113-cryptography/102-sodiumoxide.md index 0bf915896..86d679b3f 100644 --- a/src/data/roadmaps/rust/content/113-cryptography/102-sodiumoxide.md +++ b/src/data/roadmaps/rust/content/113-cryptography/102-sodiumoxide.md @@ -1 +1,3 @@ -# Sodiumoxide \ No newline at end of file +# sodiumoxide + +"Sodiumoxide" is a Rust binding to the networking and cryptography library, libsodium. It is designed to be easy to use and difficult to misuse. Sodiumoxide follows the design of NaCl for simplicity while allowing the performance benefits of libsodium. It provides cryptographic primitives in a safe, high-level, idiomatic Rust wrapper. It attempts to handle all possible errors, eliminating the possibility of a misuse, a significant advantage over using libsodium directly. Overall, sodiumoxide aims to make high-level cryptographic operations accessible without sacrificing safety or performance. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/113-cryptography/index.md b/src/data/roadmaps/rust/content/113-cryptography/index.md index c0bf98cfb..6b8b97d95 100644 --- a/src/data/roadmaps/rust/content/113-cryptography/index.md +++ b/src/data/roadmaps/rust/content/113-cryptography/index.md @@ -1 +1,3 @@ -# Cryptography \ No newline at end of file +# Cryptography + +Cryptography is a method of storing and transmitting data in a particular form so that only those for whom it is intended can read and process it. This practice is widely used in securing modern communications and protecting data from theft or tampering. It bases itself on the fundamentals of mathematics to transform data into a format that is unreadable without a key. In its simplest form, it involves just two steps: encryption and decryption. Encryption is the process of converting readable data into an unreadable format using an algorithm and a key. Decryption is the reverse of encryption; it turns the unreadable data back into its original form with the use of the matching key. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/114-cli-utils/100-clap.md b/src/data/roadmaps/rust/content/114-cli-utils/100-clap.md index 48b305166..be2cae9b4 100644 --- a/src/data/roadmaps/rust/content/114-cli-utils/100-clap.md +++ b/src/data/roadmaps/rust/content/114-cli-utils/100-clap.md @@ -1 +1,3 @@ -# Clap \ No newline at end of file +# clap + +`clap` is a command line argument parser for Rust. It is used for managing and parsing command line arguments and subcommands for your application. `clap` allows you to set the name, version, author, about info, and other global settings of your application. It also supports auto-generated help messages, custom errors, and is unicode compatible. It is very flexible and highly configurable and allows you to extract the needed values easily with the provided methods. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/114-cli-utils/101-structopt.md b/src/data/roadmaps/rust/content/114-cli-utils/101-structopt.md index bf4de931f..05701ceeb 100644 --- a/src/data/roadmaps/rust/content/114-cli-utils/101-structopt.md +++ b/src/data/roadmaps/rust/content/114-cli-utils/101-structopt.md @@ -1 +1,3 @@ -# Structopt \ No newline at end of file +# structopt + +`StructOpt` is a third-party library in Rust designed to parse command-line arguments by defining a struct. It brings together the capabilities of `clap` for command-line parsing with Rust's powerful type system. With `StructOpt`, you can define a struct for your command-line program where each field represents a flag, switch, option, or positional argument. This allows a highly declarative and expressive means of handling command-line inputs, including automatic help message generation, strongly-typed values, default values, validators, and more. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/114-cli-utils/102-termion.md b/src/data/roadmaps/rust/content/114-cli-utils/102-termion.md index 3f03a1d2b..2634429bc 100644 --- a/src/data/roadmaps/rust/content/114-cli-utils/102-termion.md +++ b/src/data/roadmaps/rust/content/114-cli-utils/102-termion.md @@ -1 +1,3 @@ -# Termion \ No newline at end of file +# termion + +`Termion` is a pure Rust, bindless library for low-level handling, manipulating and reading information about terminals. This provides a full-featured solution for cross-terminal compatibility, allowing for features such as color support, input handling, and other terminal specific features. It's completely independent and does not require any third-party libraries or bindings in C, C++ or any other language. As such, `Termion` simplifies the process of writing cross-platform CLI applications or utilities in Rust, while maintaining a lean, zero-dependency codebase. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/114-cli-utils/index.md b/src/data/roadmaps/rust/content/114-cli-utils/index.md index 3e14cd07a..98127910c 100644 --- a/src/data/roadmaps/rust/content/114-cli-utils/index.md +++ b/src/data/roadmaps/rust/content/114-cli-utils/index.md @@ -1 +1,3 @@ -# Cli utils \ No newline at end of file +# CLI Utilities + +"CLI Utils" in Rust refers to command-line interface utilities. These are tools or programs that allow users to interact with their computer's operating system via command lines, as opposed to graphical user interfaces (GUI). A CLI utility operates based on commands given by the user. In Rust, packages like clap and structopt are typically used to build such CLI tools, thanks to their capability to parse command line arguments. They provide methods to define what arguments a program accepts, handle incorrect input, generate help messages, and more - all things that make a CLI utility very useful and efficient. Rust's efficient memory management and speed make it a popular choice to build fast and reliable CLI utilities. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/115-game-dev/100-bevy.md b/src/data/roadmaps/rust/content/115-game-dev/100-bevy.md index ee01141e0..8cd53122f 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/100-bevy.md +++ b/src/data/roadmaps/rust/content/115-game-dev/100-bevy.md @@ -1 +1,3 @@ -# Bevy \ No newline at end of file +# bevy + +Bevy is a simple, data-driven game engine built in Rust. It emphasizes high performance with its ECS (Entity Component System) architecture and provides the tools needed to build immersive interactive real-time systems. With modern design principles, Bevy enables developers to create rich interactive systems without complex boilerplate. In addition, Bevy provides flexibility with its modular and extensible structure capable of supporting a wide range of different types of games and multimedia applications. It also allows users to build both 2D and 3D games with support for custom shaders and materials. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/115-game-dev/101-fyrox.md b/src/data/roadmaps/rust/content/115-game-dev/101-fyrox.md index c6623bc30..60e3ad68a 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/101-fyrox.md +++ b/src/data/roadmaps/rust/content/115-game-dev/101-fyrox.md @@ -1 +1,3 @@ -# Fyrox \ No newline at end of file +# fyrox + +"Fyrox" is a modern, lightweight, highly optimized and fast 3D game engine specifically designed for Rust. Leveraging the safety and concurrency inherent in Rust lang, it offers a high level of performance and reliability in game development. Its lower level of abstraction allows more direct control over the hardware, making it more suitable for performance-critical parts of a game. These aspects combined with a robust feature set, such as support for common 3D formats and advanced lighting and shadowing techniques, make Fyrox an ideal choice for developing games in Rust. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/115-game-dev/102-ggez.md b/src/data/roadmaps/rust/content/115-game-dev/102-ggez.md index 6e7ea312f..4499b255b 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/102-ggez.md +++ b/src/data/roadmaps/rust/content/115-game-dev/102-ggez.md @@ -1 +1,3 @@ -# Ggez \ No newline at end of file +# ggez + +`ggez` is a lightweight game framework for making 2D games using Rust programming language. It provides various facilities to make game development easier, such as drawing graphics, handling user input, manipulating audio, and handling game timing. It is inspired by libraries like Love2D and aims to present an easy and Rusty interface to the underlying Web platform. With `ggez`, developers can focus more on their game logic without worrying too much about the behind-the-scenes details. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/115-game-dev/103-macroquad.md b/src/data/roadmaps/rust/content/115-game-dev/103-macroquad.md index f2feb6612..645647439 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/103-macroquad.md +++ b/src/data/roadmaps/rust/content/115-game-dev/103-macroquad.md @@ -1 +1,3 @@ -# Macroquad \ No newline at end of file +# macroquad + +Macroquad is a Rust library that offers a festive and straightforward way to prototype and develop games quickly. It is an ultra-efficient and flexible cross-platform game engine that specializes in 2D game development. Macroquad features a 2D rendering engine driven by the powerful metal-based miniquad, and includes support for inputs, random number generation, coroutine-based async programming, and sound. It is also portable across various platforms such as Windows, MacOS, Linux, WebAssembly, Android, and iOS. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/115-game-dev/104-wgpu-rs.md b/src/data/roadmaps/rust/content/115-game-dev/104-wgpu-rs.md index 0d2a84492..dc468980e 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/104-wgpu-rs.md +++ b/src/data/roadmaps/rust/content/115-game-dev/104-wgpu-rs.md @@ -1 +1,3 @@ -# Wgpu rs \ No newline at end of file +# wgpu-rs + +`wgpu-rs` is a Rust project designed to make graphics programming more accessible for the Rust language. It is a library that allows users to easily interact with the graphic hardware in their system in a safe and comfortable way. The library provides a high-level, idiomatic and convenient abstraction over wgpu-core while still allowing low-level direct control over the underlying API. Through this, it provides a unified way to access graphics and computing functionality across various backends including Vulkan, Metal, DirectX, and browser WebGPU. diff --git a/src/data/roadmaps/rust/content/115-game-dev/index.md b/src/data/roadmaps/rust/content/115-game-dev/index.md index bd9de713a..e02cc3640 100644 --- a/src/data/roadmaps/rust/content/115-game-dev/index.md +++ b/src/data/roadmaps/rust/content/115-game-dev/index.md @@ -1 +1,3 @@ -# Game dev \ No newline at end of file +# Game Development + +"Game development" is the process of designing, programming, and testing a video game. It involves various disciplines such as game design, which covers gameplay and story, arts and animation to ensure aesthetics and appeal, and programming for game interactions and mechanics. Game development can be approached using different tools and languages, and "Rust" has emerged as a powerful option thanks to its performance and safety aspects. It can be used to create both 2D and 3D games, and there are several libraries and frameworks in Rust meant specifically for game development, such as Amethyst and ggez. The process usually involves a game engine where most of the game contents are processed and a renderer where the game's visual representation is produced. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/116-gui-dev/100-druid.md b/src/data/roadmaps/rust/content/116-gui-dev/100-druid.md index 528199a3e..7151bbc50 100644 --- a/src/data/roadmaps/rust/content/116-gui-dev/100-druid.md +++ b/src/data/roadmaps/rust/content/116-gui-dev/100-druid.md @@ -1 +1,3 @@ -# Druid \ No newline at end of file +# druid + +`Druid` is an open-source, data-oriented Rust GUI framework. It is focused on giving users a seamless and robust way of creating GUI interfaces in Rust while also providing them with a high level of control. `Druid` uses a reactive-model similar to `React` but it has its own distinguishing features, as well. `Druid` includes features such as flexbox styling, data binding, and event handling. It provides platform-native look-and-feel by utilizing the platform's own widget. Currently, `Druid` supports various platforms such as Windows, macOS, Linux, and Redox. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/116-gui-dev/101-gtk-rs.md b/src/data/roadmaps/rust/content/116-gui-dev/101-gtk-rs.md index 69820af1e..65e0abe40 100644 --- a/src/data/roadmaps/rust/content/116-gui-dev/101-gtk-rs.md +++ b/src/data/roadmaps/rust/content/116-gui-dev/101-gtk-rs.md @@ -1 +1,3 @@ -# Gtk rs \ No newline at end of file +# gtk-rs + +`gtk-rs` is a group of Rust bindings for GTK+ 3 and other related libraries. This means you can write your GUI applications in Rust language with GTK+3, a cross-platform widget toolkit for creating graphical user interfaces. It includes bindings for GObject, Glib, and Cairo among others. Meanwhile, the number of bindings for different GTK libraries and components is continuously increasing. It's worth noting that gtk-rs projects are a set of open-source libraries dedicated to providing a Rust-friendly interface for GTK libraries (gtk, gdk, gdk-pixbuf, cairo, pango, etc). This allows developers to create software using Rust and GTK simultaneously. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/116-gui-dev/102-relm.md b/src/data/roadmaps/rust/content/116-gui-dev/102-relm.md index ad04f6a33..06cac23f2 100644 --- a/src/data/roadmaps/rust/content/116-gui-dev/102-relm.md +++ b/src/data/roadmaps/rust/content/116-gui-dev/102-relm.md @@ -1 +1,3 @@ -# Relm \ No newline at end of file +# relm + +`relm` is a declarative, event-driven framework for building GUIs in Rust. It is asynchronous and designed to handle complex user interfaces. `relm` uses `gtk-rs`, a wrapper for GTK+3, allowing for the creation of cross-platform GUI applications. Features in `relm` include Widget identification through name instead of Arc>, asynchronicity framework using Futures, and seamless communication between widgets through the Model-View-Update architecture. The main focus of `relm` is to enable the creation of dynamic desktop applications with complex interactions, using the safe concurrency features of Rust. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/116-gui-dev/index.md b/src/data/roadmaps/rust/content/116-gui-dev/index.md index b26697c78..150e17538 100644 --- a/src/data/roadmaps/rust/content/116-gui-dev/index.md +++ b/src/data/roadmaps/rust/content/116-gui-dev/index.md @@ -1 +1,3 @@ -# Gui dev \ No newline at end of file +# GUI Development + +"GUI Dev" or Graphical User Interface Development is a significant aspect of software development which focuses on creating visually engaging and intuitive user interfaces. It includes designing the layout, look, and feel of an application through elements such as buttons, icons, images, input fields, and other widgets. In Rust, GUI Development can be done using numerous libraries like 'conrod', 'druid', or 'iced'. Each of these libraries contains unique ways to deal with user input, event handling, and drawing graphics. Ultimately, good GUI design can lead to an improved user experience by making software easy and enjoyable to interact with. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/117-embedded/100-embedded-hal.md b/src/data/roadmaps/rust/content/117-embedded/100-embedded-hal.md index 9be6aebca..04f1cdd7c 100644 --- a/src/data/roadmaps/rust/content/117-embedded/100-embedded-hal.md +++ b/src/data/roadmaps/rust/content/117-embedded/100-embedded-hal.md @@ -1 +1,3 @@ -# Embedded hal \ No newline at end of file +# embedded-hal + +"Embedded-hal" or "Embedded Hardware Abstraction Layer" is a notably robust and highly accommodating platform for the Rust embedded systems domain. It essentially allows for the creation of portable embedded drivers by providing generic device traits. These traits enable users to write hardware-agnostic code, which translates to enhanced efficiency and code reuse. By abstracting hardware specifics into a uniform API, "embedded hal" facilitates unified handling of different hardware abilities such as digital I/O, UART, I2C, and SPI communication, among others. This categorically makes it an invaluable tool in the Rust embedded space. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/117-embedded/101-rppal.md b/src/data/roadmaps/rust/content/117-embedded/101-rppal.md index 06efcdd8d..6bc109b19 100644 --- a/src/data/roadmaps/rust/content/117-embedded/101-rppal.md +++ b/src/data/roadmaps/rust/content/117-embedded/101-rppal.md @@ -1 +1,3 @@ -# Rppal \ No newline at end of file +# rppal + +`RPPAL` stands for Raspberry Pi Peripheral Access Library. It's a crate for Raspberry Pi that provides access to the GPIO, I2C, PWM, SPI, and UART peripherals. Developed in Rust, it also includes a comprehensive interrupt handling system, software-based PWM, and I2C/SPI buses. The library supports all models of Raspberry Pi that run a variant of Raspbian/Debian Stretch or newer. While it's primarily designed for the Raspberry Pi's official Linux-based Raspbian OS, parts of the library might work with other Linux distributions or operating systems on the Raspberry Pi. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/117-embedded/102-nrf-hal.md b/src/data/roadmaps/rust/content/117-embedded/102-nrf-hal.md index 885cb785e..4cf98eac7 100644 --- a/src/data/roadmaps/rust/content/117-embedded/102-nrf-hal.md +++ b/src/data/roadmaps/rust/content/117-embedded/102-nrf-hal.md @@ -1 +1,3 @@ -# Nrf hal \ No newline at end of file +# nrf-hal + +`nrf-hal` is a Rust Language Peripheral Access Crate for the Nordic Semiconductor nRF52 series and nRF91 series. It provides a high-level interface to the features and functionality available on these chips. It abstracts away the specifics of direct register access and allows for more robust and semantic interaction. It includes supports for GPIO, timers, RNG, RTC, TWIM+TWIS (I2C), SPIM+SPIS(SPI), temperature sensor and delay routines. It's an open-source project under the Apache license which means it's completely free to use and modify. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/117-embedded/index.md b/src/data/roadmaps/rust/content/117-embedded/index.md index 3ca353aef..c6023626a 100644 --- a/src/data/roadmaps/rust/content/117-embedded/index.md +++ b/src/data/roadmaps/rust/content/117-embedded/index.md @@ -1 +1,3 @@ -# Embedded \ No newline at end of file +# Embedded and Systems + +"Embedded" in the world of Rust programming refers to the use of Rust in embedded systems. These are computer systems with a dedicated function within a larger mechanical or electrical system, often with real-time computational constraints. They are used in a wide range of applications from appliances to vehicles to vending machines and all sorts of industrial applications. Rust's zero-cost abstractions, high-level ergonomics, and low-level control make it an excellent language to use for embedded systems. By using Rust, developers can write extremely low-level code, such as operating system kernels or microcontroller applications. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/118-wasm/100-wasm-bindgen.md b/src/data/roadmaps/rust/content/118-wasm/100-wasm-bindgen.md index 449f47c48..b26e26152 100644 --- a/src/data/roadmaps/rust/content/118-wasm/100-wasm-bindgen.md +++ b/src/data/roadmaps/rust/content/118-wasm/100-wasm-bindgen.md @@ -1 +1,3 @@ -# Wasm bindgen \ No newline at end of file +# wasm-bindgen + +`wasm-bindgen` is a library and command line tool designed to facilitate high-level interactions between Rust and JavaScript. It provides a seamless way for the two languages to communicate with each other, permitting the call of JavaScript APIs directly from Rust and vice versa. `wasm-bindgen` achieves this by generating an interoperability layer that 'translates' between the semantics of JavaScript and Rust. It handles differences in memory representations and call semantics for complex data types, such as strings and objects, allowing developers to focus on implementing their applications without worrying about the low-level details. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/118-wasm/101-wasm-pack.md b/src/data/roadmaps/rust/content/118-wasm/101-wasm-pack.md index a75302408..847fe9830 100644 --- a/src/data/roadmaps/rust/content/118-wasm/101-wasm-pack.md +++ b/src/data/roadmaps/rust/content/118-wasm/101-wasm-pack.md @@ -1 +1,3 @@ -# Wasm pack \ No newline at end of file +# wasm-pack + +`wasm-pack` is a command line tool aimed at assembling and packaging Rust crates that target WebAssembly. It helps to bridge the gap between WebAssembly (written in Rust) and JavaScript. It generates necessary files for publishing a package to `npm`. `wasm-pack` also helps to make sure your rust code is set up correctly to get compiled to `wasm`. The tool aims to seamlessly have packages that work out-of-the-box in most JavaScript environments. `wasm-pack` was designed with a focus on ergonomics, performance, and correctness so as to make a developer's life easier. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/118-wasm/102-wasmer.md b/src/data/roadmaps/rust/content/118-wasm/102-wasmer.md index 45823e529..c3c22de4e 100644 --- a/src/data/roadmaps/rust/content/118-wasm/102-wasmer.md +++ b/src/data/roadmaps/rust/content/118-wasm/102-wasmer.md @@ -1 +1,3 @@ -# Wasmer \ No newline at end of file +# wasmer + +Wasmer is a popular standalone WebAssembly (WASM) runtime that aims to run any WASM file on any platform swiftly. It's designed to be lightweight and simple to use. The project supports features of WASM like linear memory and tables, while also providing a friendly command line interface (CLI). It ships with a pluggable, modular system that allows for different compiling and runtime strategies. Wasmer can be integrated into different programming languages through its embedding API, which enables calling WASM functions directly as pure functions in the host language. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/118-wasm/index.md b/src/data/roadmaps/rust/content/118-wasm/index.md index 7eb1617e6..49c2a3b54 100644 --- a/src/data/roadmaps/rust/content/118-wasm/index.md +++ b/src/data/roadmaps/rust/content/118-wasm/index.md @@ -1 +1,3 @@ -# Wasm \ No newline at end of file +# WebAssembly (WASM) + +"Wasm" or WebAssembly is an open standard binary instruction format. It serves as a compact binary format that aims to execute at near-native speed, providing a performance-efficient compilation target for low-level languages like C, C++, and Rust. Wasm was initially developed for efficient execution in web browsers but is designed to be used in other environments as well. WebAssembly aims to maintain a safe, secure, and platform-independent runtime to perform high-performance applications on the web or on other platforms. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/119-testing/100-unit-integration.md b/src/data/roadmaps/rust/content/119-testing/100-unit-integration.md index 100b41069..92c76594f 100644 --- a/src/data/roadmaps/rust/content/119-testing/100-unit-integration.md +++ b/src/data/roadmaps/rust/content/119-testing/100-unit-integration.md @@ -1 +1,3 @@ -# Unit integration \ No newline at end of file +# Unit and Integration Testing + +In Rust language, the concept of unit integration encompasses writing tests for individual units of your code, typically a function or method, as well as for multiple units that interact with each other. Unit tests are written in the same files as the code and are used to verify the functionality of a single unit of software in isolation. On the other hand, integration tests are stored in an entirely different directory and are meant to test how multiple components or modules of your application work together. They rely on combining units of code and testing the group, identifying issues that may not be visible when units are tested in isolation. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/119-testing/101-mocking.md b/src/data/roadmaps/rust/content/119-testing/101-mocking.md index fedca8186..a736ba824 100644 --- a/src/data/roadmaps/rust/content/119-testing/101-mocking.md +++ b/src/data/roadmaps/rust/content/119-testing/101-mocking.md @@ -1 +1,3 @@ -# Mocking \ No newline at end of file +# Mocking and Property-based Testing + +In Rust, **mocking** is a process that lets you create fake functions, objects, or behaviors to test different conditions and scenarios in your code. Rust does not natively support mocking, however, there are external libraries present to help you perform mocking. Some of the popular libraries for mocking in rust are `mockall`, `mockiato`, and `double`. These libraries give you the ability to create mock structures with the same API as your original code and allow you to set predefined responses from functions or validate function calls, thus helping you test your rust code thoroughly. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/119-testing/index.md b/src/data/roadmaps/rust/content/119-testing/index.md index 94cfd7d77..ae0c5e198 100644 --- a/src/data/roadmaps/rust/content/119-testing/index.md +++ b/src/data/roadmaps/rust/content/119-testing/index.md @@ -1 +1,3 @@ -# Testing \ No newline at end of file +# Testing + +"Testing" in Rust is a crucial part of any programming project. This procedure involves creating specific scenarios to determine whether your code functions as expected. Rust has built-in support for this via the `cargo test` command which will run your test functions. These test functions are typically marked with the `#[test]` attribute to signify that they are not regular functions but testing adjuncts. Rust also provides a few macros such as `assert!`, `assert_eq!`, and `assert_ne!` for comparison checks and confirming expected behavior. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/120-debugging/100-rust-gdb.md b/src/data/roadmaps/rust/content/120-debugging/100-rust-gdb.md index 3eaa6503a..f69feb63c 100644 --- a/src/data/roadmaps/rust/content/120-debugging/100-rust-gdb.md +++ b/src/data/roadmaps/rust/content/120-debugging/100-rust-gdb.md @@ -1 +1,3 @@ -# Rust gdb \ No newline at end of file +# rust-gdb + +`Rust GDB` is a powerful tool used for debugging applications written in Rust programming language. It stands for the GNU Project debugger and has a wide range of features that are versatile for dealing with different tasks involved in debugging. With `Rust GDB`, you can carry out tasks such image inspection, trace execution, modify programs during runtime and break execution during specific conditions. It is usually used from the command line and supported on many Unix-like systems. It communicates directly with the processors and operating systems on a low level, making it a great tool for programmers looking to explore in-depth analysis of their Rust applications. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/120-debugging/101-rust-lldb.md b/src/data/roadmaps/rust/content/120-debugging/101-rust-lldb.md index 56ff9b786..255ece951 100644 --- a/src/data/roadmaps/rust/content/120-debugging/101-rust-lldb.md +++ b/src/data/roadmaps/rust/content/120-debugging/101-rust-lldb.md @@ -1 +1,3 @@ -# Rust lldb \ No newline at end of file +# rust-lldb + +`Rust LLDB` is a set of modifications made to the LLDB debugger by the Rust developers to enable it to understand Rust-specific data structures and concepts. It allows the developer to drill down into Rust-specific data structures in a meaningful way that the regular LLDB debugger wouldn't understand. Furthermore, `Rust LLDB` includes pretty-printers for many common Rust standard library types. It’s worth noting that Rust-enhanced LLDB doesn’t need to be installed separately, it comes bundled with the Rust compiler. diff --git a/src/data/roadmaps/rust/content/120-debugging/index.md b/src/data/roadmaps/rust/content/120-debugging/index.md index 948532978..2ec4c581f 100644 --- a/src/data/roadmaps/rust/content/120-debugging/index.md +++ b/src/data/roadmaps/rust/content/120-debugging/index.md @@ -1 +1,3 @@ -# Debugging \ No newline at end of file +# Debugging + +"Debugging" is a critical process in software development that involves identifying, isolating, and fixing (or "debugging") problems or errors in a computer program or software code. In Rust, the Rust compiler plays a big part in this process because of its strictness and propensity for compile-time error checking. Rust also provides various debugging tools such as `rust-gdb` and `rust-lldb`. Moreover, the language comes with standard library macros like `debug!` and `println!` for tracing and debugging. Additionally, for a thorough debugging experience, there are debugging variables that provide a backtrace of a system's state, and tests that can help you ensure that your system works as expected. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/121-rustdoc.md b/src/data/roadmaps/rust/content/121-rustdoc.md index e3d5370bd..b5cbc39d3 100644 --- a/src/data/roadmaps/rust/content/121-rustdoc.md +++ b/src/data/roadmaps/rust/content/121-rustdoc.md @@ -1 +1,3 @@ -# Rustdoc \ No newline at end of file +# Documenting with `rustdoc` + +`rustdoc` is a tool that comes bundled with Rust by default. It is primarily used to generate documentation for Rust projects. `rustdoc` takes into consideration both the comments and the source code to produce comprehensive documentation. The resultant documentation can be viewed through a web server or a web browser. The uniqueness of `rustdoc` lies in its testing feature. It can test the code snippets present in your documentation, ensuring that your examples are accurate and up-to-date. It is the de facto tool for all Rust developers to create and maintain their project documentation. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/122-perf-profiling/100-criterion-rs.md b/src/data/roadmaps/rust/content/122-perf-profiling/100-criterion-rs.md index 8060832e4..b559ec23f 100644 --- a/src/data/roadmaps/rust/content/122-perf-profiling/100-criterion-rs.md +++ b/src/data/roadmaps/rust/content/122-perf-profiling/100-criterion-rs.md @@ -1 +1,3 @@ -# Criterion rs \ No newline at end of file +# Criterion.rs + +`Criterion.rs` is a statistics-driven micro-benchmarking library in Rust programming language. It provides you with a reliable way to analyze your code's performance over time with statistical methods. The library provides you with zero-cost setup. It delivers detailed, actionable feedback to help you understand what caused performance improvements or regressions. Additionally, it provides automatic outlier detection and can compare the performance of several algorithms or different versions of the same algorithm. \ No newline at end of file diff --git a/src/data/roadmaps/rust/content/122-perf-profiling/index.md b/src/data/roadmaps/rust/content/122-perf-profiling/index.md index fb88c7ec7..5861fa3a1 100644 --- a/src/data/roadmaps/rust/content/122-perf-profiling/index.md +++ b/src/data/roadmaps/rust/content/122-perf-profiling/index.md @@ -1 +1,3 @@ -# Perf profiling \ No newline at end of file +# Performance and Profiling + +`Perf profiling` is a type of software performance analysis tool that helps to identify the performance bottlenecks in a program. It is derived from the Linux `perf` tool, and is specifically designed for use with Rust programs. Perf profiling works by collecting statistical data about the running system and software, which can then be analyzed to determine where the most time is being spent in your code. This makes it easier to target optimizations effectively, rather than relying on intuition or guesswork. \ No newline at end of file diff --git a/src/data/roadmaps/rust/rust.json b/src/data/roadmaps/rust/rust.json index c19bbb00f..9e068d324 100644 --- a/src/data/roadmaps/rust/rust.json +++ b/src/data/roadmaps/rust/rust.json @@ -4967,8771 +4967,6 @@ } } }, - { - "ID": "730", - "typeID": "Component", - "zOrder": "130", - "measuredW": "119", - "measuredH": "50", - "w": "119", - "h": "50", - "x": "849", - "y": "666", - "properties": { - "src": { - "Anchor": "2", - "ID": "7D9032BB-9E61-45F8-9D65-50D01E280EF5" - } - } - }, - { - "ID": "732", - "typeID": "__group__", - "zOrder": "74", - "measuredW": "95", - "measuredH": "50", - "w": "95", - "h": "50", - "x": "616", - "y": "824", - "properties": { - "controlName": "100-language-basics:data-structures:integers" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "95", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "65", - "measuredH": "25", - "x": "15", - "y": "12", - "properties": { - "size": "17", - "text": "Integers" - } - } - ] - } - } - }, - { - "ID": "733", - "typeID": "__group__", - "zOrder": "75", - "measuredW": "80", - "measuredH": "50", - "w": "80", - "h": "50", - "x": "707", - "y": "824", - "properties": { - "controlName": "101-language-basics:data-structures:floats" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "80", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "47", - "measuredH": "25", - "x": "16", - "y": "12", - "properties": { - "size": "17", - "text": "Floats" - } - } - ] - } - } - }, - { - "ID": "734", - "typeID": "__group__", - "zOrder": "76", - "measuredW": "89", - "measuredH": "50", - "w": "89", - "h": "50", - "x": "782", - "y": "824", - "properties": { - "controlName": "102-language-basics:data-structures:boolean" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "89", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "64", - "measuredH": "25", - "x": "13", - "y": "12", - "properties": { - "size": "17", - "text": "Boolean" - } - } - ] - } - } - }, - { - "ID": "736", - "typeID": "__group__", - "zOrder": "77", - "measuredW": "101", - "measuredH": "50", - "w": "101", - "h": "50", - "x": "867", - "y": "824", - "properties": { - "controlName": "103-language-basics:data-structures:character" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "101", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "77", - "measuredH": "25", - "x": "13", - "y": "12", - "properties": { - "size": "17", - "text": "Character" - } - } - ] - } - } - }, - { - "ID": "737", - "typeID": "__group__", - "zOrder": "108", - "measuredW": "171", - "measuredH": "50", - "w": "171", - "h": "50", - "x": "616", - "y": "870", - "properties": { - "controlName": "104-language-basics:data-structures:tuple" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "171", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "43", - "measuredH": "25", - "x": "64", - "y": "12", - "properties": { - "size": "17", - "text": "Tuple" - } - } - ] - } - } - }, - { - "ID": "738", - "typeID": "__group__", - "zOrder": "109", - "measuredW": "184", - "measuredH": "50", - "w": "184", - "h": "50", - "x": "784", - "y": "871", - "properties": { - "controlName": "105-language-basics:data-structures:array" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "184", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "40", - "measuredH": "25", - "x": "59", - "y": "11", - "properties": { - "size": "17", - "text": "Array" - } - } - ] - } - } - }, - { - "ID": "739", - "typeID": "__group__", - "zOrder": "113", - "measuredW": "79", - "measuredH": "50", - "w": "79", - "h": "50", - "x": "616", - "y": "916", - "properties": { - "controlName": "106-language-basics:data-structures:vector" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "79", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "50", - "measuredH": "25", - "x": "15", - "y": "12", - "properties": { - "size": "17", - "text": "Vector" - } - } - ] - } - } - }, - { - "ID": "740", - "typeID": "__group__", - "zOrder": "114", - "measuredW": "81", - "measuredH": "50", - "w": "81", - "h": "50", - "x": "692", - "y": "916", - "properties": { - "controlName": "107-language-basics:data-structures:string" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "81", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "46", - "measuredH": "25", - "x": "18", - "y": "12", - "properties": { - "size": "17", - "text": "String" - } - } - ] - } - } - }, - { - "ID": "741", - "typeID": "__group__", - "zOrder": "115", - "measuredW": "104", - "measuredH": "50", - "w": "104", - "h": "50", - "x": "767", - "y": "916", - "properties": { - "controlName": "108-language-basics:data-structures:hashmap" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "104", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "74", - "measuredH": "25", - "x": "17", - "y": "12", - "properties": { - "size": "17", - "text": "Hashmap" - } - } - ] - } - } - }, - { - "ID": "742", - "typeID": "__group__", - "zOrder": "116", - "measuredW": "101", - "measuredH": "50", - "w": "101", - "h": "50", - "x": "867", - "y": "916", - "properties": { - "controlName": "109-language-basics:data-structures:hashset" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "101", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "64", - "measuredH": "25", - "x": "17", - "y": "12", - "properties": { - "size": "17", - "text": "Hashset" - } - } - ] - } - } - }, - { - "ID": "743", - "typeID": "__group__", - "zOrder": "117", - "measuredW": "110", - "measuredH": "50", - "w": "110", - "h": "50", - "x": "616", - "y": "963", - "properties": { - "controlName": "110-language-basics:data-structures:linked-list" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "110", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "79", - "measuredH": "25", - "x": "12", - "y": "12", - "properties": { - "size": "17", - "text": "LinkedList" - } - } - ] - } - } - }, - { - "ID": "744", - "typeID": "__group__", - "zOrder": "118", - "measuredW": "110", - "measuredH": "50", - "w": "110", - "h": "50", - "x": "713", - "y": "963", - "properties": { - "controlName": "111-language-basics:data-structures:binary-heap" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "110", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "91", - "measuredH": "25", - "x": "10", - "y": "12", - "properties": { - "size": "17", - "text": "BinaryHeap" - } - } - ] - } - } - }, - { - "ID": "746", - "typeID": "__group__", - "zOrder": "110", - "measuredW": "77", - "measuredH": "50", - "w": "77", - "h": "50", - "x": "820", - "y": "963", - "properties": { - "controlName": "112-language-basics:data-structures:stack" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "77", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "43", - "measuredH": "25", - "x": "16", - "y": "12", - "properties": { - "size": "17", - "text": "Stack" - } - } - ] - } - } - }, - { - "ID": "747", - "typeID": "__group__", - "zOrder": "119", - "measuredW": "77", - "measuredH": "50", - "w": "77", - "h": "50", - "x": "892", - "y": "963", - "properties": { - "controlName": "113-language-basics:data-structures:queue" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "77", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "53", - "measuredH": "25", - "x": "13", - "y": "12", - "properties": { - "size": "17", - "text": "Queue" - } - } - ] - } - } - }, - { - "ID": "748", - "typeID": "__group__", - "zOrder": "120", - "measuredW": "135", - "measuredH": "50", - "w": "135", - "h": "50", - "x": "616", - "y": "1061", - "properties": { - "controlName": "114-language-basics:data-structures:btree-map" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "135", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "82", - "measuredH": "25", - "x": "27", - "y": "12", - "properties": { - "size": "17", - "text": "BTreeMap" - } - } - ] - } - } - }, - { - "ID": "749", - "typeID": "__group__", - "zOrder": "121", - "measuredW": "112", - "measuredH": "50", - "w": "112", - "h": "50", - "x": "747", - "y": "1061", - "properties": { - "controlName": "115-language-basics:data-structures:btree-set" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "112", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "73", - "measuredH": "25", - "x": "19", - "y": "12", - "properties": { - "size": "17", - "text": "BTreeSet" - } - } - ] - } - } - }, - { - "ID": "750", - "typeID": "__group__", - "zOrder": "122", - "measuredW": "113", - "measuredH": "50", - "w": "113", - "h": "50", - "x": "856", - "y": "1061", - "properties": { - "controlName": "116-language-basics:data-structures:rc" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "113", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "22", - "measuredH": "25", - "x": "46", - "y": "12", - "properties": { - "size": "17", - "text": "Rc" - } - } - ] - } - } - }, - { - "ID": "751", - "typeID": "__group__", - "zOrder": "123", - "measuredW": "60", - "measuredH": "50", - "w": "60", - "h": "50", - "x": "616", - "y": "1107", - "properties": { - "controlName": "117-language-basics:data-structures:arc" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "60", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "26", - "measuredH": "25", - "x": "17", - "y": "12", - "properties": { - "size": "17", - "text": "Arc" - } - } - ] - } - } - }, - { - "ID": "752", - "typeID": "__group__", - "zOrder": "126", - "measuredW": "78", - "measuredH": "50", - "w": "78", - "h": "50", - "x": "673", - "y": "1107", - "properties": { - "controlName": "118-language-basics:data-structures:mutex" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "78", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "48", - "measuredH": "25", - "x": "15", - "y": "12", - "properties": { - "size": "17", - "text": "Mutex" - } - } - ] - } - } - }, - { - "ID": "753", - "typeID": "__group__", - "zOrder": "124", - "measuredW": "110", - "measuredH": "50", - "w": "110", - "h": "50", - "x": "748", - "y": "1107", - "properties": { - "controlName": "119-language-basics:data-structures:rwlock" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "110", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "60", - "measuredH": "25", - "x": "23", - "y": "12", - "properties": { - "size": "17", - "text": "RwLock" - } - } - ] - } - } - }, - { - "ID": "754", - "typeID": "__group__", - "zOrder": "125", - "measuredW": "115", - "measuredH": "50", - "w": "115", - "h": "50", - "x": "854", - "y": "1107", - "properties": { - "controlName": "120-language-basics:data-structures:channels" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "115", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "73", - "measuredH": "25", - "x": "21", - "y": "12", - "properties": { - "size": "17", - "text": "Channels" - } - } - ] - } - } - }, - { - "ID": "755", - "typeID": "__group__", - "zOrder": "143", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "1064", - "y": "964", - "properties": { - "controlName": "100-concurrency-parallelism:futures" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "266", - "measuredH": "25", - "x": "48", - "y": "13", - "properties": { - "size": "17", - "text": "Futures and Async/Await Paradigm" - } - } - ] - } - } - }, - { - "ID": "756", - "typeID": "__group__", - "zOrder": "142", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "1064", - "y": "911", - "properties": { - "controlName": "101-concurrency-parallelism:atomic-operations" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "309", - "measuredH": "25", - "x": "26", - "y": "13", - "properties": { - "size": "17", - "text": "Atomic Operations and Memory Barriers" - } - } - ] - } - } - }, - { - "ID": "757", - "typeID": "__group__", - "zOrder": "141", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "1064", - "y": "857", - "properties": { - "controlName": "102-concurrency-parallelism:threads" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "320", - "measuredH": "25", - "x": "21", - "y": "13", - "properties": { - "size": "17", - "text": "Threads, Channels, and Message Passing" - } - } - ] - } - } - }, - { - "ID": "759", - "typeID": "__group__", - "zOrder": "137", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "616", - "y": "1375", - "properties": { - "controlName": "100-modules-and-crates:code-organization" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "289", - "measuredH": "25", - "x": "36", - "y": "13", - "properties": { - "size": "17", - "text": "Code Organization and Namespacing" - } - } - ] - } - } - }, - { - "ID": "760", - "typeID": "__group__", - "zOrder": "138", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "616", - "y": "1422", - "properties": { - "controlName": "101-modules-and-crates:dependency-mgmt" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "326", - "measuredH": "25", - "x": "18", - "y": "13", - "properties": { - "size": "17", - "text": "Dependency Management with Cargo.toml" - } - } - ] - } - } - }, - { - "ID": "761", - "typeID": "__group__", - "zOrder": "139", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "616", - "y": "1469", - "properties": { - "controlName": "102-modules-and-crates:publishing" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "168", - "measuredH": "25", - "x": "97", - "y": "13", - "properties": { - "size": "17", - "text": "Publishing to crates.io" - } - } - ] - } - } - }, - { - "ID": "762", - "typeID": "__group__", - "zOrder": "145", - "measuredW": "416", - "measuredH": "50", - "w": "416", - "h": "50", - "x": "1010", - "y": "1672", - "properties": { - "controlName": "100-traits-generics:trait-def" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "416", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "286", - "measuredH": "25", - "x": "65", - "y": "13", - "properties": { - "size": "17", - "text": "Trait Definitions and Implementations" - } - } - ] - } - } - }, - { - "ID": "763", - "typeID": "__group__", - "zOrder": "146", - "measuredW": "416", - "measuredH": "50", - "w": "416", - "h": "50", - "x": "1010", - "y": "1726", - "properties": { - "controlName": "101-traits-generics:trait-bounds" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "416", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "268", - "measuredH": "25", - "x": "74", - "y": "13", - "properties": { - "size": "17", - "text": "Trait Bounds and Associated Types" - } - } - ] - } - } - }, - { - "ID": "764", - "typeID": "__group__", - "zOrder": "147", - "measuredW": "416", - "measuredH": "50", - "w": "416", - "h": "50", - "x": "1010", - "y": "1779", - "properties": { - "controlName": "102-traits-generics:advanced-generics" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "416", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "374", - "measuredH": "25", - "x": "21", - "y": "13", - "properties": { - "size": "17", - "text": "Advanced Generics and Type-level Programming" - } - } - ] - } - } - }, - { - "ID": "765", - "typeID": "__group__", - "zOrder": "149", - "measuredW": "331", - "measuredH": "50", - "w": "331", - "h": "50", - "x": "635", - "y": "1672", - "properties": { - "controlName": "100-lifetimes-borrow:explicit-lifetime" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "331", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "217", - "measuredH": "25", - "x": "56", - "y": "13", - "properties": { - "size": "17", - "text": "Explicit Lifetime Annotations" - } - } - ] - } - } - }, - { - "ID": "766", - "typeID": "__group__", - "zOrder": "150", - "measuredW": "331", - "measuredH": "50", - "w": "331", - "h": "50", - "x": "635", - "y": "1726", - "properties": { - "controlName": "101-lifetimes-borrow:lifetime-elision" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "331", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "166", - "measuredH": "25", - "x": "82", - "y": "13", - "properties": { - "size": "17", - "text": "Lifetime Elision Rules" - } - } - ] - } - } - }, - { - "ID": "767", - "typeID": "__group__", - "zOrder": "151", - "measuredW": "331", - "measuredH": "50", - "w": "331", - "h": "50", - "x": "635", - "y": "1780", - "properties": { - "controlName": "102-lifetimes-borrow:covariant" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "331", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "291", - "measuredH": "25", - "x": "19", - "y": "13", - "properties": { - "size": "17", - "text": "Covariant and Contravariant Lifetimes" - } - } - ] - } - } - }, - { - "ID": "769", - "typeID": "__group__", - "zOrder": "133", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "129", - "y": "1223", - "properties": { - "controlName": "100-error-handling:option" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "232", - "measuredH": "25", - "x": "45", - "y": "13", - "properties": { - "size": "17", - "text": "Option & Result Enumerations" - } - } - ] - } - } - }, - { - "ID": "770", - "typeID": "__group__", - "zOrder": "134", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "129", - "y": "1277", - "properties": { - "controlName": "101-error-handling:propagating" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "273", - "measuredH": "25", - "x": "24", - "y": "13", - "properties": { - "size": "17", - "text": "Propagating Errors and `?` Operator" - } - } - ] - } - } - }, - { - "ID": "771", - "typeID": "__group__", - "zOrder": "135", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "129", - "y": "1331", - "properties": { - "controlName": "102-error-handling:custom-error" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "232", - "measuredH": "25", - "x": "45", - "y": "13", - "properties": { - "size": "17", - "text": "Custom Error Types and Traits" - } - } - ] - } - } - }, - { - "ID": "772", - "typeID": "__group__", - "zOrder": "153", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "128", - "y": "1427", - "properties": { - "controlName": "100-macros:declarative" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "288", - "measuredH": "25", - "x": "37", - "y": "13", - "properties": { - "size": "17", - "text": "Declarative Macros with macro_rules!" - } - } - ] - } - } - }, - { - "ID": "773", - "typeID": "__group__", - "zOrder": "154", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "128", - "y": "1481", - "properties": { - "controlName": "101-macros:procedural" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "297", - "measuredH": "25", - "x": "32", - "y": "13", - "properties": { - "size": "17", - "text": "Procedural Macros and Custom Derive" - } - } - ] - } - } - }, - { - "ID": "774", - "typeID": "__group__", - "zOrder": "155", - "measuredW": "362", - "measuredH": "50", - "w": "362", - "h": "50", - "x": "128", - "y": "1535", - "properties": { - "controlName": "102-macros:domain-specific" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "362", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "332", - "measuredH": "25", - "x": "15", - "y": "13", - "properties": { - "size": "17", - "text": "Domain-Specific Languages (DSLs) in Rust" - } - } - ] - } - } - }, - { - "ID": "775", - "typeID": "__group__", - "zOrder": "161", - "measuredW": "98", - "measuredH": "50", - "w": "98", - "h": "50", - "x": "128", - "y": "1896", - "properties": { - "controlName": "100-web-development:rocket" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "98", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "55", - "measuredH": "25", - "x": "21", - "y": "13", - "properties": { - "size": "17", - "text": "Rocket" - } - } - ] - } - } - }, - { - "ID": "776", - "typeID": "__group__", - "zOrder": "162", - "measuredW": "98", - "measuredH": "50", - "w": "98", - "h": "50", - "x": "128", - "y": "1951", - "properties": { - "controlName": "101-web-development:warp" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "98", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "41", - "measuredH": "25", - "x": "28", - "y": "13", - "properties": { - "size": "17", - "text": "Warp" - } - } - ] - } - } - }, - { - "ID": "777", - "typeID": "__group__", - "zOrder": "163", - "measuredW": "98", - "measuredH": "50", - "w": "98", - "h": "50", - "x": "128", - "y": "2006", - "properties": { - "controlName": "102-web-development:actix" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "98", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "37", - "measuredH": "25", - "x": "30", - "y": "13", - "properties": { - "size": "17", - "text": "Actix" - } - } - ] - } - } - }, - { - "ID": "778", - "typeID": "__group__", - "zOrder": "164", - "measuredW": "98", - "measuredH": "50", - "w": "98", - "h": "50", - "x": "128", - "y": "2061", - "properties": { - "controlName": "103-web-development:yew" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "98", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "30", - "measuredH": "25", - "x": "34", - "y": "13", - "properties": { - "size": "17", - "text": "Yew" - } - } - ] - } - } - }, - { - "ID": "779", - "typeID": "__group__", - "zOrder": "166", - "measuredW": "81", - "measuredH": "50", - "w": "81", - "h": "50", - "x": "634", - "y": "1899", - "properties": { - "controlName": "100-async-programming:tokio" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "81", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "41", - "measuredH": "25", - "x": "21", - "y": "12", - "properties": { - "size": "17", - "text": "Tokio" - } - } - ] - } - } - }, - { - "ID": "780", - "typeID": "__group__", - "zOrder": "167", - "measuredW": "110", - "measuredH": "50", - "w": "110", - "h": "50", - "x": "723", - "y": "1899", - "properties": { - "controlName": "101-async-programming:async-std" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "110", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "74", - "measuredH": "25", - "x": "18", - "y": "12", - "properties": { - "size": "17", - "text": "async-std" - } - } - ] - } - } - }, - { - "ID": "781", - "typeID": "__group__", - "zOrder": "168", - "measuredW": "75", - "measuredH": "50", - "w": "75", - "h": "50", - "x": "839", - "y": "1899", - "properties": { - "controlName": "102-async-programming:smol" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "75", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "36", - "measuredH": "25", - "x": "18", - "y": "12", - "properties": { - "size": "17", - "text": "smol" - } - } - ] - } - } - }, - { - "ID": "782", - "typeID": "__group__", - "zOrder": "170", - "measuredW": "101", - "measuredH": "50", - "w": "101", - "h": "50", - "x": "1009", - "y": "1896", - "properties": { - "controlName": "100-networking:reqwest" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "101", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "61", - "measuredH": "25", - "x": "20", - "y": "12", - "properties": { - "size": "17", - "text": "reqwest" - } - } - ] - } - } - }, - { - "ID": "783", - "typeID": "__group__", - "zOrder": "171", - "measuredW": "78", - "measuredH": "50", - "w": "78", - "h": "50", - "x": "1119", - "y": "1896", - "properties": { - "controlName": "101-networking:hyper" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "78", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "44", - "measuredH": "25", - "x": "17", - "y": "12", - "properties": { - "size": "17", - "text": "hyper" - } - } - ] - } - } - }, - { - "ID": "784", - "typeID": "__group__", - "zOrder": "172", - "measuredW": "75", - "measuredH": "50", - "w": "75", - "h": "50", - "x": "1208", - "y": "1896", - "properties": { - "controlName": "102-networking:quinn" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "75", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "43", - "measuredH": "25", - "x": "18", - "y": "12", - "properties": { - "size": "17", - "text": "quinn" - } - } - ] - } - } - }, - { - "ID": "787", - "typeID": "__group__", - "zOrder": "175", - "measuredW": "79", - "measuredH": "50", - "w": "79", - "h": "50", - "x": "1009", - "y": "2224", - "properties": { - "controlName": "100-serialization:serde" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "79", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "46", - "measuredH": "25", - "x": "17", - "y": "12", - "properties": { - "size": "17", - "text": "Serde" - } - } - ] - } - } - }, - { - "ID": "788", - "typeID": "__group__", - "zOrder": "176", - "measuredW": "100", - "measuredH": "50", - "w": "100", - "h": "50", - "x": "1096", - "y": "2224", - "properties": { - "controlName": "101-serialization:json-rust" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "100", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "68", - "measuredH": "25", - "x": "16", - "y": "12", - "properties": { - "size": "17", - "text": "json-rust" - } - } - ] - } - } - }, - { - "ID": "789", - "typeID": "__group__", - "zOrder": "177", - "measuredW": "80", - "measuredH": "50", - "w": "80", - "h": "50", - "x": "1203", - "y": "2224", - "properties": { - "controlName": "102-serialization:toml-rs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "80", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "54", - "measuredH": "25", - "x": "13", - "y": "12", - "properties": { - "size": "17", - "text": "toml-rs" - } - } - ] - } - } - }, - { - "ID": "791", - "typeID": "__group__", - "zOrder": "40", - "measuredW": "94", - "measuredH": "50", - "w": "94", - "h": "50", - "x": "640", - "y": "2224", - "properties": { - "controlName": "100-database-orm:diesel" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "94", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "49", - "measuredH": "25", - "x": "22", - "y": "12", - "properties": { - "size": "17", - "text": "Diesel" - } - } - ] - } - } - }, - { - "ID": "792", - "typeID": "__group__", - "zOrder": "41", - "measuredW": "69", - "measuredH": "50", - "w": "69", - "h": "50", - "x": "740", - "y": "2224", - "properties": { - "controlName": "101-database-orm:sqlx" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "69", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "31", - "measuredH": "25", - "x": "21", - "y": "12", - "properties": { - "size": "17", - "text": "sqlx" - } - } - ] - } - } - }, - { - "ID": "793", - "typeID": "__group__", - "zOrder": "42", - "measuredW": "95", - "measuredH": "50", - "w": "95", - "h": "50", - "x": "819", - "y": "2224", - "properties": { - "controlName": "102-database-orm:rusqlite" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "95", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "57", - "measuredH": "25", - "x": "19", - "y": "12", - "properties": { - "size": "17", - "text": "rusqlite" - } - } - ] - } - } - }, - { - "ID": "795", - "typeID": "__group__", - "zOrder": "180", - "measuredW": "132", - "measuredH": "50", - "w": "132", - "h": "50", - "x": "128", - "y": "2150", - "properties": { - "controlName": "100-cryptography:ring" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "132", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "30", - "measuredH": "25", - "x": "51", - "y": "13", - "properties": { - "size": "17", - "text": "ring" - } - } - ] - } - } - }, - { - "ID": "796", - "typeID": "__group__", - "zOrder": "181", - "measuredW": "132", - "measuredH": "50", - "w": "132", - "h": "50", - "x": "128", - "y": "2205", - "properties": { - "controlName": "101-cryptography:rust-crypto" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "132", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "84", - "measuredH": "25", - "x": "24", - "y": "13", - "properties": { - "size": "17", - "text": "rust-crypto" - } - } - ] - } - } - }, - { - "ID": "797", - "typeID": "__group__", - "zOrder": "182", - "measuredW": "132", - "measuredH": "50", - "w": "132", - "h": "50", - "x": "128", - "y": "2260", - "properties": { - "controlName": "102-cryptography:sodiumoxide" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "132", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "97", - "measuredH": "25", - "x": "17", - "y": "13", - "properties": { - "size": "17", - "text": "sodiumoxide" - } - } - ] - } - } - }, - { - "ID": "799", - "typeID": "__group__", - "zOrder": "184", - "measuredW": "106", - "measuredH": "50", - "w": "106", - "h": "50", - "x": "150", - "y": "2360", - "properties": { - "controlName": "100-cli-utils:clap" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "106", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "33", - "measuredH": "25", - "x": "37", - "y": "13", - "properties": { - "size": "17", - "text": "clap" - } - } - ] - } - } - }, - { - "ID": "800", - "typeID": "__group__", - "zOrder": "185", - "measuredW": "106", - "measuredH": "50", - "w": "106", - "h": "50", - "x": "150", - "y": "2415", - "properties": { - "controlName": "101-cli-utils:structopt" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "106", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "68", - "measuredH": "25", - "x": "20", - "y": "13", - "properties": { - "size": "17", - "text": "structopt" - } - } - ] - } - } - }, - { - "ID": "801", - "typeID": "__group__", - "zOrder": "186", - "measuredW": "106", - "measuredH": "50", - "w": "106", - "h": "50", - "x": "150", - "y": "2470", - "properties": { - "controlName": "102-cli-utils:termion" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "106", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "59", - "measuredH": "25", - "x": "24", - "y": "13", - "properties": { - "size": "17", - "text": "termion" - } - } - ] - } - } - }, - { - "ID": "802", - "typeID": "__group__", - "zOrder": "188", - "measuredW": "87", - "measuredH": "50", - "w": "87", - "h": "50", - "x": "640", - "y": "2334", - "properties": { - "controlName": "100-game-dev:bevy" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "87", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "36", - "measuredH": "25", - "x": "26", - "y": "13", - "properties": { - "size": "17", - "text": "bevy" - } - } - ] - } - } - }, - { - "ID": "803", - "typeID": "__group__", - "zOrder": "189", - "measuredW": "89", - "measuredH": "50", - "w": "89", - "h": "50", - "x": "731", - "y": "2335", - "properties": { - "controlName": "101-game-dev:fyrox" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "89", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "36", - "measuredH": "25", - "x": "27", - "y": "13", - "properties": { - "size": "17", - "text": "fyrox" - } - } - ] - } - } - }, - { - "ID": "804", - "typeID": "__group__", - "zOrder": "190", - "measuredW": "86", - "measuredH": "50", - "w": "86", - "h": "50", - "x": "825", - "y": "2335", - "properties": { - "controlName": "102-game-dev:ggez" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "86", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "38", - "measuredH": "25", - "x": "24", - "y": "13", - "properties": { - "size": "17", - "text": "ggez" - } - } - ] - } - } - }, - { - "ID": "805", - "typeID": "__group__", - "zOrder": "191", - "measuredW": "133", - "measuredH": "50", - "w": "133", - "h": "50", - "x": "640", - "y": "2508", - "properties": { - "controlName": "103-game-dev:macroquad" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "133", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "87", - "measuredH": "25", - "x": "23", - "y": "13", - "properties": { - "size": "17", - "text": "macroquad" - } - } - ] - } - } - }, - { - "ID": "806", - "typeID": "__group__", - "zOrder": "192", - "measuredW": "130", - "measuredH": "50", - "w": "130", - "h": "50", - "x": "781", - "y": "2509", - "properties": { - "controlName": "104-game-dev:wgpu-rs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "130", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "62", - "measuredH": "25", - "x": "34", - "y": "13", - "properties": { - "size": "17", - "text": "wgpu-rs" - } - } - ] - } - } - }, - { - "ID": "808", - "typeID": "__group__", - "zOrder": "21", - "measuredW": "87", - "measuredH": "50", - "w": "87", - "h": "50", - "x": "1010", - "y": "2332", - "properties": { - "controlName": "100-gui-dev:druid" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "87", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "40", - "measuredH": "25", - "x": "26", - "y": "13", - "properties": { - "size": "17", - "text": "druid" - } - } - ] - } - } - }, - { - "ID": "809", - "typeID": "__group__", - "zOrder": "22", - "measuredW": "89", - "measuredH": "50", - "w": "89", - "h": "50", - "x": "1101", - "y": "2333", - "properties": { - "controlName": "101-gui-dev:gtk-rs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "89", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "45", - "measuredH": "25", - "x": "23", - "y": "13", - "properties": { - "size": "17", - "text": "gtk-rs" - } - } - ] - } - } - }, - { - "ID": "810", - "typeID": "__group__", - "zOrder": "23", - "measuredW": "86", - "measuredH": "50", - "w": "86", - "h": "50", - "x": "1195", - "y": "2333", - "properties": { - "controlName": "102-gui-dev:relm" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "86", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "34", - "measuredH": "25", - "x": "25", - "y": "13", - "properties": { - "size": "17", - "text": "relm" - } - } - ] - } - } - }, - { - "ID": "811", - "typeID": "__group__", - "zOrder": "196", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "1031", - "y": "2522", - "properties": { - "controlName": "100-embedded:embedded-hal" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "113", - "measuredH": "25", - "x": "15", - "y": "13", - "properties": { - "size": "17", - "text": "embedded-hal" - } - } - ] - } - } - }, - { - "ID": "812", - "typeID": "__group__", - "zOrder": "197", - "measuredW": "66", - "measuredH": "50", - "w": "66", - "h": "50", - "x": "1180", - "y": "2523", - "properties": { - "controlName": "101-embedded:rppal" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "66", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "40", - "measuredH": "25", - "x": "13", - "y": "13", - "properties": { - "size": "17", - "text": "rppal" - } - } - ] - } - } - }, - { - "ID": "813", - "typeID": "__group__", - "zOrder": "198", - "measuredW": "77", - "measuredH": "50", - "w": "77", - "h": "50", - "x": "1251", - "y": "2524", - "properties": { - "controlName": "102-embedded:nrf-hal" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "77", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "51", - "measuredH": "25", - "x": "13", - "y": "13", - "properties": { - "size": "17", - "text": "nrf-hal" - } - } - ] - } - } - }, - { - "ID": "814", - "typeID": "__group__", - "zOrder": "200", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "391", - "y": "2559", - "properties": { - "controlName": "100-wasm:wasm-bindgen" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "112", - "measuredH": "25", - "x": "16", - "y": "13", - "properties": { - "size": "17", - "text": "wasm-bindgen" - } - } - ] - } - } - }, - { - "ID": "815", - "typeID": "__group__", - "zOrder": "201", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "391", - "y": "2614", - "properties": { - "controlName": "101-wasm:wasm-pack" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "87", - "measuredH": "25", - "x": "28", - "y": "13", - "properties": { - "size": "17", - "text": "wasm-pack" - } - } - ] - } - } - }, - { - "ID": "816", - "typeID": "__group__", - "zOrder": "202", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "391", - "y": "2668", - "properties": { - "controlName": "102-wasm:wasmer" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "60", - "measuredH": "25", - "x": "42", - "y": "13", - "properties": { - "size": "17", - "text": "wasmer" - } - } - ] - } - } - }, - { - "ID": "817", - "typeID": "__group__", - "zOrder": "204", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "1081", - "y": "2734", - "properties": { - "controlName": "100-testing:unit-integration" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "213", - "measuredH": "25", - "x": "54", - "y": "13", - "properties": { - "size": "17", - "text": "Unit and Integration Testing" - } - } - ] - } - } - }, - { - "ID": "818", - "typeID": "__group__", - "zOrder": "205", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "1081", - "y": "2788", - "properties": { - "controlName": "101-testing:mocking" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "282", - "measuredH": "25", - "x": "20", - "y": "13", - "properties": { - "size": "17", - "text": "Mocking and Property-based Testing" - } - } - ] - } - } - }, - { - "ID": "821", - "typeID": "__group__", - "zOrder": "206", - "measuredW": "134", - "measuredH": "50", - "w": "134", - "h": "50", - "x": "959", - "y": "2915", - "properties": { - "controlName": "100-perf-profiling:criterion-rs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "134", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "85", - "measuredH": "25", - "x": "20", - "y": "13", - "properties": { - "size": "17", - "text": "Criterion.rs" - } - } - ] - } - } - }, - { - "ID": "822", - "typeID": "__group__", - "zOrder": "208", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "157", - "y": "2744", - "properties": { - "controlName": "100-debugging:rust-gdb" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "65", - "measuredH": "25", - "x": "42", - "y": "13", - "properties": { - "size": "17", - "text": "rust-gdb" - } - } - ] - } - } - }, - { - "ID": "823", - "typeID": "__group__", - "zOrder": "209", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "157", - "y": "2798", - "properties": { - "controlName": "101-debugging:rust-lldb" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "63", - "measuredH": "25", - "x": "42", - "y": "13", - "properties": { - "size": "17", - "text": "rust-lldb" - } - } - ] - } - } - } - ] - }, - "attributes": { - "name": "New Wireframe 1 copy", - "order": 1000009.1336392317, - "parentID": null, - "notes": "" - }, - "branchID": "Master", - "resourceID": "E62F7257-0C11-4024-8C48-67BDED6B975E", - "mockupH": "3027", - "mockupW": "1314", - "measuredW": "1442", - "measuredH": "3212", - "version": "1.0" - }, - "groupOffset": { - "x": 0, - "y": 0 - }, - "mockupBrokenSymbols": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Label", - "zOrder": "83", - "measuredW": "67", - "measuredH": "40", - "x": "776", - "y": "324", - "properties": { - "size": "32", - "text": "Rust" - } - }, - { - "ID": "1", - "typeID": "__group__", - "zOrder": "84", - "measuredW": "373", - "measuredH": "151", - "w": "373", - "h": "151", - "x": "1069", - "y": "216", - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Canvas", - "zOrder": "0", - "w": "373", - "h": "151", - "measuredW": "100", - "measuredH": "70", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "333", - "measuredH": "26", - "x": "18", - "y": "19", - "properties": { - "text": "Find the detailed version of this roadmap", - "size": "18" - } - }, - { - "ID": "3", - "typeID": "__group__", - "zOrder": "2", - "measuredW": "339", - "measuredH": "47", - "w": "339", - "h": "47", - "x": "18", - "y": "88", - "properties": { - "controlName": "ext_link:roadmap.sh" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Canvas", - "zOrder": "0", - "w": "339", - "h": "47", - "measuredW": "100", - "measuredH": "70", - "x": "0", - "y": "0", - "properties": { - "borderColor": "4273622", - "color": "4273622" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "155", - "measuredH": "26", - "x": "92", - "y": "11", - "properties": { - "color": "16777215", - "text": "https://roadmap.sh", - "size": "18" - } - } - ] - } - } - }, - { - "ID": "5", - "typeID": "Label", - "zOrder": "3", - "measuredW": "337", - "measuredH": "26", - "x": "18", - "y": "48", - "properties": { - "size": "18", - "text": "Along with resources and more roadmaps" - } - } - ] - } - } - }, - { - "ID": "2", - "typeID": "Arrow", - "zOrder": "85", - "w": "1", - "h": "74", - "measuredW": "150", - "measuredH": "100", - "x": "805", - "y": "233", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549725, - "y": -0.00008403832147459165 - }, - "p2": { - "x": 0, - "y": 74.15918378573792 - }, - "stroke": "dotted" - } - }, - { - "ID": "3", - "typeID": "Arrow", - "zOrder": "86", - "w": "1", - "h": "164", - "measuredW": "150", - "measuredH": "100", - "x": "805", - "y": "385", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459165 - }, - "p2": { - "x": 0, - "y": 164.11821056548797 - } - } - }, - { - "ID": "5", - "typeID": "Arrow", - "zOrder": "87", - "w": "101", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "754", - "y": "203", - "properties": { - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "color": "16777215", - "p0": { - "x": 100.57841492806233, - "y": 0.15918378573792324 - }, - "p1": { - "x": 0.4438624012549726, - "y": -0.00008403832147459165 - }, - "p2": { - "x": 0, - "y": 0.15918378573792324 - } - } - }, - { - "ID": "17", - "typeID": "Arrow", - "zOrder": "82", - "w": "197", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "893", - "y": "551", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 197, - "y": 0.15918378573792324 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459165 - }, - "p2": { - "x": 0.33333333333337123, - "y": 0.15918378573792324 - } - } - }, - { - "ID": "18", - "typeID": "Arrow", - "zOrder": "81", - "w": "179", - "h": "41", - "measuredW": "150", - "measuredH": "100", - "x": "893", - "y": "494", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 178.33333333333326, - "y": 0 - }, - "p1": { - "x": 0.432199336489445, - "y": 0.06731985877495898 - }, - "p2": { - "x": -0.33333333333337123, - "y": 41.33333333333337 - } - } - }, - { - "ID": "23", - "typeID": "Arrow", - "zOrder": "80", - "w": "197", - "h": "44", - "measuredW": "150", - "measuredH": "100", - "x": "877", - "y": "562", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 197, - "y": 44 - }, - "p1": { - "x": 0.385595616057061, - "y": -0.06267124777106091 - }, - "p2": { - "x": -0.33333333333337123, - "y": 0 - } - } - }, - { - "ID": "26", - "typeID": "Arrow", - "zOrder": "79", - "w": "240", - "h": "207", - "measuredW": "150", - "measuredH": "100", - "x": "490", - "y": "546", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0.32905999288510657, - "y": 206.95337847572125 - }, - "p1": { - "x": 0.45941041169891733, - "y": 0.25917406993184083 - }, - "p2": { - "x": 240.40115168079626, - "y": 0.3458813867310937 - } - } - }, - { - "ID": "35", - "typeID": "Arrow", - "zOrder": "78", - "w": "1", - "h": "224", - "measuredW": "150", - "measuredH": "100", - "x": "383", - "y": "659", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 223.44680974980668 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459861 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "318", - "typeID": "TextArea", - "zOrder": "91", - "w": "370", - "h": "189", - "measuredW": "200", - "measuredH": "140", - "x": "1063", - "y": "584" - }, - { - "ID": "334", - "typeID": "Label", - "zOrder": "94", - "measuredW": "146", - "measuredH": "25", - "x": "1183", - "y": "597", - "properties": { - "size": "17", - "text": "Environment Setup" - } - }, - { - "ID": "371", - "typeID": "TextArea", - "zOrder": "111", - "w": "353", - "h": "130", - "measuredW": "200", - "measuredH": "140", - "x": "616", - "y": "1010" - }, - { - "ID": "372", - "typeID": "Label", - "zOrder": "112", - "measuredW": "76", - "measuredH": "25", - "x": "634", - "y": "1026", - "properties": { - "size": "17", - "text": "Advanced" - } - }, - { - "ID": "414", - "typeID": "Arrow", - "zOrder": "73", - "w": "132", - "h": "24", - "measuredW": "150", - "measuredH": "100", - "x": "494", - "y": "739", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 0.24895255476468492, - "y": 23.446809749806675 - }, - "p1": { - "x": 0.5575040182177255, - "y": -0.06911872824527829 - }, - "p2": { - "x": 132.53323103265757, - "y": 0.19291874734653902 - } - } - }, - { - "ID": "426", - "typeID": "Arrow", - "zOrder": "72", - "w": "121", - "h": "22", - "measuredW": "150", - "measuredH": "100", - "x": "504", - "y": "780", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 0.24895255476468492, - "y": 0.4468097498066754 - }, - "p1": { - "x": 0.4947817519115979, - "y": 0.0539510853409226 - }, - "p2": { - "x": 121.07955764279063, - "y": 21.70087451162567 - } - } - }, - { - "ID": "427", - "typeID": "Arrow", - "zOrder": "71", - "w": "1", - "h": "345", - "measuredW": "150", - "measuredH": "100", - "x": "492", - "y": "788", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459159 - }, - "p2": { - "x": 0, - "y": 345.13840740129126 - } - } - }, - { - "ID": "436", - "typeID": "Arrow", - "zOrder": "70", - "w": "1", - "h": "111", - "measuredW": "150", - "measuredH": "100", - "x": "382", - "y": "1137", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 110.97860520078075 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459834 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "437", - "typeID": "Arrow", - "zOrder": "69", - "w": "197", - "h": "163", - "measuredW": "150", - "measuredH": "100", - "x": "494", - "y": "1152", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": -0.4778841401688396, - "y": 0.03616146956164812 - }, - "p1": { - "x": 0.4871417361689739, - "y": -0.2098902254544283 - }, - "p2": { - "x": 196.49486018680352, - "y": 162.8475811346607 - } - } - }, - { - "ID": "446", - "typeID": "Arrow", - "zOrder": "68", - "w": "1", - "h": "111", - "measuredW": "150", - "measuredH": "100", - "x": "796", - "y": "1317", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 110.97860520078075 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459834 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "456", - "typeID": "Arrow", - "zOrder": "67", - "w": "1", - "h": "111", - "measuredW": "150", - "measuredH": "100", - "x": "1189", - "y": "983", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 110.97860520078075 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459834 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "458", - "typeID": "Arrow", - "zOrder": "66", - "w": "249", - "h": "219", - "measuredW": "150", - "measuredH": "100", - "x": "905", - "y": "1094", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 249.32162480478883, - "y": -0.315385594950385 - }, - "p1": { - "x": 0.476956488587886, - "y": 0.24646723290179923 - }, - "p2": { - "x": 0, - "y": 218.13840740129126 - } - } - }, - { - "ID": "460", - "typeID": "Arrow", - "zOrder": "65", - "w": "1", - "h": "485", - "measuredW": "150", - "measuredH": "100", - "x": "1189", - "y": "1100", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459157 - }, - "p2": { - "x": 0, - "y": 484.6965034956197 - } - } - }, - { - "ID": "469", - "typeID": "Arrow", - "zOrder": "64", - "w": "1", - "h": "111", - "measuredW": "150", - "measuredH": "100", - "x": "1189", - "y": "1585", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 110.97860520078075 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459834 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "470", - "typeID": "Arrow", - "zOrder": "63", - "w": "492", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "675", - "y": "1592", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.08040012395417762, - "y": 0 - }, - "p1": { - "x": 0.5, - "y": 0 - }, - "p2": { - "x": 492, - "y": 0 - } - } - }, - { - "ID": "479", - "typeID": "Arrow", - "zOrder": "62", - "w": "1", - "h": "106", - "measuredW": "150", - "measuredH": "100", - "x": "795", - "y": "1596", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.211151520721387, - "y": 105.8446807219259 - }, - "p1": { - "x": 0.4438624012549726, - "y": -0.00008403832147459821 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "489", - "typeID": "Arrow", - "zOrder": "61", - "w": "213", - "h": "107", - "measuredW": "150", - "measuredH": "100", - "x": "486", - "y": "1590", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.17425353750144268, - "y": 107.48097641238269 - }, - "p1": { - "x": 0.37043013046626244, - "y": 0.2220567186365373 - }, - "p2": { - "x": 213, - "y": 2 - } - } - }, - { - "ID": "490", - "typeID": "Arrow", - "zOrder": "60", - "w": "1", - "h": "135", - "measuredW": "150", - "measuredH": "100", - "x": "380", - "y": "1557", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 134.6627039996581 - }, - "p1": { - "x": 0.4438624012549726, - "y": -0.00008403832147459805 - }, - "p2": { - "x": -0.21115152072133014, - "y": -0.1510751141287301 - } - } - }, - { - "ID": "491", - "typeID": "Arrow", - "zOrder": "59", - "w": "1", - "h": "283", - "measuredW": "150", - "measuredH": "100", - "x": "490", - "y": "1711", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459159 - }, - "p2": { - "x": 0, - "y": 282.91031929587234 - } - } - }, - { - "ID": "492", - "typeID": "Arrow", - "zOrder": "156", - "w": "349", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "150", - "y": "1806", - "properties": { - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 349.10198439749036, - "y": 0.16578208707346676 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147455506 - }, - "p2": { - "x": 0.3604503075575849, - "y": 0.16578208707346676 - } - } - }, - { - "ID": "493", - "typeID": "Arrow", - "zOrder": "157", - "w": "29", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "470", - "y": "1810", - "properties": { - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 29.101984397490355, - "y": 0.16578208707346676 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147455411 - }, - "p2": { - "x": -0.13539456394892113, - "y": 0.16578208707346676 - } - } - }, - { - "ID": "494", - "typeID": "Arrow", - "zOrder": "158", - "w": "29", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "470", - "y": "1813", - "properties": { - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 29.101984397490355, - "y": 0.16578208707346676 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147455411 - }, - "p2": { - "x": -0.13539456394892113, - "y": 0.16578208707346676 - } - } - }, - { - "ID": "495", - "typeID": "Label", - "zOrder": "159", - "measuredW": "223", - "measuredH": "28", - "x": "219", - "y": "1819", - "properties": { - "size": "20", - "text": "Ecosystem and Libraries" - } - }, - { - "ID": "506", - "typeID": "Arrow", - "zOrder": "58", - "w": "142", - "h": "62", - "measuredW": "150", - "measuredH": "100", - "x": "216", - "y": "1920", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 141.92324584081643, - "y": 62.10160448561237 - }, - "p1": { - "x": 0.4888238423607004, - "y": 0.0938563755456296 - }, - "p2": { - "x": -0.26544086306955705, - "y": -0.0037989022919191484 - } - } - }, - { - "ID": "507", - "typeID": "Arrow", - "zOrder": "57", - "w": "141", - "h": "16", - "measuredW": "150", - "measuredH": "100", - "x": "214", - "y": "1977", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 140.65454039934775, - "y": 14.907720810018418 - }, - "p1": { - "x": 0.46040357945532767, - "y": 0.03826232433035317 - }, - "p2": { - "x": -0.07155718747549145, - "y": -0.3372960003418939 - } - } - }, - { - "ID": "508", - "typeID": "Arrow", - "zOrder": "56", - "w": "139", - "h": "20", - "measuredW": "150", - "measuredH": "100", - "x": "214", - "y": "2011", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 139.02018767861347, - "y": 2.154306179564628 - }, - "p1": { - "x": 0.4858098449650881, - "y": -0.061152098125993315 - }, - "p2": { - "x": -0.07155718747549145, - "y": 19.662703999658106 - } - } - }, - { - "ID": "509", - "typeID": "Arrow", - "zOrder": "55", - "w": "139", - "h": "69", - "measuredW": "150", - "measuredH": "100", - "x": "219", - "y": "2020", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 138.92324584081643, - "y": -0.30828293749846125 - }, - "p1": { - "x": 0.5636378966354441, - "y": -0.11312583844916659 - }, - "p2": { - "x": 0.0032645783990972177, - "y": 68.33453133334342 - } - } - }, - { - "ID": "510", - "typeID": "Arrow", - "zOrder": "54", - "w": "581", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "507", - "y": "1999", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 580.6617356486911, - "y": -0.09227918998158202 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459161 - }, - "p2": { - "x": 0, - "y": -0.09227918998158202 - } - } - }, - { - "ID": "525", - "typeID": "Arrow", - "zOrder": "53", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "675", - "y": "1909", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "526", - "typeID": "Arrow", - "zOrder": "52", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "783", - "y": "1909", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "527", - "typeID": "Arrow", - "zOrder": "51", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "877", - "y": "1909", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "536", - "typeID": "Arrow", - "zOrder": "49", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1157", - "y": "1909", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "537", - "typeID": "Arrow", - "zOrder": "50", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1062", - "y": "1913", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "538", - "typeID": "Arrow", - "zOrder": "48", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1247", - "y": "1906", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "539", - "typeID": "Arrow", - "zOrder": "47", - "w": "128", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "1259", - "y": "1999", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.08040012395417762, - "y": 0 - }, - "p1": { - "x": 0.5, - "y": 0 - }, - "p2": { - "x": 127.74828354307192, - "y": 0 - } - } - }, - { - "ID": "542", - "typeID": "Arrow", - "zOrder": "174", - "w": "1", - "h": "172", - "measuredW": "150", - "measuredH": "100", - "x": "1386", - "y": "1999", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.08040012395417762, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": -0.08040012395417762, - "y": 172.23758949554622 - } - } - }, - { - "ID": "543", - "typeID": "Arrow", - "zOrder": "46", - "w": "903", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "484", - "y": "2173", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.2315946626408163, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": 902.7482835430719, - "y": 0 - } - } - }, - { - "ID": "550", - "typeID": "Arrow", - "zOrder": "45", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1052", - "y": "2174", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "551", - "typeID": "Arrow", - "zOrder": "43", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1145", - "y": "2172", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "552", - "typeID": "Arrow", - "zOrder": "44", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1242", - "y": "2178", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "555", - "typeID": "Arrow", - "zOrder": "37", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "776", - "y": "2172", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "556", - "typeID": "Arrow", - "zOrder": "38", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "866", - "y": "2178", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "557", - "typeID": "Arrow", - "zOrder": "39", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "686", - "y": "2174", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "572", - "typeID": "Arrow", - "zOrder": "36", - "w": "110", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "246", - "y": "2173", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.49988962694184125, - "y": 0 - }, - "p2": { - "x": 110, - "y": 0 - }, - "stroke": "dotted" - } - }, - { - "ID": "573", - "typeID": "Arrow", - "zOrder": "35", - "w": "103", - "h": "46", - "measuredW": "150", - "measuredH": "100", - "x": "247", - "y": "2188", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "stroke": "dotted", - "p0": { - "x": -0.21273916911744095, - "y": 45.34299288345028 - }, - "p1": { - "x": 0.5373835310182236, - "y": 0.09908460035431385 - }, - "p2": { - "x": 102.75148223714478, - "y": -0.41888329711082406 - } - } - }, - { - "ID": "574", - "typeID": "Arrow", - "zOrder": "34", - "w": "141", - "h": "93", - "measuredW": "150", - "measuredH": "100", - "x": "250", - "y": "2192", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "stroke": "dotted", - "p0": { - "x": 0.0559662723511849, - "y": 93.64227994694875 - }, - "p1": { - "x": 0.4586269254089054, - "y": 0.1240568294915703 - }, - "p2": { - "x": 140.61030025550286, - "y": 0.48417486509242735 - } - } - }, - { - "ID": "575", - "typeID": "Arrow", - "zOrder": "33", - "w": "1", - "h": "283", - "measuredW": "150", - "measuredH": "100", - "x": "490", - "y": "2172", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459159 - }, - "p2": { - "x": 0, - "y": 282.91031929587234 - } - } - }, - { - "ID": "590", - "typeID": "Arrow", - "zOrder": "32", - "w": "110", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "247", - "y": "2439", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.49988962694184125, - "y": 0 - }, - "p2": { - "x": 110, - "y": 0 - }, - "stroke": "dotted" - } - }, - { - "ID": "591", - "typeID": "Arrow", - "zOrder": "31", - "w": "113", - "h": "41", - "measuredW": "150", - "measuredH": "100", - "x": "247", - "y": "2384", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "stroke": "dotted", - "p0": { - "x": -0.21273916911744095, - "y": -0.2965568089921362 - }, - "p1": { - "x": 0.4469574548884744, - "y": -0.10632047047599992 - }, - "p2": { - "x": 112.55759856155072, - "y": 40.56226120936617 - } - } - }, - { - "ID": "592", - "typeID": "Arrow", - "zOrder": "30", - "w": "111", - "h": "51", - "measuredW": "150", - "measuredH": "100", - "x": "247", - "y": "2452", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "stroke": "dotted", - "p0": { - "x": -0.21273916911744095, - "y": 51.011191804613645 - }, - "p1": { - "x": 0.3958302309548188, - "y": 0.10460609338599246 - }, - "p2": { - "x": 110.92324584081643, - "y": -0.01938981741614043 - } - } - }, - { - "ID": "593", - "typeID": "Arrow", - "zOrder": "29", - "w": "903", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "499", - "y": "2440", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.2315946626408163, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": 902.7482835430719, - "y": 0 - } - } - }, - { - "ID": "606", - "typeID": "Arrow", - "zOrder": "26", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "775", - "y": "2364", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "607", - "typeID": "Arrow", - "zOrder": "27", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "865", - "y": "2361", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "608", - "typeID": "Arrow", - "zOrder": "28", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "685", - "y": "2357", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "609", - "typeID": "Arrow", - "zOrder": "25", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "706", - "y": "2441", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "610", - "typeID": "Arrow", - "zOrder": "24", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "839", - "y": "2445", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "613", - "typeID": "Arrow", - "zOrder": "18", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1145", - "y": "2362", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "614", - "typeID": "Arrow", - "zOrder": "19", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1235", - "y": "2359", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "615", - "typeID": "Arrow", - "zOrder": "20", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1055", - "y": "2355", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "624", - "typeID": "Arrow", - "zOrder": "194", - "w": "1", - "h": "196", - "measuredW": "150", - "measuredH": "100", - "x": "1403", - "y": "2440", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": -0.08040012395417762, - "y": 0 - }, - "p1": { - "x": 0.49999999999999994, - "y": 0 - }, - "p2": { - "x": -0.08040012395417762, - "y": 196 - } - } - }, - { - "ID": "627", - "typeID": "Arrow", - "zOrder": "17", - "w": "560", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "841", - "y": "2636", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0.25442776906936615, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": 560.7482835430719, - "y": 0 - } - } - }, - { - "ID": "634", - "typeID": "Arrow", - "zOrder": "16", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1112", - "y": "2547", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "635", - "typeID": "Arrow", - "zOrder": "15", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1212", - "y": "2547", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "636", - "typeID": "Arrow", - "zOrder": "14", - "w": "1", - "h": "89", - "measuredW": "150", - "measuredH": "100", - "x": "1288", - "y": "2547", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": -0.21115152072133014, - "y": 88.6627039996581 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459767 - }, - "p2": { - "x": -0.211151520721387, - "y": -0.2503842718381293 - } - } - }, - { - "ID": "645", - "typeID": "Arrow", - "zOrder": "13", - "w": "149", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "498", - "y": "2640", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 149.11879059159185, - "y": -0.3372960003416665 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459798 - }, - "p2": { - "x": 0.43647605231535636, - "y": -0.3372960003416665 - } - } - }, - { - "ID": "646", - "typeID": "Arrow", - "zOrder": "12", - "w": "111", - "h": "39", - "measuredW": "150", - "measuredH": "100", - "x": "525", - "y": "2585", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 111.58429865172877, - "y": 37.58356560593711 - }, - "p1": { - "x": 0.4167802882873299, - "y": 0.08803553433262563 - }, - "p2": { - "x": 0.43647605231535636, - "y": -0.3372960003416665 - } - } - }, - { - "ID": "647", - "typeID": "Arrow", - "zOrder": "11", - "w": "110", - "h": "41", - "measuredW": "150", - "measuredH": "100", - "x": "525", - "y": "2653", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 110.07937123174827, - "y": -0.317885994453718 - }, - "p1": { - "x": 0.4256646028559527, - "y": -0.07878450113435448 - }, - "p2": { - "x": 0.43647605231535636, - "y": 40.66270399965833 - } - } - }, - { - "ID": "648", - "typeID": "Arrow", - "zOrder": "10", - "w": "1", - "h": "117", - "measuredW": "150", - "measuredH": "100", - "x": "756", - "y": "2633", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459161 - }, - "p2": { - "x": 0, - "y": 116.7794971141675 - } - } - }, - { - "ID": "657", - "typeID": "Arrow", - "zOrder": "9", - "w": "142", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "966", - "y": "2759", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 0.1634036274464279, - "y": 0.28442453414800184 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459793 - }, - "p2": { - "x": 142.5402181279353, - "y": -0.3372960003416665 - } - } - }, - { - "ID": "658", - "typeID": "Arrow", - "zOrder": "8", - "w": "129", - "h": "46", - "measuredW": "150", - "measuredH": "100", - "x": "963", - "y": "2773", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 0.15354878748553347, - "y": 1.3336987339525876 - }, - "p1": { - "x": 0.4304540139626095, - "y": 0.09558239666808163 - }, - "p2": { - "x": 129.57730690580388, - "y": 46.48152133336589 - } - } - }, - { - "ID": "659", - "typeID": "Arrow", - "zOrder": "7", - "w": "141", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "758", - "y": "2750", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0.25442776906936615, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": 141.015581028033, - "y": 0 - } - } - }, - { - "ID": "660", - "typeID": "Arrow", - "zOrder": "6", - "w": "364", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "521", - "y": "2768", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0.4573510232245326, - "y": 0 - }, - "p1": { - "x": 0.4999999999999999, - "y": 0 - }, - "p2": { - "x": 364.015581028033, - "y": 0 - } - } - }, - { - "ID": "667", - "typeID": "Arrow", - "zOrder": "5", - "w": "118", - "h": "5", - "measuredW": "150", - "measuredH": "100", - "x": "290", - "y": "2764", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 117.3564720416407, - "y": -0.200793205910486 - }, - "p1": { - "x": 0.44386240125497256, - "y": -0.00008403832147459404 - }, - "p2": { - "x": -0.4933747769709953, - "y": 4.6627039996583335 - } - } - }, - { - "ID": "668", - "typeID": "Arrow", - "zOrder": "4", - "w": "110", - "h": "42", - "measuredW": "150", - "measuredH": "100", - "x": "293", - "y": "2780", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 109.84168978169942, - "y": 0.3534084138741491 - }, - "p1": { - "x": 0.47104569195055057, - "y": -0.0920191932119486 - }, - "p2": { - "x": -0.018011876873174515, - "y": 42.4913761733269 - } - } - }, - { - "ID": "669", - "typeID": "Arrow", - "zOrder": "3", - "w": "1", - "h": "117", - "measuredW": "150", - "measuredH": "100", - "x": "462", - "y": "2772", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459161 - }, - "p2": { - "x": 0, - "y": 116.7794971141675 - } - } - }, - { - "ID": "674", - "typeID": "Arrow", - "zOrder": "2", - "w": "193", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "462", - "y": "2888", - "properties": { - "leftArrow": "false", - "rightArrow": "false", - "color": "10027263", - "p0": { - "x": 0.4573510232245326, - "y": 0 - }, - "p1": { - "x": 0.4999999999999998, - "y": 0 - }, - "p2": { - "x": 193.3019545368494, - "y": 0 - } - } - }, - { - "ID": "675", - "typeID": "Arrow", - "zOrder": "1", - "w": "142", - "h": "1", - "measuredW": "150", - "measuredH": "100", - "x": "856", - "y": "2939", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "stroke": "dotted", - "p0": { - "x": 0.1634036274464279, - "y": 0.28442453414800184 - }, - "p1": { - "x": 0.44386240125497245, - "y": -0.00008403832147459793 - }, - "p2": { - "x": 142.5402181279353, - "y": -0.3372960003416665 - } - } - }, - { - "ID": "679", - "typeID": "Arrow", - "zOrder": "0", - "w": "1", - "h": "117", - "measuredW": "150", - "measuredH": "100", - "x": "754", - "y": "2940", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459161 - }, - "p2": { - "x": 0, - "y": 116.7794971141675 - } - } - }, - { - "ID": "680", - "typeID": "Label", - "zOrder": "212", - "measuredW": "187", - "measuredH": "36", - "x": "669", - "y": "3075", - "properties": { - "size": "28", - "text": "Keep Learning" - } - }, - { - "ID": "681", - "typeID": "Arrow", - "zOrder": "213", - "w": "1", - "h": "84", - "measuredW": "150", - "measuredH": "100", - "x": "754", - "y": "3128", - "properties": { - "color": "2848996", - "curvature": "-1", - "direction": "bottom", - "leftArrow": "false", - "rightArrow": "false", - "p0": { - "x": 0, - "y": 0 - }, - "p1": { - "x": 0.4438624012549724, - "y": -0.00008403832147459163 - }, - "p2": { - "x": 0, - "y": 83.7885919892492 - }, - "stroke": "dotted" - } - }, - { - "ID": "682", - "typeID": "__group__", - "zOrder": "214", - "measuredW": "423", - "measuredH": "200", - "w": "423", - "h": "200", - "x": "128", - "y": "185", - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Canvas", - "zOrder": "0", - "w": "423", - "h": "200", - "measuredW": "100", - "measuredH": "70", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "__group__", - "zOrder": "1", - "measuredW": "189", - "measuredH": "27", - "w": "189", - "h": "27", - "x": "28", - "y": "77", - "properties": { - "controlName": "ext_link:roadmap.sh/backend" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Label", - "zOrder": "0", - "measuredW": "156", - "measuredH": "26", - "x": "33", - "y": "0", - "properties": { - "size": "18", - "text": "Backend Roadmap" - } - }, - { - "ID": "1", - "typeID": "__group__", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "w": "24", - "h": "24", - "x": "0", - "y": "3", - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Icon", - "zOrder": "0", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "16777215", - "icon": { - "ID": "circle", - "size": "small" - } - } - }, - { - "ID": "1", - "typeID": "Icon", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "10066329", - "icon": { - "ID": "check-circle", - "size": "small" - } - } - } - ] - } - } - } - ] - } - } - }, - { - "ID": "2", - "typeID": "__group__", - "zOrder": "2", - "measuredW": "183", - "measuredH": "27", - "w": "183", - "h": "27", - "x": "28", - "y": "113", - "properties": { - "controlName": "ext_link:roadmap.sh/devops" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Label", - "zOrder": "0", - "measuredW": "150", - "measuredH": "26", - "x": "33", - "y": "0", - "properties": { - "size": "18", - "text": "DevOps Roadmap" - } - }, - { - "ID": "1", - "typeID": "__group__", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "w": "24", - "h": "24", - "x": "0", - "y": "3", - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Icon", - "zOrder": "0", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "16777215", - "icon": { - "ID": "circle", - "size": "small" - } - } - }, - { - "ID": "1", - "typeID": "Icon", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "10066329", - "icon": { - "ID": "check-circle", - "size": "small" - } - } - } - ] - } - } - } - ] - } - } - }, - { - "ID": "3", - "typeID": "Label", - "zOrder": "3", - "measuredW": "209", - "measuredH": "32", - "x": "28", - "y": "29", - "properties": { - "size": "24", - "text": "Related Roadmaps" - } - }, - { - "ID": "4", - "typeID": "__group__", - "zOrder": "4", - "measuredW": "141", - "measuredH": "27", - "w": "141", - "h": "27", - "x": "28", - "y": "151", - "properties": { - "controlName": "ext_link:roadmap.sh/golang" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Label", - "zOrder": "0", - "measuredW": "108", - "measuredH": "26", - "x": "33", - "y": "0", - "properties": { - "size": "18", - "text": "Go Roadmap" - } - }, - { - "ID": "1", - "typeID": "__group__", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "w": "24", - "h": "24", - "x": "0", - "y": "3", - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "Icon", - "zOrder": "0", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "16777215", - "icon": { - "ID": "circle", - "size": "small" - } - } - }, - { - "ID": "1", - "typeID": "Icon", - "zOrder": "1", - "measuredW": "24", - "measuredH": "24", - "x": "0", - "y": "0", - "properties": { - "color": "10066329", - "icon": { - "ID": "check-circle", - "size": "small" - } - } - } - ] - } - } - } - ] - } - } - } - ] - } - } - }, - { - "ID": "683", - "typeID": "__group__", - "zOrder": "88", - "measuredW": "204", - "measuredH": "50", - "w": "204", - "h": "50", - "x": "703", - "y": "523", - "properties": { - "controlName": "100-introduction" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "204", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "93", - "measuredH": "25", - "x": "60", - "y": "13", - "properties": { - "size": "17", - "text": "Introduction" - } - } - ] - } - } - }, - { - "ID": "686", - "typeID": "__group__", - "zOrder": "92", - "measuredW": "243", - "measuredH": "50", - "w": "243", - "h": "50", - "x": "272", - "y": "745", - "properties": { - "controlName": "101-language-basics" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "243", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "134", - "measuredH": "25", - "x": "55", - "y": "13", - "properties": { - "size": "17", - "text": "Language Basics" - } - } - ] - } - } - }, - { - "ID": "687", - "typeID": "__group__", - "zOrder": "132", - "measuredW": "243", - "measuredH": "50", - "w": "243", - "h": "50", - "x": "272", - "y": "1114", - "properties": { - "controlName": "102-error-handling" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "243", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "113", - "measuredH": "25", - "x": "65", - "y": "13", - "properties": { - "size": "17", - "text": "Error Handling" - } - } - ] - } - } - }, - { - "ID": "688", - "typeID": "__group__", - "zOrder": "136", - "measuredW": "243", - "measuredH": "50", - "w": "243", - "h": "50", - "x": "675", - "y": "1287", - "properties": { - "controlName": "103-modules-and-crates" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "243", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "155", - "measuredH": "25", - "x": "52", - "y": "13", - "properties": { - "size": "17", - "text": "Modules and Crates" - } - } - ] - } - } - }, - { - "ID": "689", - "typeID": "__group__", - "zOrder": "140", - "measuredW": "280", - "measuredH": "50", - "w": "280", - "h": "50", - "x": "1105", - "y": "1061", - "properties": { - "controlName": "104-concurrency-parallelism" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "280", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "218", - "measuredH": "25", - "x": "31", - "y": "13", - "properties": { - "size": "17", - "text": "Concurrency and Parallelism" - } - } - ] - } - } - }, - { - "ID": "690", - "typeID": "__group__", - "zOrder": "144", - "measuredW": "280", - "measuredH": "50", - "w": "280", - "h": "50", - "x": "1145", - "y": "1566", - "properties": { - "controlName": "105-traits-generics" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "280", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "151", - "measuredH": "25", - "x": "64", - "y": "13", - "properties": { - "size": "17", - "text": "Traits and Generics" - } - } - ] - } - } - }, - { - "ID": "691", - "typeID": "__group__", - "zOrder": "148", - "measuredW": "280", - "measuredH": "50", - "w": "280", - "h": "50", - "x": "657", - "y": "1567", - "properties": { - "controlName": "106-lifetimes-borrow" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "280", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "232", - "measuredH": "25", - "x": "24", - "y": "13", - "properties": { - "size": "17", - "text": "Lifetimes and Borrow Checker" - } - } - ] - } - } - }, - { - "ID": "692", - "typeID": "__group__", - "zOrder": "152", - "measuredW": "280", - "measuredH": "50", - "w": "280", - "h": "50", - "x": "254", - "y": "1673", - "properties": { - "controlName": "107-macros" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "280", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "237", - "measuredH": "25", - "x": "21", - "y": "13", - "properties": { - "size": "17", - "text": "Macros and Metaprogramming" - } - } - ] - } - } - }, - { - "ID": "693", - "typeID": "__group__", - "zOrder": "160", - "measuredW": "196", - "measuredH": "50", - "w": "196", - "h": "50", - "x": "338", - "y": "1974", - "properties": { - "controlName": "108-web-development" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "196", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "142", - "measuredH": "25", - "x": "27", - "y": "13", - "properties": { - "size": "17", - "text": "Web Development" - } - } - ] - } - } - }, - { - "ID": "694", - "typeID": "__group__", - "zOrder": "165", - "measuredW": "281", - "measuredH": "50", - "w": "281", - "h": "50", - "x": "633", - "y": "1975", - "properties": { - "controlName": "109-async-programming" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "281", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "215", - "measuredH": "25", - "x": "33", - "y": "12", - "properties": { - "size": "17", - "text": "Asynchronous Programming" - } - } - ] - } - } - }, - { - "ID": "695", - "typeID": "__group__", - "zOrder": "169", - "measuredW": "273", - "measuredH": "50", - "w": "273", - "h": "50", - "x": "1010", - "y": "1975", - "properties": { - "controlName": "110-networking" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "273", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "87", - "measuredH": "25", - "x": "97", - "y": "12", - "properties": { - "size": "17", - "text": "Networking" - } - } - ] - } - } - }, - { - "ID": "696", - "typeID": "__group__", - "zOrder": "173", - "measuredW": "273", - "measuredH": "50", - "w": "273", - "h": "50", - "x": "1009", - "y": "2148", - "properties": { - "controlName": "111-serialization" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "273", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "216", - "measuredH": "25", - "x": "34", - "y": "12", - "properties": { - "size": "17", - "text": "Serialization/Deserialization" - } - } - ] - } - } - }, - { - "ID": "697", - "typeID": "__group__", - "zOrder": "178", - "measuredW": "273", - "measuredH": "50", - "w": "273", - "h": "50", - "x": "640", - "y": "2148", - "properties": { - "controlName": "112-database-orm" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "273", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "152", - "measuredH": "25", - "x": "61", - "y": "12", - "properties": { - "size": "17", - "text": "Database and ORM" - } - } - ] - } - } - }, - { - "ID": "698", - "typeID": "__group__", - "zOrder": "179", - "measuredW": "196", - "measuredH": "50", - "w": "196", - "h": "50", - "x": "338", - "y": "2148", - "properties": { - "controlName": "113-cryptography" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "196", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "103", - "measuredH": "25", - "x": "46", - "y": "12", - "properties": { - "size": "17", - "text": "Cryptography" - } - } - ] - } - } - }, - { - "ID": "699", - "typeID": "__group__", - "zOrder": "183", - "measuredW": "196", - "measuredH": "50", - "w": "196", - "h": "50", - "x": "338", - "y": "2415", - "properties": { - "controlName": "114-cli-utils" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "196", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "89", - "measuredH": "25", - "x": "46", - "y": "12", - "properties": { - "size": "17", - "text": "CLI Utilities" - } - } - ] - } - } - }, - { - "ID": "700", - "typeID": "__group__", - "zOrder": "187", - "measuredW": "273", - "measuredH": "50", - "w": "273", - "h": "50", - "x": "640", - "y": "2415", - "properties": { - "controlName": "115-game-dev" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "273", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "154", - "measuredH": "25", - "x": "61", - "y": "12", - "properties": { - "size": "17", - "text": "Game Development" - } - } - ] - } - } - }, - { - "ID": "701", - "typeID": "__group__", - "zOrder": "193", - "measuredW": "273", - "measuredH": "50", - "w": "273", - "h": "50", - "x": "1009", - "y": "2415", - "properties": { - "controlName": "116-gui-dev" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "273", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "138", - "measuredH": "25", - "x": "67", - "y": "12", - "properties": { - "size": "17", - "text": "GUI Development" - } - } - ] - } - } - }, - { - "ID": "702", - "typeID": "__group__", - "zOrder": "195", - "measuredW": "297", - "measuredH": "50", - "w": "297", - "h": "50", - "x": "1031", - "y": "2612", - "properties": { - "controlName": "117-embedded" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "297", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "187", - "measuredH": "25", - "x": "55", - "y": "12", - "properties": { - "size": "17", - "text": "Embedded and Systems" - } - } - ] - } - } - }, - { - "ID": "703", - "typeID": "__group__", - "zOrder": "199", - "measuredW": "297", - "measuredH": "50", - "w": "297", - "h": "50", - "x": "627", - "y": "2612", - "properties": { - "controlName": "118-wasm" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "297", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "172", - "measuredH": "25", - "x": "54", - "y": "12", - "properties": { - "size": "17", - "text": "WebAssembly (WASM)" - } - } - ] - } - } - }, - { - "ID": "704", - "typeID": "__group__", - "zOrder": "203", - "measuredW": "130", - "measuredH": "50", - "w": "130", - "h": "50", - "x": "852", - "y": "2735", - "properties": { - "controlName": "119-testing" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "130", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "56", - "measuredH": "25", - "x": "37", - "y": "12", - "properties": { - "size": "17", - "text": "Testing" - } - } - ] - } - } - }, - { - "ID": "705", - "typeID": "__group__", - "zOrder": "207", - "measuredW": "144", - "measuredH": "50", - "w": "144", - "h": "50", - "x": "391", - "y": "2744", - "properties": { - "controlName": "120-debugging" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "144", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "85", - "measuredH": "25", - "x": "29", - "y": "12", - "properties": { - "size": "17", - "text": "Debugging" - } - } - ] - } - } - }, - { - "ID": "706", - "typeID": "__group__", - "zOrder": "210", - "measuredW": "264", - "measuredH": "50", - "w": "264", - "h": "50", - "x": "642", - "y": "2861", - "properties": { - "controlName": "121-rustdoc" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "264", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "206", - "measuredH": "25", - "x": "29", - "y": "12", - "properties": { - "size": "17", - "text": "Documenting with `rustdoc`" - } - } - ] - } - } - }, - { - "ID": "707", - "typeID": "__group__", - "zOrder": "211", - "measuredW": "264", - "measuredH": "50", - "w": "264", - "h": "50", - "x": "643", - "y": "2915", - "properties": { - "controlName": "122-perf-profiling" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "264", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16776960" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "199", - "measuredH": "25", - "x": "31", - "y": "12", - "properties": { - "size": "17", - "text": "Performance and Profiling" - } - } - ] - } - } - }, - { - "ID": "708", - "typeID": "__group__", - "zOrder": "89", - "measuredW": "180", - "measuredH": "50", - "w": "180", - "h": "50", - "x": "1063", - "y": "471", - "properties": { - "controlName": "100-introduction:what-is-rust" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "180", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "105", - "measuredH": "25", - "x": "37", - "y": "13", - "properties": { - "size": "17", - "text": "What is Rust?" - } - } - ] - } - } - }, - { - "ID": "709", - "typeID": "__group__", - "zOrder": "93", - "measuredW": "184", - "measuredH": "50", - "w": "184", - "h": "50", - "x": "1249", - "y": "471", - "properties": { - "controlName": "101-introduction:why-rust" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "184", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "112", - "measuredH": "25", - "x": "36", - "y": "13", - "properties": { - "size": "17", - "text": "Why use Rust?" - } - } - ] - } - } - }, - { - "ID": "710", - "typeID": "__group__", - "zOrder": "90", - "measuredW": "370", - "measuredH": "50", - "w": "370", - "h": "50", - "x": "1063", - "y": "527", - "properties": { - "controlName": "102-introduction:memory-safety" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "370", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "328", - "measuredH": "25", - "x": "21", - "y": "12", - "properties": { - "size": "17", - "text": "Memory Safety and Zero-Cost Abstractions" - } - } - ] - } - } - }, - { - "ID": "711", - "typeID": "__group__", - "zOrder": "95", - "measuredW": "370", - "measuredH": "50", - "w": "370", - "h": "50", - "x": "1063", - "y": "632", - "properties": { - "controlName": "103-introduction:installing-rust" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "370", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "194", - "measuredH": "25", - "x": "88", - "y": "12", - "properties": { - "size": "17", - "text": "Installing Rust and Cargo" - } - } - ] - } - } - }, - { - "ID": "713", - "typeID": "__group__", - "zOrder": "96", - "measuredW": "370", - "measuredH": "50", - "w": "370", - "h": "50", - "x": "1063", - "y": "679", - "properties": { - "controlName": "104-introduction:ides-and-rust" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "370", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "197", - "measuredH": "25", - "x": "86", - "y": "12", - "properties": { - "size": "17", - "text": "IDEs and Rust Toolchains" - } - } - ] - } - } - }, - { - "ID": "714", - "typeID": "__group__", - "zOrder": "97", - "measuredW": "370", - "measuredH": "50", - "w": "370", - "h": "50", - "x": "1063", - "y": "726", - "properties": { - "controlName": "105-introduction:rust-repl" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "370", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "226", - "measuredH": "25", - "x": "86", - "y": "12", - "properties": { - "size": "17", - "text": "Rust REPL (Rust Playground)" - } - } - ] - } - } - }, - { - "ID": "715", - "typeID": "__group__", - "zOrder": "98", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "650", - "properties": { - "controlName": "100-language-basics:syntax" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "169", - "measuredH": "25", - "x": "76", - "y": "13", - "properties": { - "size": "17", - "text": "Syntax and Semantics" - } - } - ] - } - } - }, - { - "ID": "716", - "typeID": "__group__", - "zOrder": "102", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "844", - "properties": { - "controlName": "101-language-basics:ownership" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "152", - "measuredH": "25", - "x": "85", - "y": "13", - "properties": { - "size": "17", - "text": "Onwnership System" - } - } - ] - } - } - }, - { - "ID": "717", - "typeID": "__group__", - "zOrder": "131", - "measuredW": "351", - "measuredH": "50", - "w": "351", - "h": "50", - "x": "617", - "y": "713", - "properties": { - "controlName": "102-language-basics:constructs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "351", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "84", - "measuredH": "25", - "x": "134", - "y": "13", - "properties": { - "size": "17", - "text": "Constructs" - } - } - ] - } - } - }, - { - "ID": "718", - "typeID": "__group__", - "zOrder": "107", - "measuredW": "352", - "measuredH": "50", - "w": "352", - "h": "50", - "x": "616", - "y": "778", - "properties": { - "controlName": "103-language-basics:data-structures" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "352", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0" - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "120", - "measuredH": "25", - "x": "101", - "y": "13", - "properties": { - "size": "17", - "text": "Data Structures" - } - } - ] - } - } - }, - { - "ID": "719", - "typeID": "__group__", - "zOrder": "99", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "603", - "properties": { - "controlName": "101-language-basics:syntax:variables" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "282", - "measuredH": "25", - "x": "20", - "y": "13", - "properties": { - "size": "17", - "text": "Variables, Constants, and Data Types" - } - } - ] - } - } - }, - { - "ID": "720", - "typeID": "__group__", - "zOrder": "100", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "556", - "properties": { - "controlName": "102-language-basics:syntax:control-flow" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "183", - "measuredH": "25", - "x": "69", - "y": "13", - "properties": { - "size": "17", - "text": "Control Flow Constructs" - } - } - ] - } - } - }, - { - "ID": "721", - "typeID": "__group__", - "zOrder": "101", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "511", - "properties": { - "controlName": "103-language-basics:syntax:functions" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "227", - "measuredH": "25", - "x": "47", - "y": "13", - "properties": { - "size": "17", - "text": "Functions and Method Syntax" - } - } - ] - } - } - }, - { - "ID": "722", - "typeID": "__group__", - "zOrder": "106", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "465", - "properties": { - "controlName": "104-language-basics:syntax:pattern-matching" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "275", - "measuredH": "25", - "x": "23", - "y": "13", - "properties": { - "size": "17", - "text": "Pattern Matching and Destructuring" - } - } - ] - } - } - }, - { - "ID": "723", - "typeID": "__group__", - "zOrder": "103", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "891", - "properties": { - "controlName": "100-language-basics:ownership:rules" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "282", - "measuredH": "25", - "x": "20", - "y": "13", - "properties": { - "size": "17", - "text": "Ownership Rules and Memory Safety" - } - } - ] - } - } - }, - { - "ID": "724", - "typeID": "__group__", - "zOrder": "104", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "938", - "properties": { - "controlName": "101-language-basics:ownership:borrowing" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "262", - "measuredH": "25", - "x": "30", - "y": "13", - "properties": { - "size": "17", - "text": "Borrowing, References, and Slices" - } - } - ] - } - } - }, - { - "ID": "725", - "typeID": "__group__", - "zOrder": "105", - "measuredW": "321", - "measuredH": "50", - "w": "321", - "h": "50", - "x": "131", - "y": "985", - "properties": { - "controlName": "102-language-basics:ownership:stack-heap" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "321", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "199", - "measuredH": "25", - "x": "61", - "y": "13", - "properties": { - "size": "17", - "text": "Deep Dive: Stack vs Heap" - } - } - ] - } - } - }, - { - "ID": "726", - "typeID": "__group__", - "zOrder": "127", - "measuredW": "84", - "measuredH": "50", - "w": "84", - "h": "50", - "x": "617", - "y": "666", - "properties": { - "controlName": "100-language-basics:constructs:enums" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "84", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "53", - "measuredH": "25", - "x": "15", - "y": "12", - "properties": { - "size": "17", - "text": "Enums" - } - } - ] - } - } - }, - { - "ID": "727", - "typeID": "__group__", - "zOrder": "128", - "measuredW": "83", - "measuredH": "50", - "w": "83", - "h": "50", - "x": "696", - "y": "666", - "properties": { - "controlName": "101-language-basics:constructs:structs" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "83", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "54", - "measuredH": "25", - "x": "15", - "y": "12", - "properties": { - "size": "17", - "text": "Structs" - } - } - ] - } - } - }, - { - "ID": "728", - "typeID": "__group__", - "zOrder": "129", - "measuredW": "78", - "measuredH": "50", - "w": "78", - "h": "50", - "x": "774", - "y": "666", - "properties": { - "controlName": "102-language-basics:constructs:traits" - }, - "children": { - "controls": { - "control": [ - { - "ID": "0", - "typeID": "TextArea", - "zOrder": "0", - "w": "78", - "h": "50", - "measuredW": "200", - "measuredH": "140", - "x": "0", - "y": "0", - "properties": { - "color": "16770457" - } - }, - { - "ID": "1", - "typeID": "Label", - "zOrder": "1", - "measuredW": "43", - "measuredH": "25", - "x": "19", - "y": "12", - "properties": { - "size": "17", - "text": "Traits" - } - } - ] - } - } - }, { "ID": "732", "typeID": "__group__", @@ -17493,7 +8728,7 @@ } }, { - "ID": "832", + "ID": "834", "typeID": "__group__", "zOrder": "130", "measuredW": "119", @@ -17555,23 +8790,10 @@ "measuredH": "3212", "version": "1.0" }, - "dependencies": [ - { - "resourceID": "7D9032BB-9E61-45F8-9D65-50D01E280EF5", - "branchID": "Master", - "attributes": { - "name": "Project Symbols", - "kind": "symbolLibrary", - "trashed": false, - "importedFrom": "", - "creationDate": 0, - "modifiedBy": null, - "notes": "These are the notes for this Symbol Library. Click to edit them.\n\nUse them to add your name and email if you want to share on Wireframes To Go", - "order": null, - "parentID": null - }, - "data": "{\"mockup\":{\"controls\":{\"control\":[{\"ID\":\"2\",\"typeID\":\"__group__\",\"zOrder\":\"0\",\"measuredW\":\"119\",\"measuredH\":\"50\",\"w\":\"119\",\"h\":\"50\",\"x\":\"6\",\"y\":\"117\",\"properties\":{\"controlName\":\"103-language-basics:constructs:impl-blocks\"},\"children\":{\"controls\":{\"control\":[{\"ID\":\"0\",\"typeID\":\"TextArea\",\"zOrder\":\"0\",\"w\":\"119\",\"h\":\"50\",\"measuredW\":\"200\",\"measuredH\":\"140\",\"x\":\"0\",\"y\":\"0\",\"properties\":{\"color\":\"16770457\"}},{\"ID\":\"1\",\"typeID\":\"Label\",\"zOrder\":\"1\",\"measuredW\":\"89\",\"measuredH\":\"25\",\"x\":\"15\",\"y\":\"12\",\"properties\":{\"size\":\"17\",\"text\":\"Impl Blocks\"}}]}}}]},\"attributes\":{\"name\":\"Project Symbols\",\"order\":null,\"parentID\":null,\"notes\":\"These are the notes for this Symbol Library. Click to edit them.\\n\\nUse them to add your name and email if you want to share on Wireframes To Go\"},\"branchID\":\"Master\",\"resourceID\":\"7D9032BB-9E61-45F8-9D65-50D01E280EF5\",\"mockupH\":\"50\",\"mockupW\":\"119\",\"measuredW\":\"125\",\"measuredH\":\"167\",\"version\":\"1.0\"}}" - } - ], + "groupOffset": { + "x": 0, + "y": 0 + }, + "dependencies": [], "projectID": "file:///Users/kamrify/Desktop/New%20Roadmaps/Android%20Roadmap.bmpr" } \ No newline at end of file