diff --git a/public/roadmap-content/blockchain.json b/public/roadmap-content/blockchain.json index d4863f1fb..590606894 100644 --- a/public/roadmap-content/blockchain.json +++ b/public/roadmap-content/blockchain.json @@ -3,6 +3,11 @@ "title": "Basic Blockchain Knowledge", "description": "A blockchain is a decentralized, distributed, and oftentimes public, digital ledger consisting of records called blocks that is used to record transactions across many computers so that any involved block cannot be altered retroactively, without the alteration of all subsequent blocks.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfirn Updraft | Blockchain Basics", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics", + "type": "course" + }, { "title": "Introduction to Blockchain", "url": "https://chain.link/education-hub/blockchain", @@ -63,6 +68,16 @@ "title": "Explore top posts about Blockchain", "url": "https://app.daily.dev/tags/blockchain?ref=roadmapsh", "type": "article" + }, + { + "title": "Blockchain Architecture Layers: Guide And Topology", + "url": "https://www.cyfrin.io/blog/blockchain-architecture-layers-what-is-it", + "type": "article" + }, + { + "title": "Cyfirn Updraft | How Do Blockchains Work?", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics/basics/how-do-blockchains-work?lesson_format=video", + "type": "video" } ] }, @@ -132,6 +147,11 @@ "title": "What is Blockchain", "description": "A blockchain is a decentralized, distributed, and oftentimes public, digital ledger consisting of records called blocks that is used to record transactions across many computers so that any involved block cannot be altered retroactively, without the alteration of all subsequent blocks.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfirn Updraft | Blockchain Basics", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics", + "type": "course" + }, { "title": "Blockchain Explained", "url": "https://www.investopedia.com/terms/b/blockchain.asp", @@ -190,7 +210,7 @@ } ] }, - "Nc9AH6L7EqeQxh0m6Hddz": { + "why-it-matters@Nc9AH6L7EqeQxh0m6Hddz.md": { "title": "Why it matters?", "description": "", "links": [] @@ -199,6 +219,11 @@ "title": "General Blockchain Knowledge", "description": "A blockchain is a decentralized, distributed ledger technology that records transactions across many computers in such a way that the registered transactions cannot be altered retroactively. This technology is the backbone of cryptocurrencies like Bitcoin and Ethereum, but its applications extend far beyond digital currencies.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfirn Updraft | Blockchain Basics", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics", + "type": "course" + }, { "title": "The Complete Course On Understanding Blockchain Technology", "url": "https://www.udemy.com/course/understanding-blockchain-technology/", @@ -303,6 +328,11 @@ "url": "https://www.nerdwallet.com/article/investing/cryptocurrency", "type": "article" }, + { + "title": "Cyfrin Glossary | Cryptocurrency", + "url": "https://www.cyfrin.io/glossary/cryptocurrency", + "type": "article" + }, { "title": "Explore top posts about Crypto", "url": "https://app.daily.dev/tags/crypto?ref=roadmapsh", @@ -330,9 +360,9 @@ "type": "article" }, { - "title": "Choose your wallet - Ethereum", - "url": "https://ethereum.org/en/wallets/find-wallet/", - "type": "article" + "title": "Cyfrin Updraft | Settin Up a Wallet", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics/basics/setting-up-your-wallet", + "type": "video" } ] }, @@ -385,6 +415,11 @@ "title": "What Is a Consensus Mechanism?", "url": "https://www.coindesk.com/learn/what-is-a-consensus-mechanism/", "type": "article" + }, + { + "title": "Consensus Algorithm", + "url": "https://www.cyfrin.io/glossary/consensus-algorithm", + "type": "article" } ] }, @@ -833,6 +868,11 @@ "title": "Explore top posts about Blockchain", "url": "https://app.daily.dev/tags/blockchain?ref=roadmapsh", "type": "article" + }, + { + "title": "Cyfrin Updraft | L1s L2s and Rollups", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics/basics/l1s-l2s-and-rollups", + "type": "video" } ] }, @@ -944,6 +984,11 @@ "title": "What Is Chainlink in 5 Minutes", "url": "https://www.gemini.com/cryptopedia/what-is-chainlink-and-how-does-it-work", "type": "article" + }, + { + "title": "Cyfrin Updraft | Getting real world price data from chainlink", + "url": "https://updraft.cyfrin.io/courses/solidity/fund-me/getting-prices-from-chainlink", + "type": "video" } ] }, @@ -970,6 +1015,11 @@ "title": "Explore top posts about Oracle", "url": "https://app.daily.dev/tags/oracle?ref=roadmapsh", "type": "article" + }, + { + "title": "Cyfrin Updraft | Intro to oracles", + "url": "https://updraft.cyfrin.io/courses/solidity/fund-me/real-world-price-data", + "type": "video" } ] }, @@ -977,6 +1027,11 @@ "title": "Smart Contracts", "description": "A smart contract is a computer program or a transaction protocol that is intended to automatically execute, control or document legally relevant events and actions according to the terms of a contract or an agreement.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfirn Updraft | Solidity Smart Contract Development", + "url": "https://updraft.cyfrin.io/courses/solidity", + "type": "course" + }, { "title": "Smart Contracts", "url": "https://www.ibm.com/topics/smart-contracts", @@ -1008,6 +1063,11 @@ "title": "Solidity", "description": "Solidity is an object-oriented programming language created specifically by Ethereum Network team for constructing smart contracts on various blockchain platforms, most notably, Ethereum. It's used to create smart contracts that implements business logic and generate a chain of transaction records in the blockchain system. It acts as a tool for creating machine-level code and compiling it on the Ethereum Virtual Machine (EVM).\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfirn Updraft | Solidity Smart Contract Development", + "url": "https://updraft.cyfrin.io/courses/solidity", + "type": "course" + }, { "title": "Solidity Programming Language", "url": "https://soliditylang.org/", @@ -1044,6 +1104,11 @@ "title": "Vyper", "description": "Vyper is a contract-oriented, pythonic programming language that targets the Ethereum Virtual Machine (EVM).\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Vyper Smart Contract Development", + "url": "https://updraft.cyfrin.io/courses/intro-python-vyper-smart-contract-development", + "type": "course" + }, { "title": "Vyper Programming Language", "url": "https://vyper.readthedocs.io/en/stable/", @@ -1163,6 +1228,11 @@ "title": "Explore top posts about CI/CD", "url": "https://app.daily.dev/tags/cicd?ref=roadmapsh", "type": "article" + }, + { + "title": "Cyfrin Updraft | Deploying Your First Smart Contract", + "url": "https://updraft.cyfrin.io/courses/solidity/simple-storage/deploying-solidity-smart-contract", + "type": "video" } ] }, @@ -1205,6 +1275,11 @@ "title": "Upgrading your Smart Contracts | A Tutorial & Introduction", "url": "https://youtu.be/bdXJmWajZRY", "type": "video" + }, + { + "title": "Cyfrin Updraft | Introduction to Upgradable Smart Contracts", + "url": "https://updraft.cyfrin.io/courses/advanced-foundry/upgradeable-smart-contracts/introduction-to-upgradeable-smart-contracts", + "type": "video" } ] }, @@ -1231,6 +1306,21 @@ "title": "ERC-1155 Token Standard (Multi-Token)", "url": "https://decrypt.co/resources/what-is-erc-1155-ethereums-flexible-token-standard", "type": "article" + }, + { + "title": "ERC3675", + "url": "https://www.cyfrin.io/glossary/erc-3675", + "type": "article" + }, + { + "title": "ERC4337", + "url": "https://www.cyfrin.io/glossary/erc-4337", + "type": "article" + }, + { + "title": "Cyfrin Updraft | Introduction To ERC Fundamentals and ERC20", + "url": "https://updraft.cyfrin.io/courses/advanced-foundry/How-to-create-an-erc20-crypto-currency/erc-and-erc20-fundamentals", + "type": "video" } ] }, @@ -1238,6 +1328,11 @@ "title": "Crypto Wallets", "description": "A cryptocurrency wallet is a device, physical medium, program, or service which stores the public and/or private keys for cryptocurrency transactions. In addition to this basic function of storing the keys, a cryptocurrency wallet more often also offers the functionality of encrypting and/or signing information.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfrin Updraft | Smart Contract DevOps", + "url": "https://updraft.cyfrin.io/courses/wallets", + "type": "course" + }, { "title": "What is a Crypto Wallet?: A Beginner’s Guide", "url": "https://crypto.com/university/crypto-wallets", @@ -1252,11 +1347,6 @@ "title": "Choose your wallet - Ethereum", "url": "https://ethereum.org/en/wallets/find-wallet/", "type": "article" - }, - { - "title": "Explore top posts about Crypto", - "url": "https://app.daily.dev/tags/crypto?ref=roadmapsh", - "type": "article" } ] }, @@ -1320,6 +1410,11 @@ "title": "Explore top posts about Decentralized", "url": "https://app.daily.dev/tags/decentralized?ref=roadmapsh", "type": "article" + }, + { + "title": "Cyfrin Updraft | Introduction to IPFS", + "url": "https://updraft.cyfrin.io/courses/advanced-foundry/how-to-create-an-NFT-collection/what-is-ipfs", + "type": "video" } ] }, @@ -1411,6 +1506,16 @@ "title": "Foundry", "description": "Foundry is a smart contract development toolchain. Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command-line and via Solidity scripts.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfrin Updraft | Foundry Fundamentals", + "url": "https://updraft.cyfrin.io/courses/foundry", + "type": "course" + }, + { + "title": "Cyfrin Updraft | Foundry Advanced", + "url": "https://updraft.cyfrin.io/courses/advanced-foundry", + "type": "course" + }, { "title": "Foundry Overview", "url": "https://book.getfoundry.sh/", @@ -1427,6 +1532,11 @@ "title": "Security", "description": "Smart contracts are extremely flexible, capable of both holding large quantities of tokens (often in excess of $1B) and running immutable logic based on previously deployed smart contract code. While this has created a vibrant and creative ecosystem of trustless, interconnected smart contracts, it is also the perfect ecosystem to attract attackers looking to profit by exploiting vulnerabilities\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfrin Updraft | Smart Contract Security", + "url": "https://updraft.cyfrin.io/courses/security", + "type": "course" + }, { "title": "Smart Contract Security", "url": "https://ethereum.org/en/developers/docs/smart-contracts/security/", @@ -1448,6 +1558,11 @@ "title": "Practices", "description": "Smart contract programming requires a different engineering mindset. The cost of failure can be high, and change can be difficult.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Cyfrin Updraft | Smart Contract Security", + "url": "https://updraft.cyfrin.io/courses/security", + "type": "course" + }, { "title": "Ethereum Smart Contract Security Best Practices", "url": "https://consensys.github.io/smart-contract-best-practices/", @@ -1483,6 +1598,11 @@ "title": "Smart Contract Fuzzing", "url": "https://youtu.be/LRyyNzrqgOc", "type": "video" + }, + { + "title": "Cyfrin Updraft | Stateful And Stateless Fuzzing", + "url": "https://updraft.cyfrin.io/courses/security/tswap/stateful-and-stateless-fuzzing", + "type": "video" } ] }, @@ -1536,6 +1656,11 @@ "title": "Top 10 Tools for Blockchain Development", "url": "https://www.blockchain-council.org/blockchain/top-10-tools-for-blockchain-development/", "type": "article" + }, + { + "title": "Cyfrin Updraft | Security Tools", + "url": "https://updraft.cyfrin.io/courses/security/audit/tools", + "type": "video" } ] }, @@ -1552,6 +1677,11 @@ "title": "Slither Framework", "url": "https://blog.trailofbits.com/2018/10/19/slither-a-solidity-static-analysis-framework/", "type": "article" + }, + { + "title": "Cyfrin Updraft | Slither Walkthrough", + "url": "https://updraft.cyfrin.io/courses/security/puppy-raffle/slither-walkthrough", + "type": "video" } ] }, @@ -1815,6 +1945,11 @@ "url": "https://www.coindesk.com/learn/what-is-a-dapp-decentralized-apps-explained/", "type": "article" }, + { + "title": "Cyfrin Glossary | dApp", + "url": "https://www.cyfrin.io/glossary/dapp", + "type": "article" + }, { "title": "Explore Top dApps on Ethereum and its Layer 2s", "url": "https://www.ethereum-ecosystem.com/apps", @@ -1918,6 +2053,11 @@ "title": "NFT Explained In 5 Minutes | What Is NFT? - Non Fungible Token", "url": "https://youtu.be/NNQLJcJEzv0", "type": "video" + }, + { + "title": "Cyfrin Updraft | What is an NFT", + "url": "https://updraft.cyfrin.io/courses/advanced-foundry/how-to-create-an-NFT-collection/what-is-a-nft", + "type": "video" } ] }, @@ -1977,6 +2117,11 @@ "title": "Alchemy", "url": "https://www.alchemy.com/", "type": "article" + }, + { + "title": "Cyfrin Updraft | Introduction to Alchemy", + "url": "https://updraft.cyfrin.io/courses/foundry/foundry-simple-storage/introduction-to-alchemy", + "type": "video" } ] }, @@ -2611,6 +2756,11 @@ "title": "Introduction to zk-SNARKs", "url": "https://vitalik.eth.limo/general/2021/01/26/snarks.html", "type": "article" + }, + { + "title": "What Are zk-SNARKs and zkSTARKs: Full Comparison", + "url": "https://www.cyfrin.io/blog/a-full-comparison-what-are-zk-snarks-and-zk-starks", + "type": "article" } ] }, @@ -2712,6 +2862,11 @@ "title": "Explore top posts about Blockchain", "url": "https://app.daily.dev/tags/blockchain?ref=roadmapsh", "type": "article" + }, + { + "title": "Cyfirn Updraft | The Purpose of Smart Contracts", + "url": "https://updraft.cyfrin.io/courses/blockchain-basics/basics/the-purpose-of-smart-contracts", + "type": "video" } ] }, @@ -2734,6 +2889,11 @@ "url": "https://docs.ipfs.tech/concepts/how-ipfs-works/", "type": "article" }, + { + "title": "Data Locations - Storage, Memory, and Calldata", + "url": "https://www.cyfrin.io/glossary/data-locations-storage-memory-and-calldata-solidity-code-example", + "type": "article" + }, { "title": "Explore top posts about Storage", "url": "https://app.daily.dev/tags/storage?ref=roadmapsh", diff --git a/public/roadmap-content/rust.json b/public/roadmap-content/rust.json new file mode 100644 index 000000000..d9b732854 --- /dev/null +++ b/public/roadmap-content/rust.json @@ -0,0 +1,1315 @@ +{ + "4U-HZQGH7kaWCB94Xy8Mh": { + "title": "Introduction", + "description": "Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance.", + "links": [ + { + "title": "Rust Book", + "url": "https://edu.anarcho-copy.org/Programming%20Languages/Rust/rust-programming-language-steve-klabnik.pdf", + "type": "opensource" + }, + { + "title": "Rust Book Interactive", + "url": "https://rust-book.cs.brown.edu/experiment-intro.html", + "type": "opensource" + }, + { + "title": "Rust by Example", + "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", + "type": "article" + }, + { + "title": "Official Website", + "url": "https://www.rust-lang.org/", + "type": "article" + } + ] + }, + "cMfsRtvzvDZZJ0TqeUOxm": { + "title": "What is Rust?", + "description": "Rust is a modern system programming language focused on performance, safety, and concurrency. It accomplishes these goals without having a garbage collector, making it a useful language for a number of use cases other languages aren’t good at. Its syntax is similar to C++, but Rust offers better memory safety while maintaining high performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Explore top posts about Rust", + "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", + "type": "article" + }, + { + "title": "Rust by example", + "url": "https://doc.rust-lang.org/stable/rust-by-example/index.html", + "type": "article" + }, + { + "title": "What is Rust?", + "url": "https://www.youtube.com/watch?v=R33h77nrMqc", + "type": "video" + } + ] + }, + "VhSEH_RoWFt1z2lial7xZ": { + "title": "Why use Rust?", + "description": "Rust is a system programming language that aims to provide memory safety, concurrency, and performance with a focus on zero cost abstractions. It was originally created by Graydon Hoare at Mozilla Research, with contributions from Brendan Eich, the creator of JavaScript. Rust is appreciated for the solutions it provides to common programming language issues. Its emphasis on safety, speed, and support for concurrent programming, as well as its robust type system, are just a few reasons why developers choose Rust.", + "links": [ + { + "title": "Explore top posts about Rust", + "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", + "type": "article" + }, + { + "title": "Convince your boss to use Rust", + "url": "https://www.youtube.com/playlist?list=PLZaoyhMXgBzqkaLKR8HHWZaASMvW4gRtZ", + "type": "video" + }, + { + "title": "Rust in 100 seconds", + "url": "https://www.youtube.com/watch?v=5C_HPTJg5ek&pp=ygUNcnVzdCBmaXJlYmFzZQ%3D%3D", + "type": "video" + } + ] + }, + "-IqA02ObYvXPW1ot6t_b9": { + "title": "Installing Rust and Cargo", + "description": "To install Rust, navigate to the official website at [https://www.rust-lang.org](https://www.rust-lang.org) and download the appropriate installation file (or run the appropriate terminal command) for your operating system. You'll be installing `rustup`, which is the preferred tool for installing, updating, and managing your core Rust tooling. For UNIX systems like Linux and MacOS, installation is as easy as running a single command in the terminal. For Windows, you'll be provided with an '.exe' installer which you need to execute. Further instructions can be found on the download page of the website.\n\nKeep in mind that for the compiler to create executables, you'll also need a linker on your operating system, such as 'GCC'. Otherwise, you'll encounter errors when you try to run `rustc` or `cargo`. This is one necessary thing that `rustup` doesn't install for you. Such linker components are part of the C standard library, so they may or may not be partially or fully preinstalled on your system. For example, a common error when running `rustc` for the first time in a 64-bit Linux environment is that your system is missing 32-bit support for GCC, which can be solved by installing `gcc-multilib`.\n\nYou can update your Rust version at any time by running `rustup update` in the terminal.", + "links": [] + }, + "oyP1ZyOgDC4nYEQXHwdVQ": { + "title": "IDEs and Rust Toolchains", + "description": "For the Rust Programming Language, several Integrated Development Environments (IDEs) and editors provide great support. [Visual Studio Code](https://code.visualstudio.com) is highly preferred among Rust developers due to its support for Rust via the \"Rust Language Server\" or \"rust-analyzer\" plugins. Another popular choice is [RustRover](https://www.jetbrains.com/rust/), a dedicated IDE for Rust development by JetBrains. Additionally, [Sublime Text](https://www.sublimetext.com) and [Atom](https://atom.io) with respective Rust-enhancement plugins are also used. For a more terminal-centric approach, [Vim](https://www.vim.org) and [Emacs](https://www.gnu.org/software/emacs/) are equipped with Rust modes. These IDEs and editors offer various features like auto-completion, syntax highlighting, and debugging tools which prove useful for Rust programming.", + "links": [] + }, + "eYCNYtwXBjZwcPUe7QYZ-": { + "title": "Rust REPL (Rust Playground)", + "description": "`Rust REPL` (Read-Eval-Print-Loop) is an interactive shell in which you can write and test Rust snippets in real-time. Unlike running a program normally in Rust where you have to manually compile and then run the program, REPL automatically evaluates your inputs, and the result is returned immediately after execution. This is helpful when experimenting with Rust code, learning the language, and debugging. REPL isn't built into Rust directly, but is available via third-party tools such as `evcxr_repl`.", + "links": [] + }, + "6E4pGifNfSAq6SbzfzFNT": { + "title": "Language Basics", + "description": "Rust language basics cover fundamental programming concepts including syntax and semantics, variables and data types, control flow (loops and conditionals), and functions. These elements form the foundation for writing effective Rust code and understanding how to structure and reuse code segments.", + "links": [] + }, + "Gw5E21W5zis-RUIgNSEV2": { + "title": "Variables, DataTypes and Constants", + "description": "In Rust, variables are declared using the `let` keyword. All variables are immutable by default, which means once a value is bound to a variable, it cannot be changed. If you want to make a variable mutable, the `mut` keyword is used. So, if you wanted to declare a mutable variable `x` and assign it the value `5`, you would write `let mut x = 5;`. Variables can also be patterned. By default in Rust, variables are block-scoped. Rust also supports several types of variable attributes.\n\nLearn more from the following links:", + "links": [ + { + "title": "Variables and Mutability", + "url": "https://rust-book.cs.brown.edu/ch03-01-variables-and-mutability.html", + "type": "article" + }, + { + "title": "Data Types", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html", + "type": "article" + } + ] + }, + "u2wlnmE1uLaTqWw35UF0a": { + "title": "Control Flow and Constructs", + "description": "In Rust, control flow is managed through various structures, like `if`, `else`, `while`, `for`, `loop`, `match` and `if let`. 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, such as an array or a range. The `loop` keyword tells Rust to execute a block of code over and over again forever or until you explicitly tell it to stop. Rust's `match` structure, which is similar to switch statements in other languages, is a powerful tool used for pattern matching: it checks through different cases defined by the programmer and executes the block where the match is found. The `if let` syntax lets you combine `if` and `let` into a less verbose way to handle values that match one pattern while ignoring the rest.\n\nLearn more from the following links:", + "links": [ + { + "title": "Control Flow", + "url": "https://rust-book.cs.brown.edu/ch03-05-control-flow.html", + "type": "article" + }, + { + "title": "Concise Control Flow with if let", + "url": "https://rust-book.cs.brown.edu/ch06-03-if-let.html", + "type": "article" + } + ] + }, + "5hKJaMKpeFEUi3S1Hpiyk": { + "title": "Functions and Method Syntax", + "description": "In Rust, functions are declared using the `fn` keyword. Each function can take a set of input variables with their specified types, and may return data of a specified type. The body of a function is contained within curly braces `{}`. Unlike other languages, in Rust, you don't need to end the last statement in a block with a semicolon; omitting the last semicolon of a block in this way turns the last statement into an expression, and the result of this expression becomes the implicit return value of the block. In other words, if we want to return a value, we simply write the expression we want to return.\n\nAn example of a function that returns implicitly in Rust is `fn add(one: i32, two: i32) -> i32 { one + two }`, where `one` and `two` are parameters of type `i32`. This function returns an integer of type `i32`, which is the result of `one + two`. Rust also has an explicit `return` keyword to exit a function with a given value, like so: `fn add(one: i32, two: i32) -> i32 { return one + two; }`. Using a `return` statement versus the implicit return syntax is mostly a matter of preference.\n\nLearn more from the following links:", + "links": [ + { + "title": "Functions", + "url": "https://rust-book.cs.brown.edu/ch03-03-how-functions-work.html", + "type": "article" + } + ] + }, + "yqp3UePmSlGyOYpxITis4": { + "title": "Pattern Matching & Destructuring", + "description": "In Rust, \"pattern matching\" is a robust tool that allows you to destructure data types and perform conditional checks in a succinct and clear way. The main structures used for pattern matching are `match` and `if let`. The `match` keyword can be used to compare a value against a series of patterns and then execute code based on which pattern matches. Patterns can be made up of literal values, variable names, wildcards, and many other things. The `if let` structure allows you to combine `if` and `let` into a less verbose way of handling values that match one specific pattern, rather than a series of patterns. It's basically a nice syntax sugar over a `match` statement.\n\nLearn more from the following links:", + "links": [ + { + "title": "The match Control Flow Construct", + "url": "https://rust-book.cs.brown.edu/ch06-02-match.html", + "type": "article" + }, + { + "title": "Concise Control Flow with if let", + "url": "https://rust-book.cs.brown.edu/ch06-03-if-let.html", + "type": "article" + } + ] + }, + "FswpjWqqt8-BzUTsDDjel": { + "title": "Enums", + "description": "An enum, short for enumeration, is a custom data type that allows you to define a type by enumerating (listing out one-by-one) all of its possible variants. In Rust, if something is one of a given set of possibilities (e.g., `Rock` or `Paper` or `Scissors`), it's probably appropriate to represent that data with an enum, like so: `enum RpsChoice { Rock, Paper, Scissors }`.\n\nAn instance of an `enum` can be one and only one of the enum's declared variants at any given time. Unlike enumerations in some other languages, variants in Rust are not restricted to a singular data type. When you define an `enum`, you can decide for each of its possible variants whether or not that variant will hold additional embedded data; each variant of the enum is also allowed to hold data of completely different types and amounts. You can even embed structs and other enums in a variant, making enums incredibly versatile.\n\nEnums in Rust are one way to enable simple pattern matching for a value, which allows you to compare the interior structure of a value to a series of patterns using a `match` block. For example, you can execute different branches of code based on whether an `RpsChoice` value is `Rock`, `Paper`, or `Scissors` without a verbose tree of `if`/`else` blocks. You can also handle whatever data might be embedded within that instance of the enum variant, as you will do frequently with Rust's standard `Option` and `Result` enums.\n\nLearn more from the following links:", + "links": [ + { + "title": "Defining an Enum", + "url": "https://rust-book.cs.brown.edu/ch06-01-defining-an-enum.html", + "type": "article" + } + ] + }, + "Mi9mQ-8gyDPd8Mbu1zuHt": { + "title": "Structs", + "description": "In Rust, a struct is a custom data type used for grouping related values together into one entity. Structs are similar to classes in other programming languages. Essentially, each `struct` creates a new type that we can use to streamline complex data handling.\n\nThere are three types of `struct` in Rust: classic 'C' structs, tuple structs, and unit structs.\n\n* **Classic 'C' structs** are named-field structs and are the most commonly used.\n* **Tuple structs**, while not being common, are useful when you want to couple together just a few data points that don't need field names.\n* **Unit structs** are useful in situations where you want to implement a **trait** on some type, but don't have any data that you want to store in the type itself.\n\nLearn more from the following links:", + "links": [ + { + "title": "Defining and Instantiating Structs", + "url": "https://rust-book.cs.brown.edu/ch05-01-defining-structs.html", + "type": "article" + } + ] + }, + "SJMuIEuHp8X6nfLb0k0TU": { + "title": "Traits", + "description": "Traits in Rust define behaviors that are shared among different data types. Implementing traits for data types is a great way to group method signatures together and define a set of behaviors your types require. Essentially, anything with a certain `trait` applied to it will \"inherit\" the behavior of that trait's methods, but this is not the same thing as inheritance found in object-oriented programming languages.\n\nTraits are abstract; it's not possible to create instances of traits. However, we can define pointers of trait types, and these can hold any data type that implements the `trait`. A `trait` is **implemented** for something else with the syntax `impl TraitAbc for Xyz {...}`, which can be a concrete type or another trait.\n\nYou should read carefully about traits in Rust and understand how some common traits, like `Copy`, are already implemented for various primitive types and how this could affect your program.\n\nLearn more from the following links:", + "links": [ + { + "title": "Traits: Defining Shared Behaviour", + "url": "https://doc.rust-lang.org/book/ch10-02-traits.html", + "type": "article" + } + ] + }, + "HzWHDQZjA9OgVZEWrmhKf": { + "title": "Impl Blocks", + "description": "Impl blocks use the `impl` keyword, and are used to **implement** behavior in the form of **methods** for a `struct`, `enum`, or `trait`. If you want your data type or trait to have methods, you need a corresponding `impl` block containing functions for the type or trait.\n\nNote that `self` and `Self` have different meanings in the context of an `impl` block's functions. `self` represents the specific value in your program that's calling the method and passing itself as an argument, while `Self` is syntax sugar for the `impl` block's data type, which is commonly used in constructor methods that return a new instance of the type.\n\nLearn more from the following links:", + "links": [ + { + "title": "Method Syntax", + "url": "https://rust-book.cs.brown.edu/ch05-03-method-syntax.html", + "type": "article" + } + ] + }, + "FHZSxSiOZYNBEz6tu8wuF": { + "title": "Integers", + "description": "In Rust, integers are a primitive data type that hold whole number values, both positive and negative. Integer types in Rust can be divided into signed and unsigned ones:\n\n* Signed integers, denoted by \"i\", are those that can hold negative, zero, and positive values.\n* Unsigned integers, denoted by \"u\", only hold zero and positive values.\n\nEach denotation is followed by a number which represents the number of bits they occupy in memory. The available integer types are:\n\nType\n\nMinimum\n\nMaximum\n\ni8\n\n\\-(2^7)\n\n(2^7)-1\n\ni16\n\n\\-(2^15)\n\n(2^15)-1\n\ni32\n\n\\-(2^31)\n\n(2^31)-1\n\ni64\n\n\\-(2^63)\n\n(2^63)-1\n\ni128\n\n\\-(2^127)\n\n(2^127)-1)\n\nisize\n\n\\-(2^31) or -(2^63)\n\n(2^31)-1 or (2^63)-1\n\nThe unsigned integer types consist of:\n\nType\n\nMinimum\n\nMaximum\n\nu8\n\n0\n\n(2^8)-1\n\nu16\n\n0\n\n(2^16)-1\n\nu32\n\n0\n\n(2^32)-1\n\nu64\n\n0\n\n(2^64)-1\n\nu128\n\n0\n\n(2^128)-1\n\nusize\n\n0\n\n(2^32)-1 or (2^64)-1\n\nIn these types, the number after \"i\" or \"u\" denotes the size of the integer type in bits.\n\nThere's also the `isize` and `usize` integer types. The sizes of these primitive are taken from the computer architecture (32/64 bits). When one of these types is declared, the compiler calculates, so to speak, how many bytes it takes to reference any location in memory. For example, on a 32-bit target, this is 4 bytes, and on a 64-bit target, this is 8 bytes.\n\n* [@article@Integer Data Type in Rust](https://doc.rust-lang.org/book/ch03-02-data-types.html#integer-types)\n \n* [@article@Rust Data Types (With Examples)](https://www.programiz.com/rust/data-types#integer-type)\n \n* [@article@Machine-dependent Integer Types](https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types)\n \n\nLearn more from the following links:", + "links": [ + { + "title": "Integer Types", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#integer-types", + "type": "article" + } + ] + }, + "bjwJCGMx5ZfrH7vz3eLS7": { + "title": "Boolean", + "description": "Rust's `bool` primitive type represents truth values with two possible states: `true` or `false`. Booleans are used in conditional statements and logical operations like `&&` (AND), `||` (OR), and `!` (NOT). When cast to integers, `true` becomes `1` and `false` becomes `0`. Example: `let is_active: bool = true;`\n\nLearn more from the following links:", + "links": [ + { + "title": "The Boolean Type", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-boolean-type", + "type": "article" + }, + { + "title": "bool - Rust", + "url": "https://doc.rust-lang.org/std/primitive.bool.html", + "type": "article" + }, + { + "title": "Rust Tutorial - Booleans", + "url": "https://www.youtube.com/watch?v=t047Hseyj_k&t=388s", + "type": "video" + } + ] + }, + "rNHHp1GgmRnKIYlZayi59": { + "title": "Floats", + "description": "In Rust, `floats` are a primitive data types used to represent floating-point numbers. They are defined as numerical values with fractional components. Floating-point numbers are represented according to the IEEE-754 standard.\n\nRust supports two types of floating-point numbers: `f32` and `f64`. These are 32-bit and 64-bit in size, respectively.\n\n* `f32` (_binary32_ type defined in IEEE-754-2008) is a single-precision float, which means is less precise than `f64` type.\n* `f64` (_binary64_ type defined in IEEE-754-2008) has double precision. The default type is `f64` because on modern CPUs it’s roughly the same speed as `f32` but allows more precision.\n\nBoth `f32` and `f64` represent negative, zero and positive floating-point values.\n\nLearn more from the following links:", + "links": [ + { + "title": "f32 - Rust", + "url": "https://doc.rust-lang.org/std/primitive.f32.html", + "type": "article" + }, + { + "title": "IEEE-754 Standard", + "url": "https://en.wikipedia.org/wiki/IEEE_754", + "type": "article" + }, + { + "title": "Floating-Point Types", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#floating-point-types", + "type": "article" + }, + { + "title": "Rust Tutorial - Floating-Points", + "url": "https://www.youtube.com/watch?v=t047Hseyj_k&t=335s", + "type": "video" + } + ] + }, + "dXMJb2wDmmh2jie1AnPoK": { + "title": "Character", + "description": "Rust's `char` type represents a Unicode Scalar Value, supporting far more than ASCII including emojis, accented letters, and various scripts. Each `char` occupies 4 bytes (32 bits) in memory and is defined using single quotes. Example: `let letter: char = 'z';` or `let emoji: char = '🦀';`\n\nLearn more from the following links:", + "links": [ + { + "title": "The char Primitive Type", + "url": "https://doc.rust-lang.org/std/primitive.char.html", + "type": "article" + }, + { + "title": "The Character Type", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-character-type", + "type": "article" + }, + { + "title": "Unicode Glossary - Unicode Scalar Value", + "url": "https://www.unicode.org/glossary/#unicode_scalar_value", + "type": "article" + }, + { + "title": "Char Type in Rust", + "url": "https://www.youtube.com/watch?v=NZaEinuVPVg&pp=ygURY2hhciB0eXBlIGluIHJ1c3Q%3D", + "type": "video" + } + ] + }, + "81_J7CwtUUjYPvKV_prg3": { + "title": "Tuple", + "description": "Tuples are fixed-size collections that can hold elements of different types. Access elements using dot notation with zero-based indexing: `tuple.0`, `tuple.1`, etc. Example: `let data: (i32, f64, char) = (42, 3.14, 'x');`. Useful for grouping related values of different types and multiple variable assignments.\n\nLearn more from the following links:", + "links": [ + { + "title": "Tuple - Rust", + "url": "https://doc.rust-lang.org/std/primitive.tuple.html", + "type": "article" + }, + { + "title": "The Tuple Type", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-tuple-type", + "type": "article" + }, + { + "title": "Rust Tutorial - Tuples", + "url": "https://www.youtube.com/watch?v=t047Hseyj_k&t=506s", + "type": "video" + } + ] + }, + "Hu1jf46OpX44nam_UvYqc": { + "title": "String", + "description": "Rust's `String` is a growable, mutable, UTF-8 encoded string type stored on the heap. Unlike string slices (`&str`), `String` owns its data and can be modified. Create with `String::from(\"text\")` or `\"text\".to_string()`. Common operations include `push_str()`, `push()`, and concatenation with `+` or `format!()` macro.\n\nLearn more from the following links:", + "links": [ + { + "title": "String in std::string - Rust", + "url": "https://doc.rust-lang.org/std/string/struct.String.html", + "type": "article" + }, + { + "title": "str - Rust", + "url": "https://doc.rust-lang.org/std/primitive.str.html", + "type": "article" + }, + { + "title": "What Is a String?", + "url": "https://doc.rust-lang.org/book/ch08-02-strings.html?highlight=String#what-is-a-string", + "type": "article" + }, + { + "title": "Rust String (With Examples)", + "url": "https://www.programiz.com/rust/string", + "type": "article" + }, + { + "title": "All Rust string types explained", + "url": "https://www.youtube.com/watch?v=CpvzeyzgQdw&pp=ygUOc3RyaW5nIGluIHJ1c3Q%3D", + "type": "video" + } + ] + }, + "2DbdHCjFzGHwCUETakaGh": { + "title": "Array", + "description": "Arrays are fixed-size collections of elements of the same type stored consecutively in memory. Size must be known at compile time and cannot change. Syntax: `let arr: [type; size] = [elements];`. Example: `let nums: [i32; 3] = [1, 2, 3];`. Access elements with zero-based indexing: `arr[0]`.\n\nLearn more from the following links:", + "links": [ + { + "title": "Rust - array", + "url": "https://doc.rust-lang.org/std/primitive.array.html", + "type": "article" + }, + { + "title": "The Array Type", + "url": "https://rust-book.cs.brown.edu/ch03-02-data-types.html#the-array-type", + "type": "article" + }, + { + "title": "Rust Array (With Examples)", + "url": "https://www.programiz.com/rust/array", + "type": "article" + }, + { + "title": "Rust Tutorial - Arrays", + "url": "https://www.youtube.com/watch?v=t047Hseyj_k&t=767s", + "type": "video" + } + ] + }, + "JAgjrf5WDXiorZ6gFRzTc": { + "title": "Hashmap", + "description": "`HashMap` stores key-value pairs using hashing for fast lookups, insertions, and removals. Keys must be unique; duplicate keys replace old values. Rust uses cryptographically strong hashing for security. Items are unordered. Example: `HashMap::new()` or `HashMap::from([(\"key\", \"value\")])`.\n\nLearn more from the following links:", + "links": [ + { + "title": "HashMap in std::collections - Rust", + "url": "https://doc.rust-lang.org/std/collections/struct.HashMap.html", + "type": "article" + }, + { + "title": "Storing Keys With Associated Values In Hash Maps", + "url": "https://doc.rust-lang.org/book/ch08-03-hash-maps.html?highlight=hashmap#storing-keys-with-associated-values-in-hash-maps", + "type": "article" + }, + { + "title": "Hash Table", + "url": "https://en.wikipedia.org/wiki/Hash_table", + "type": "article" + }, + { + "title": "HashMaps: key-value stores in Rust", + "url": "https://www.youtube.com/watch?v=BfmSYuDdg8Q", + "type": "video" + } + ] + }, + "PskCueCc9pSxfnSzfdX-u": { + "title": "Vector", + "description": "`Vec` is Rust's growable, heap-allocated array that stores elements of the same type contiguously. Unlike arrays, vectors can resize at runtime. Key methods include `push()` to add elements, `pop()` to remove the last element, and `len()` for size. Example: `let mut v = vec![1, 2, 3];`\n\nLearn more from the following links:", + "links": [ + { + "title": "Vec in std::vec - Rust", + "url": "https://doc.rust-lang.org/std/vec/struct.Vec.html", + "type": "article" + }, + { + "title": "Storing Lists of Values with Vectors", + "url": "https://doc.rust-lang.org/book/ch08-01-vectors.html?highlight=vector#storing-lists-of-values-with-vectors", + "type": "article" + }, + { + "title": "Rust Vector (With Examples)", + "url": "https://www.programiz.com/rust/vector", + "type": "article" + }, + { + "title": "Rust: Vectors", + "url": "https://www.youtube.com/watch?v=nOKOFYzvvHo&t=97s&pp=ygUMcnVzdCB2ZWN0b3Jz", + "type": "video" + }, + { + "title": "Common Collections in Rust", + "url": "https://www.youtube.com/watch?v=Zs-pS-egQSs&t=39s&pp=ygUMcnVzdCB2ZWN0b3Jz", + "type": "video" + } + ] + }, + "b1iYy4Hvkj47Q13V2HE4i": { + "title": "Hashset", + "description": "`HashSet` is a collection of unique elements using hash-based storage for fast lookups, insertions, and deletions. No duplicates are allowed and elements are unordered. Provides methods like `insert()`, `contains()`, and `remove()`. Example: `let mut set = HashSet::new(); set.insert(\"value\");`\n\nLearn more from the following links:", + "links": [ + { + "title": "HashSet in std::collections - Rust", + "url": "https://doc.rust-lang.org/std/collections/struct.HashSet.html", + "type": "article" + }, + { + "title": "Hashset", + "url": "https://doc.rust-lang.org/rust-by-example/std/hash/hashset.html", + "type": "article" + }, + { + "title": "Rust HashSet Collection Type", + "url": "https://www.youtube.com/watch?v=KYw3Lnf0nSY&t=1440s", + "type": "video" + } + ] + }, + "iR0ewc2yURqS7bfMWfoBi": { + "title": "LinkedList", + "description": "`LinkedList` is a doubly-linked list where each node contains a value and pointers to both next and previous nodes. Provides O(1) insertion/removal at both ends but O(n) indexing. Generally slower than `Vec` and rarely needed; `VecDeque` is usually preferred for queue operations.\n\nLearn more from the following links:", + "links": [ + { + "title": "Too Many Linked Lists", + "url": "https://rust-unofficial.github.io/too-many-lists/", + "type": "opensource" + }, + { + "title": "LinkedList in std::collections - Rust", + "url": "https://doc.rust-lang.org/std/collections/struct.LinkedList.html", + "type": "article" + } + ] + }, + "B-S1hE-ofNTutnkc2hJBf": { + "title": "Stack", + "description": "Stack is a LIFO (Last-In-First-Out) data structure where elements are added and removed from the same end. In Rust, the call stack manages function calls, with each call pushing a frame and returns popping it. Stack memory is fast but limited in size, with stack overflow occurring when exceeded.\n\nLearn more from the following links:", + "links": [ + { + "title": "Box, Stack and Heap", + "url": "https://doc.rust-lang.org/rust-by-example/std/box.html", + "type": "article" + } + ] + }, + "fq2NMV-QV9ayJl82ZWzov": { + "title": "Queue", + "description": "Queue follows FIFO (First-In-First-Out) ordering where elements are added at one end and removed from the other. Rust doesn't have a built-in queue, but `VecDeque` provides queue functionality with `push_back()` for adding and `pop_front()` for removing elements efficiently.\n\nLearn more from the following links:", + "links": [ + { + "title": "Queues", + "url": "https://docs.rs/queues/latest/queues/", + "type": "article" + } + ] + }, + "jdndHBzmdgI6uYql6bO4W": { + "title": "Binary Heap", + "description": "`BinaryHeap` is a priority queue implemented as a max-heap using a binary tree structure stored in an array. The largest element is always at the root, accessible via `peek()`. Supports O(log n) insertion with `push()` and removal with `pop()`. Useful for priority-based algorithms.\n\nLearn more from the following links:", + "links": [ + { + "title": "BinaryHeap", + "url": "https://doc.rust-lang.org/std/collections/struct.BinaryHeap.html", + "type": "article" + } + ] + }, + "2UQ3AuGkDbT0-54l0rOGM": { + "title": "Ownsership Rules & Memory Safety", + "description": "Rust's ownership has three key rules: each value has exactly one owner, only one owner exists at a time, and values are dropped when owners go out of scope. This prevents data races, ensures memory safety without garbage collection, and eliminates common bugs like use-after-free and memory leaks.\n\nLearn more from the following links:", + "links": [ + { + "title": "What Is Ownership?", + "url": "https://rust-book.cs.brown.edu/ch04-01-what-is-ownership.html", + "type": "article" + } + ] + }, + "-onH5vPffdcZFjjVcnEpk": { + "title": "Borrowing, References and Slices", + "description": "Borrowing allows accessing data without taking ownership. Immutable borrows (`&T`) permit multiple read-only references, while mutable borrows (`&mut T`) allow one exclusive reference that can modify data. Slices (`&[T]`, `&str`) are references to contiguous sequences, enabling safe access to portions of data.\n\nLearn more from the following links:", + "links": [ + { + "title": "References and Borrowing", + "url": "https://rust-book.cs.brown.edu/ch04-02-references-and-borrowing.html", + "type": "article" + }, + { + "title": "The Slice Type", + "url": "https://rust-book.cs.brown.edu/ch04-04-slices.html", + "type": "article" + } + ] + }, + "UdXq0H8599cDTKXaIlPqt": { + "title": "Deep Dive: Stack vs Heap", + "description": "Stack memory stores fixed-size data with automatic allocation/deallocation following LIFO order - fast but limited. Heap memory stores dynamic-size data with manual management - slower but flexible. Rust's ownership system ensures memory safety across both, with stack being default and heap accessed via smart pointers.\n\nLearn more from the following links:", + "links": [ + { + "title": "The Stack and the Heap", + "url": "https://web.mit.edu/rust-lang_v1.25/arch/amd64_ubuntu1404/share/doc/rust/html/book/first-edition/the-stack-and-the-heap.html", + "type": "article" + } + ] + }, + "LWgaZWTJVWLDes3HzflRh": { + "title": "BTreeMap", + "description": "`BTreeMap` stores key-value pairs in a sorted binary tree structure. Keys must implement `Ord` trait and are automatically kept in sorted order. Provides O(log n) operations for insertion, removal, and lookup. Ideal when you need ordered iteration and range queries.\n\nLearn more from the following links:", + "links": [ + { + "title": "BTreeMap", + "url": "https://doc.rust-lang.org/std/collections/struct.BTreeMap.html", + "type": "article" + }, + { + "title": "BTreeMap", + "url": "https://cglab.ca/~abeinges/blah/rust-btree-case/", + "type": "article" + } + ] + }, + "FsyLYRQP_rs4qL7IAj9Mo": { + "title": "BTreeSet", + "description": "`BTreeSet` is a sorted set of unique elements implemented using a B-tree. Elements must implement `Ord` trait and are kept in sorted order. Provides O(log n) insertion, removal, and lookup operations. Supports efficient range queries and set operations like union and intersection.\n\nLearn more from the following links:", + "links": [ + { + "title": "Btree Set", + "url": "https://doc.rust-lang.org/std/collections/struct.BTreeSet.html", + "type": "article" + } + ] + }, + "U9Bd-GO0QwYVLvESR4PTb": { + "title": "RC", + "description": "`Rc` (Reference Counting) enables multiple owners of the same heap-allocated data in single-threaded contexts. It tracks the number of references and automatically deallocates data when the count reaches zero. Use `Rc::clone()` to create additional references without deep copying data.\n\nLearn more from the following links:", + "links": [ + { + "title": "rct - The Reference Counted Smart Pointer", + "url": "https://doc.rust-lang.org/book/ch15-04-rc.html#rct-the-reference-counted-smart-pointer", + "type": "article" + } + ] + }, + "yYmV5qkldu0FkDhOhWOXs": { + "title": "Arc", + "description": "`Arc` (Atomic Reference Counting) is a thread-safe smart pointer for sharing immutable data across multiple threads. It uses atomic operations to track reference counts, allowing multiple ownership of heap-allocated data. When the reference count reaches zero, the data is automatically cleaned up.\n\nLearn more from the following links:", + "links": [ + { + "title": "Arc", + "url": "https://doc.rust-lang.org/rust-by-example/std/arc.html", + "type": "article" + } + ] + }, + "GbbeV3r27IBEKHyiyLqs6": { + "title": "Mutex", + "description": "`Mutex` (Mutual Exclusion) protects shared data from concurrent access by multiple threads. Only one thread can access the protected data at a time through `lock()`. Rust automatically unlocks mutexes when they go out of scope and handles panics to prevent deadlocks.\n\nLearn more from the following links:", + "links": [ + { + "title": "Mutex", + "url": "https://doc.rust-lang.org/std/sync/struct.Mutex.html", + "type": "article" + } + ] + }, + "WzGl4DkANjUu7VC1AIWI-": { + "title": "RwLock", + "description": "`RwLock` (Read-Write Lock) allows multiple concurrent readers OR one exclusive writer, unlike Mutex which allows only one accessor. Use `read()` for shared access and `write()` for exclusive access. Ideal for read-heavy workloads where data is frequently read but rarely modified.\n\nLearn more from the following links:", + "links": [ + { + "title": "RwLock", + "url": "https://doc.rust-lang.org/std/sync/struct.RwLock.html", + "type": "article" + } + ] + }, + "3nXJg5Y4SUug_dEAj0eQm": { + "title": "Channels", + "description": "Channels enable thread communication via message passing from `std::sync::mpsc` (Multiple Producer, Single Consumer). They have `Sender` for sending data and `Receiver` for receiving. This avoids shared state concurrency issues and enables safe communication between threads without data races.\n\nLearn more from the following links:", + "links": [ + { + "title": "Channels", + "url": "https://doc.rust-lang.org/rust-by-example/std_misc/channels.html", + "type": "article" + } + ] + }, + "X2gB0m-ZKSC4TJyIcwsMx": { + "title": "Error Handling", + "description": "Rust handles errors through `Result` for operations that may fail and `Option` for values that may be absent. `Result` has `Ok(T)` for success and `Err(E)` for errors, while `Option` has `Some(T)` and `None`. Pattern matching and the `?` operator enable elegant error handling and propagation. Rust doesn't use exceptions, eliminating many common error-handling problems.", + "links": [] + }, + "wQHkBydWsiGEOZMdKmz40": { + "title": "Option and Result Enumerations", + "description": "`Option` handles nullable values with `Some(T)` and `None` variants, replacing null pointers safely. `Result` manages error handling with `Ok(T)` for success and `Err(E)` for failures. Both enums enable safe error handling through pattern matching and method chaining.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust by Example: Option & unwrap", + "url": "https://doc.rust-lang.org/rust-by-example/error/option_unwrap.html", + "type": "article" + }, + { + "title": "Rust by Example: Result", + "url": "https://doc.rust-lang.org/rust-by-example/error/result.html", + "type": "article" + } + ] + }, + "pTC1ucmErVnMbNFnYLJK7": { + "title": "Propagating Errors and `?` Operator", + "description": "The `?` operator provides concise error propagation in functions returning `Result` or `Option`. It automatically unwraps `Ok`/`Some` values or early-returns `Err`/`None` to the caller. This eliminates verbose `match` expressions and enables clean, readable error handling patterns.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Book: Recoverable Errors with Result", + "url": "https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html", + "type": "article" + } + ] + }, + "LwqOxYY9E9MUDgz2M40uV": { + "title": "Custom Error Types and Traits", + "description": "Custom error types use `enum` to define specific error variants with attached data. Implement `Debug`, `Display`, and optionally `std::error::Error` traits for proper error handling integration. Libraries like `thiserror` provide derive macros to simplify custom error creation and formatting.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust by Example: Defining an error type", + "url": "https://doc.rust-lang.org/rust-by-example/error/multiple_error_types/define_error_type.html", + "type": "article" + } + ] + }, + "Zpowr_NGd-E2DC3g-oW9h": { + "title": "Modules & Crates", + "description": "Modules provide namespacing and encapsulation within a crate, organizing code with `mod` keyword and controlling visibility with `pub`. Crates are compilation units (binaries or libraries) that can depend on other crates. The module system organizes code within crates, while crates enable sharing functionality between projects.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Book: Managing Growing Projects with Packages, Crates, and Modules", + "url": "https://doc.rust-lang.org/book/ch07-00-managing-growing-projects-with-packages-crates-and-modules.html", + "type": "article" + } + ] + }, + "c_SdccEXEJyh4ymWzvCeX": { + "title": "Code Organization & Namespacing", + "description": "Rust organizes code through modules (`mod`) for grouping related functionality and crates (binary/library projects). Modules provide namespacing and can be nested. Crates are compilation units with a root file (`main.rs` or `lib.rs`) forming the module tree for libraries or executables.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust by Example: Modules", + "url": "https://doc.rust-lang.org/rust-by-example/mod.html", + "type": "article" + }, + { + "title": "The Rust Reference: Namespaces", + "url": "https://doc.rust-lang.org/reference/names/namespaces.html", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "PkePVzV-b1pgFJP5xID5_": { + "title": "Dependency Management with Cargo", + "description": "Cargo manages Rust projects and dependencies through `Cargo.toml` files. Dependencies are listed in `[dependencies]` sections with crate names and semantic version specifications. Cargo automatically downloads, builds, and manages external libraries (crates) from [crates.io](http://crates.io) or other sources.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Blog: Cargo", + "url": "https://blog.rust-lang.org/2016/05/05/cargo-pillars.html", + "type": "article" + }, + { + "title": "Rust by Example: Dependencies", + "url": "https://doc.rust-lang.org/rust-by-example/cargo/deps.html", + "type": "article" + } + ] + }, + "Op0-bdMV3kE9Be6Ot1aC6": { + "title": "Publishing on Crates.io", + "description": "Publishing Rust crates involves creating an account on [crates.io](http://crates.io), preparing proper `Cargo.toml` metadata, and using `cargo publish`. Once published, versions cannot be deleted or overwritten, ensuring dependency stability. The registry serves as Rust's central package repository for sharing libraries.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "The Cargo Book: Publishing on crates.io", + "url": "https://doc.rust-lang.org/cargo/reference/publishing.html", + "type": "article" + } + ] + }, + "pehYc_xLrs6BFUbcpPTiJ": { + "title": "Concurrency & Parallelism", + "description": "Concurrency allows tasks to run in overlapping time periods (interleaved execution), while parallelism executes multiple tasks simultaneously on different cores. Rust provides safe concurrency primitives like channels, mutexes, and atomic operations without data races, enforced at compile time.", + "links": [] + }, + "pJN260pWQVO0gHxi1-_3U": { + "title": "Threads, Channels and Message Passing", + "description": "Rust provides native threading with `std::thread::spawn()` and `join()` for 1:1 OS thread mapping. Channels enable safe message passing between threads, avoiding shared state issues. This model promotes concurrent programming without data races through Rust's ownership system.\n\nLearn more from the following links:", + "links": [ + { + "title": "Rust Atomics and Locks - Low-Level Concurrency in Practice", + "url": "https://marabos.nl/atomics/", + "type": "article" + } + ] + }, + "n1Epl_nBuoXW2OE0IKYVR": { + "title": "Atomic Operations & Memory Barriers", + "description": "Atomic operations provide lock-free concurrency through uninterruptible operations like `load`, `store`, `swap`, and `compare_and_swap`. These low-level primitives enable thread-safe data sharing without locks, forming the foundation for higher-level concurrent abstractions and non-blocking data structures.\n\nLearn more from the following links:", + "links": [ + { + "title": "Rust Atomics and Locks - Low-Level Concurrency in Practice", + "url": "https://marabos.nl/atomics/", + "type": "article" + } + ] + }, + "kVfBbsOHoixvqb4dYTG3Q": { + "title": "Futures and Async/Await Paradigm", + "description": "Futures represent asynchronous computations that produce values or errors eventually. The `async/await` syntax provides ergonomic programming over futures, allowing asynchronous code to look synchronous. Futures are lazy and must be polled to make progress, forming the foundation of Rust's async ecosystem.", + "links": [] + }, + "08qKtgnhJ3tlb5JKfTDf5": { + "title": "Testing", + "description": "Rust has built-in testing support through `cargo test` and the `#[test]` attribute. Test functions use assertion macros like `assert!`, `assert_eq!`, and `assert_ne!` to verify expected behavior. Organize tests with unit tests, integration tests, and documentation tests for comprehensive coverage.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Book: Writing Automated Tests", + "url": "https://doc.rust-lang.org/book/ch11-00-testing.html", + "type": "article" + }, + { + "title": "Explore top posts about Testing", + "url": "https://app.daily.dev/tags/testing?ref=roadmapsh", + "type": "article" + }, + { + "title": "YouTube", + "url": "https://www.youtube.com/watch?v=8XaVlL3lObQ", + "type": "video" + } + ] + }, + "w9coeW9-crDxu0KC-9gEU": { + "title": "Unit & Integration Testing", + "description": "Unit tests verify individual functions using `#[test]` and live alongside code. Integration tests are in separate files/directories and test component interactions. Rust provides `cargo test` to run both types, supporting test organization for comprehensive code verification and quality assurance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Book: How to Write Tests", + "url": "https://doc.rust-lang.org/book/ch11-01-writing-tests.html", + "type": "article" + }, + { + "title": "Rust by Example: Unit testing", + "url": "https://doc.rust-lang.org/rust-by-example/testing/unit_testing.html", + "type": "article" + } + ] + }, + "HEqfA6An6ZeT3z4R610en": { + "title": "Mocking & Property Based Testing", + "description": "Mocking creates fake functions/objects for testing different scenarios. Rust uses external libraries like `mockito`, `mockall`, and `mockall_double` for mocking capabilities. Property-based testing generates test cases automatically to verify code behavior across a wide range of inputs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: mockito", + "url": "https://docs.rs/mockito/latest/mockito/", + "type": "article" + }, + { + "title": "Docs.rs: mockall", + "url": "https://docs.rs/mockall/latest/mockall/", + "type": "article" + }, + { + "title": "Docs.rs: mockall_double", + "url": "https://docs.rs/mockall_double/latest/mockall_double/", + "type": "article" + }, + { + "title": "Explore top posts about Testing", + "url": "https://app.daily.dev/tags/testing?ref=roadmapsh", + "type": "article" + } + ] + }, + "zLKbYX0nnbfD5n3P_JRaS": { + "title": "Traits & Generics", + "description": "Traits define shared behavior that types can implement, while generics enable code reuse with type parameters. Together, they provide trait bounds (`T: Display`) to constrain generic types, ensuring they have required functionality. This enables safe, zero-cost polymorphism and code abstraction.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Book: Generic Types, Traits, and Lifetimes", + "url": "https://doc.rust-lang.org/book/ch10-00-generics.html", + "type": "article" + } + ] + }, + "_EicstELZcdesHiXFWJGu": { + "title": "Trait Definitions & Implementations", + "description": "Traits define shared behavior as a set of method signatures that types can implement. Define with `trait Name { fn method(&self); }` and implement with `impl TraitName for Type`. Traits enable polymorphism, code reuse, and abstraction while maintaining type safety and zero-cost performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust by Example: Traits", + "url": "https://doc.rust-lang.org/rust-by-example/trait.html", + "type": "article" + } + ] + }, + "pRDgDtRIVpNM2CdhSOS3Q": { + "title": "Trait Bounds and Associated Types", + "description": "Trait bounds constrain generics by requiring types to implement specific traits (`T: Display`). Associated types define type placeholders within traits that implementors must specify. Together, they enable flexible generic programming with type safety and improved API design patterns.", + "links": [] + }, + "_hxwo_iAdOwlWBltv7i6i": { + "title": "Generics & Type-Level Programming", + "description": "Advanced generics in Rust include `where` clauses for complex bounds, `?Sized` for unsized types, associated types, and higher-kinded types. These enable sophisticated type-level programming, allowing precise control over generic constraints and enabling powerful abstractions while maintaining zero-cost performance.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Book: Generics", + "url": "https://doc.rust-lang.org/book/ch10-01-syntax.html", + "type": "article" + }, + { + "title": "Rust by Example: Generics", + "url": "https://doc.rust-lang.org/rust-by-example/generics.html", + "type": "article" + } + ] + }, + "UZ56NKloehcxUFNuSeO19": { + "title": "Lifetimes & Borrow Checker", + "description": "Lifetimes define how long references remain valid, preventing dangling references and memory safety issues. The borrow checker enforces these rules at compile time. Lifetime annotations use syntax like `'a` to specify relationships between references in function signatures when the compiler can't infer them automatically.", + "links": [] + }, + "R5HIVS-lyCp9b46aXqx2m": { + "title": "Explicit Lifetime Annotations", + "description": "Explicit lifetime annotations use syntax like `'a` to specify relationships between reference lifetimes in function signatures. Required when the compiler can't infer lifetimes automatically. Example: `fn longest<'a>(x: &'a str, y: &'a str) -> &'a str` ensures all references live equally long.", + "links": [] + }, + "qJI8GObmsxyc_tTtUEOAd": { + "title": "Lifetime Elision Rules", + "description": "Lifetime elision allows the compiler to infer lifetimes in common patterns, reducing explicit annotations. Rules: each reference parameter gets its own lifetime, single input lifetime applies to all outputs, methods with `&self` propagate its lifetime to outputs. Simplifies code while maintaining safety.", + "links": [] + }, + "7yVvMnvCvLbFa51pESx0j": { + "title": "Covariant & Contravariant Lifetimes", + "description": "Variance describes how subtyping relationships change when types are nested. Covariant types preserve ordering (`&'long T` is subtype of `&'short T`), contravariant reverses it, invariant requires exact matches. Affects how lifetimes work with references, boxes, and function parameters.", + "links": [] + }, + "eTpZXd8E2jVBmk_aSLZYV": { + "title": "Macros & Metaprogramming", + "description": "Macros are code that writes code, enabling metaprogramming in Rust. Declarative macros use `macro_rules!` for pattern-based code generation, while procedural macros provide custom derives and function-like macros. They're expanded at compile time, offering zero-cost abstractions.", + "links": [] + }, + "AXWXXsww7Xkl3BYgtThNe": { + "title": "Declarative Macros with macro_rules!", + "description": "Declarative macros use `macro_rules!` for pattern-based code generation at compile time. They match syntax patterns and expand into replacement code, enabling code reuse without runtime overhead. More limited than procedural macros but simpler to write and understand.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust Book: Macros", + "url": "https://doc.rust-lang.org/book/ch19-06-macros.html", + "type": "article" + }, + { + "title": "Macros by Example", + "url": "https://doc.rust-lang.org/reference/macros-by-example.html", + "type": "article" + } + ] + }, + "bkVM1OIbv4XUpY6FQb8x_": { + "title": "Procedural Macros & Custom Derive", + "description": "Procedural macros operate on token streams at compile time, generating new code. Three types exist: custom derive (for `#[derive(MyTrait)]`), attribute-like (`#[my_attr]`), and function-like (`my_macro!()`). More powerful than declarative macros but require separate crates with special configuration.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Procedural Macros", + "url": "https://doc.rust-lang.org/reference/procedural-macros.html", + "type": "article" + } + ] + }, + "Kb7KF7JCMaWFz-GuaQmQV": { + "title": "Domain Specific Languages (DSLs)", + "description": "DSLs are specialized programming languages for specific domains. Rust macros enable creating DSLs by manipulating syntax trees and defining custom syntax patterns. This allows extending Rust's language capabilities for specialized applications like game development, configuration, or domain-specific tasks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rust by Example: Domain Specific Languages (DSLs)", + "url": "https://doc.rust-lang.org/rust-by-example/macros/dsl.html", + "type": "article" + } + ] + }, + "KomYBYxj0FTrJDYB3nU5B": { + "title": "Web Development", + "description": "Rust offers excellent web development capabilities with frameworks like Actix, Rocket, Axum, and Warp. These provide HTTP handling, routing, middleware, and database integration. Rust's performance and safety make it ideal for high-performance web services, APIs, and microservices.", + "links": [] + }, + "duQ1RO1lqq793mfb5w31P": { + "title": "Axum", + "description": "Axum is a modern, ergonomic web framework built on hyper and designed for async Rust. It features excellent type safety, powerful extractors, middleware support, and seamless Tokio integration. Axum emphasizes developer experience while maintaining high performance for web services and APIs.\n\nVisit the following resources to learn more:\n\n[@official@Axum Documentation](https://docs.rs/axum/latest/axum/)", + "links": [] + }, + "3Y90v2ysoMcyjDL24H7mC": { + "title": "Actix", + "description": "Actix is a high-performance, pragmatic web framework for Rust built on the actor model. It features powerful middleware, WebSocket support, and excellent performance benchmarks. Actix provides a flexible, feature-rich API for building web applications, APIs, and microservices with minimal boilerplate.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Actix", + "url": "https://actix.rs/", + "type": "article" + } + ] + }, + "n5t3MUqmvrcr36VIIOw0u": { + "title": "Leptos", + "description": "", + "links": [] + }, + "GnSBtZoN9mAehRf5Eczng": { + "title": "Loco", + "description": "", + "links": [] + }, + "ApjwY_70OGG_dNIC85oBD": { + "title": "Rocket", + "description": "Rocket is a web framework for Rust emphasizing ease of use, expressiveness, and type safety. It features code generation via procedural macros, built-in templating, request guards, and comprehensive error handling. Rocket prioritizes developer productivity with intuitive APIs and detailed error messages.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Rocket", + "url": "https://rocket.rs/", + "type": "article" + } + ] + }, + "yu0f5gALho0e8wzV10yow": { + "title": "Asynchronous Programming", + "description": "Async programming in Rust allows executing tasks concurrently rather than sequentially, enabling efficient resource usage especially in IO-heavy applications. Rust provides `async` and `await` keywords: `async` marks functions that can return `Future` values, while `await` pauses and resumes async functions. Popular async runtimes like Tokio and async-std manage task execution efficiently.", + "links": [] + }, + "H0mctp3Bj2OYfIGFDWGfz": { + "title": "Tokio", + "description": "Tokio is Rust's most popular async runtime for building fast, reliable network applications. It provides an async/await runtime, I/O drivers, timers, and networking primitives. Tokio enables high-performance concurrent applications by efficiently managing thousands of tasks on a small number of threads.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Official Website", + "url": "https://tokio.rs/", + "type": "article" + }, + { + "title": "Docs.rs: Tokio", + "url": "https://docs.rs/tokio/latest/tokio/", + "type": "article" + } + ] + }, + "_2uQInXPdOY-DpYTO1Prt": { + "title": "async-std", + "description": "`async-std` provides an asynchronous version of Rust's standard library, offering familiar APIs for async programming. It includes its own runtime, task scheduler, and async I/O primitives, designed as a drop-in replacement for std with async capabilities and intuitive syntax.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: async-std", + "url": "https://docs.rs/async-std/latest/async_std/", + "type": "article" + } + ] + }, + "3C9gCBAq3OQVb583S72D4": { + "title": "smol", + "description": "`smol` is a small, fast async runtime for Rust with minimal API and clean design. Built on async-std and Tokio, it supports async/await natively with efficient scheduling. Offers essential async functionality including timers, futures, and task management with superior performance in a lightweight package.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: smol", + "url": "https://docs.rs/smol/latest/smol/", + "type": "article" + } + ] + }, + "3pL0ARqk8uRNimopHSalW": { + "title": "Networking", + "description": "Rust's `std::net` module provides networking primitives including `TcpStream`, `TcpListener`, `UdpSocket`, and address types. Built on BSD sockets, it offers low-level network operations for building networking applications. Higher-level crates like Tokio provide async networking capabilities.", + "links": [] + }, + "TtajUXZpyNx9AmdUawm-8": { + "title": "reqwest", + "description": "`reqwest` is a popular HTTP client library for Rust that provides both sync and async APIs for making HTTP requests. Built on `hyper` and `tokio`, it supports JSON, forms, cookies, and various authentication methods with an ergonomic, easy-to-use interface for web API interactions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: Reqwest", + "url": "https://docs.rs/reqwest/latest/reqwest/", + "type": "article" + } + ] + }, + "-MiN5ytI43EjgmWV55BhU": { + "title": "hyper", + "description": "Hyper is a fast, safe HTTP client/server library for Rust built on Tokio for async I/O. It supports HTTP/1 and HTTP/2 with automatic protocol negotiation. Hyper provides low-level HTTP primitives that power many higher-level web frameworks and serves as the foundation for efficient network programming.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Official Website", + "url": "https://hyper.rs/", + "type": "article" + }, + { + "title": "Docs.rs: Hyper", + "url": "https://docs.rs/hyper/latest/hyper/", + "type": "article" + } + ] + }, + "qi1pmsY8bPk8nbHiBIGha": { + "title": "quinn", + "description": "`Quinn` is a high-performance QUIC protocol implementation for Rust built on Tokio. QUIC is a modern transport protocol offering better performance than TCP with multiplexing and security. Quinn provides async, futures-based API supporting both client and server roles for networking applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: quinn", + "url": "https://docs.rs/quinn/latest/quinn/", + "type": "article" + } + ] + }, + "gcmKSLWfBqx4aPZOmyQsg": { + "title": "Serialization / Deserialization", + "description": "Serialization converts Rust data structures into bytes for storage or transmission, while deserialization reverses the process. Serde is the standard framework with support for JSON, YAML, TOML, Binary, and more formats. Provides efficient, type-safe data conversion.", + "links": [] + }, + "EHErECEYws05oi59OsZpC": { + "title": "Serde", + "description": "Serde is Rust's most popular serialization framework for converting data structures to/from formats like JSON, YAML, TOML, and Binary. It provides `Serialize` and `Deserialize` traits with derive macros for automatic implementation. Offers high performance with customizable behavior for complex use cases.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Official Website", + "url": "https://serde.rs/", + "type": "article" + }, + { + "title": "Docs.rs: Serde", + "url": "https://docs.rs/serde/latest/serde/", + "type": "article" + } + ] + }, + "ZXMKY0f7mqqlsvyH9u-LM": { + "title": "json-rust", + "description": "JSON handling in Rust primarily uses `serde` and `serde_json` libraries for high-performance serialization/deserialization. These provide seamless conversion between Rust data structures and JSON, with parsing from strings/files, serialization to JSON, and direct manipulation of JSON values.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Docs.rs: JSON", + "url": "https://docs.rs/json/latest/json/", + "type": "article" + }, + { + "title": "Explore top posts about Rust", + "url": "https://app.daily.dev/tags/rust?ref=roadmapsh", + "type": "article" + } + ] + }, + "toml-rust@LmFog_qXrS9e5ARhV6OD_.md": { + "title": "toml-rust", + "description": "", + "links": [] + }, + "_n7emeqzf5UTxVB5-385G": { + "title": "Database and ORM", + "description": "ORMs (Object-Relational Mapping) provide abstraction layers between Rust code and SQL databases. Popular Rust ORMs include Diesel (compile-time safety), SQLx (async with compile-time query checking), and Sea-ORM. They eliminate raw SQL writing while maintaining type safety and performance.", + "links": [] + }, + "UAXpBK3lfnq0Q4RcBehZ1": { + "title": "Diesel", + "description": "Diesel is a safe, extensible ORM and query builder for Rust that provides compile-time guarantees against SQL injection and type mismatches. It supports PostgreSQL, MySQL, and SQLite with high-level APIs for database operations while maintaining excellent performance and type safety.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Repository", + "url": "https://github.com/diesel-rs/diesel", + "type": "opensource" + }, + { + "title": "Diesel", + "url": "https://diesel.rs/", + "type": "article" + }, + { + "title": "Docs.rs: Diesel", + "url": "https://docs.rs/diesel/latest/diesel/", + "type": "article" + }, + { + "title": "YouTube", + "url": "https://www.youtube.com/watch?v=tRC4EIKhMzw", + "type": "video" + } + ] + }, + "r2KembNZ2WIzLe87EB91K": { + "title": "sqlx", + "description": "SQLx is an async, pure-Rust SQL toolkit providing compile-time query checking for PostgreSQL, MySQL, SQLite, and MSSQL. It features macro-based query validation, strong typing, and compatibility with Tokio/async-std runtimes. SQLx eliminates runtime SQL errors through compile-time verification.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Repository", + "url": "https://github.com/launchbadge/sqlx", + "type": "opensource" + }, + { + "title": "Docs.rs: sqlx", + "url": "https://docs.rs/sqlx/latest/sqlx/", + "type": "article" + } + ] + }, + "a2MLN7f-FvsgdmvP9ixlv": { + "title": "rusqlite", + "description": "`rusqlite` is an ergonomic SQLite library for Rust built around the sqlite3 C library. It provides simple, efficient database operations with minimal SQL knowledge required. Features seamless `serde` integration for type-safe bidirectional mapping between SQL and Rust data structures.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Repository", + "url": "https://github.com/rusqlite/rusqlite", + "type": "opensource" + }, + { + "title": "Docs.rs: rusqlite", + "url": "https://docs.rs/rusqlite/latest/rusqlite/", + "type": "article" + } + ] + }, + "Rv_Z-rbtELPZ1Nv0PZQmV": { + "title": "Cryptography", + "description": "Cryptography involves securing data through encryption (making readable data unreadable) and decryption (reversing the process). Rust offers crypto libraries like `ring`, `sodiumoxide`, and `rust-crypto` for hashing, symmetric/asymmetric encryption, and digital signatures with memory-safe implementations.", + "links": [] + }, + "f68x7r-qzaQfrzXnjOI2q": { + "title": "rust-crypto", + "description": "`rust-crypto` is a collection of cryptographic algorithms implemented in pure Rust including AES, DES ciphers, SHA, MD5 hash functions, and RSA digital signatures. Known for speed and low memory usage, making it suitable for resource-constrained systems requiring cryptographic functionality.", + "links": [] + }, + "hzzRFb5cyXkgUdLZxaozB": { + "title": "sodiumoxide", + "description": "`sodiumoxide` is a Rust binding to libsodium cryptography library, designed for easy use and misuse prevention. Provides safe, high-level, idiomatic Rust wrappers for cryptographic primitives with automatic error handling. Follows NaCl design principles for simplicity while offering libsodium performance benefits.", + "links": [] + }, + "w8nxQDxmfoUHkFV66TKiq": { + "title": "ring", + "description": "`ring` is a safe, fast cryptography library for Rust focused on TLS and core cryptographic primitives. It includes RSA, AES, SHA, and other algorithms with compile-time and runtime safety checks. Restricts usage to safe, reviewed algorithms to prevent common cryptographic pitfalls and insecure implementations.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "ring", + "url": "https://github.com/briansmith/ring", + "type": "opensource" + }, + { + "title": "Docs.rs: ring", + "url": "https://docs.rs/ring/latest/ring/", + "type": "article" + } + ] + }, + "2Zyyf9q_CxmOW-z2pipL8": { + "title": "CLI Utilities", + "description": "CLI utilities are command-line tools that allow users to interact with their system through text commands. Rust is excellent for building fast, reliable CLI tools due to its memory safety and performance. Popular crates like clap and structopt help parse command-line arguments, handle input validation, and generate help messages, making CLI development efficient.", + "links": [] + }, + "AId80IokM7NvGBVutmuGC": { + "title": "clap", + "description": "`clap` is Rust's most popular command-line argument parser library. It provides declarative CLI definition with automatic help generation, subcommands, validation, and error handling. Supports both builder pattern and derive macros for easy CLI app development with comprehensive features.", + "links": [] + }, + "_43912wPdXgLL8v-IMHX_": { + "title": "structopt", + "description": "`StructOpt` is a library for parsing command-line arguments by defining structs where fields represent flags, options, and arguments. Combines `clap`'s parsing power with Rust's type system for declarative CLI definition with automatic help generation, strong typing, and validation.", + "links": [] + }, + "YS0igALDqSanGDWva_vls": { + "title": "termion", + "description": "`termion` is a pure Rust, zero-dependency library for low-level terminal manipulation and information handling. Provides cross-terminal compatibility with features like color support, input handling, and terminal-specific capabilities. Ideal for building cross-platform CLI applications without external bindings.", + "links": [] + }, + "uG-EmZVZ-jc3mswOT4-7l": { + "title": "Game Development", + "description": "Rust's performance and memory safety make it excellent for game development. Popular engines and frameworks include Bevy (ECS-based), Macroquad, ggez, and Fyrox. Rust handles both 2D and 3D games efficiently, with growing ecosystem support for graphics, audio, and physics.", + "links": [] + }, + "uyrGki0jB7DXQ0HJe2-vY": { + "title": "bevy", + "description": "Bevy is a modern, data-driven game engine built in Rust featuring an ECS (Entity Component System) architecture. It supports both 2D and 3D games with modular design, custom shaders, and high performance. Bevy emphasizes developer ergonomics and provides comprehensive tools for game development.", + "links": [] + }, + "x9bmK_cLYpX0ebwjZUn4R": { + "title": "fyrox", + "description": "Fyrox is a modern, highly optimized 3D game engine designed specifically for Rust. Leverages Rust's safety and concurrency for high performance and reliability. Features advanced lighting, shadowing, support for common 3D formats, and low-level hardware control for performance-critical applications.", + "links": [] + }, + "qquYnrrzUlyd8738jzj1D": { + "title": "ggez", + "description": "`ggez` is a lightweight 2D game framework for Rust inspired by Love2D. Provides facilities for graphics rendering, input handling, audio manipulation, and game timing with an easy, Rusty interface. Enables developers to focus on game logic without worrying about low-level implementation details.", + "links": [] + }, + "EtKhe3lgK3NoiBOjXRb2O": { + "title": "macroquad", + "description": "Macroquad is a simple, cross-platform 2D game engine for Rust focusing on rapid prototyping and development. Features efficient rendering via miniquad, input handling, coroutine-based async programming, and sound support. Portable across Windows, macOS, Linux, WebAssembly, Android, and iOS.", + "links": [] + }, + "6wGShK9WEnXiby_Jm8sTO": { + "title": "wgpu-rs", + "description": "`wgpu-rs` provides safe, idiomatic Rust graphics programming by abstracting over wgpu-core. Offers high-level convenience with low-level control options. Provides unified access to graphics and compute functionality across Vulkan, Metal, DirectX, and WebGPU backends for cross-platform compatibility.", + "links": [] + }, + "T1LlJz5m5wnwBvKAEuGnP": { + "title": "GUI Development", + "description": "Rust offers several GUI frameworks for desktop applications including Tauri (web-based), Iced (inspired by Elm), Druid, GTK-rs, and Egui. These provide cross-platform support for creating native desktop applications with modern UI patterns and performance benefits of Rust.", + "links": [] + }, + "Q71MnFDQBkZF1c2hj13pU": { + "title": "tauri", + "description": "Tauri is a framework for building lightweight, secure desktop applications using web technologies (HTML, CSS, JS) with a Rust backend. It offers smaller bundle sizes than Electron, enhanced security, and cross-platform support for Windows, macOS, and Linux with native system integration.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Tauri Website", + "url": "https://tauri.app", + "type": "article" + } + ] + }, + "2Zp3m3Y7j6R1hK3DIVdkH": { + "title": "gtk-rs", + "description": "`gtk-rs` provides Rust bindings for GTK+3 and related libraries (GObject, Glib, Cairo, Pango) enabling cross-platform GUI application development. These open-source libraries offer a Rust-friendly interface for GTK components, allowing developers to create graphical applications using Rust with native GTK functionality.", + "links": [] + }, + "QbdGnUoTLgMHO1NCQINIi": { + "title": "relm", + "description": "`relm` is a declarative, event-driven GUI framework for Rust built on `gtk-rs` and GTK+3. Uses Model-View-Update architecture with async Futures for complex UI interactions. Features widget identification by name, seamless inter-widget communication, and leverages Rust's safe concurrency for dynamic desktop applications.", + "links": [] + }, + "RKXljexmLAceMYwg4D_uP": { + "title": "Embedded and Systems", + "description": "Rust excels in embedded systems programming for microcontrollers and real-time applications. Its zero-cost abstractions, memory safety, and low-level control make it ideal for resource-constrained environments. Popular for IoT devices, firmware, and system-level programming without garbage collection overhead.", + "links": [] + }, + "LzaO2cpDajXERqEYDjMl_": { + "title": "embedded-hal", + "description": "`embedded-hal` (Hardware Abstraction Layer) provides generic traits for creating portable embedded drivers in Rust. Enables hardware-agnostic code by abstracting digital I/O, UART, I2C, SPI, and other communication protocols into a uniform API, promoting code reuse across different hardware platforms.", + "links": [] + }, + "L01rVq2_H4rWzlKygW5kA": { + "title": "rppal", + "description": "`RPPAL` (Raspberry Pi Peripheral Access Library) provides Rust access to Raspberry Pi GPIO, I2C, PWM, SPI, and UART peripherals. Features comprehensive interrupt handling, software-based PWM, and I2C/SPI buses. Supports all Raspberry Pi models running Raspbian/Debian Stretch or newer.", + "links": [] + }, + "ETYrk0s5Wn80XyntNG_t1": { + "title": "nrf-hal", + "description": "`nrf-hal` is a Rust Peripheral Access Crate for Nordic Semiconductor nRF52 and nRF91 series chips. Provides high-level, semantic interfaces for GPIO, timers, RNG, RTC, I2C/SPI, temperature sensors, and delay routines. Open-source Apache licensed library abstracting direct register access.", + "links": [] + }, + "fusu4ZHH4-cjoouLr4F9U": { + "title": "WebAssembly (WASM)", + "description": "WebAssembly is a binary instruction format that runs at near-native speed in web browsers and other environments. Rust compiles excellently to WASM with tools like `wasm-pack` and `wasm-bindgen`, enabling high-performance web applications and cross-platform deployment.", + "links": [] + }, + "SUtBBqqDeR_yAkr669ZvE": { + "title": "wasm-bindgen", + "description": "`wasm-bindgen` facilitates high-level interactions between Rust and JavaScript in WebAssembly. It generates bindings allowing seamless communication, JavaScript API calls from Rust, and vice versa. Handles memory representations and call semantics for complex data types like strings and objects.", + "links": [] + }, + "TSlj7mMUB5CDTy8uMFzKV": { + "title": "wasm-pack", + "description": "`wasm-pack` is a command-line tool for assembling and packaging Rust crates targeting WebAssembly. It bridges Rust/WASM and JavaScript, generating necessary files for npm publishing. Ensures proper Rust-to-WASM compilation setup with focus on ergonomics, performance, and correctness.", + "links": [] + }, + "iyFHvZj_ntr_dX6WlL4E1": { + "title": "wasmer", + "description": "Wasmer is a standalone WebAssembly runtime designed to run WASM files on any platform quickly and efficiently. Features a pluggable system with different compiling strategies, friendly CLI, and embedding APIs for calling WASM functions directly from various programming languages. Lightweight and modular.", + "links": [] + }, + "7YKWYxogJq6X35IAUwcZF": { + "title": "Debugging", + "description": "Rust provides excellent debugging support through `rust-gdb` and `rust-lldb` debuggers, along with built-in macros like `println!`, `dbg!`, and `debug!`. The strict compiler catches many bugs at compile-time, while runtime debugging is enhanced by panic backtraces and comprehensive error messages.", + "links": [] + }, + "UkHXsAolmbk-MsJFfqObC": { + "title": "rust-gdb", + "description": "`rust-gdb` is GDB (GNU Project debugger) enhanced for Rust debugging. It provides low-level debugging capabilities including breakpoints, execution tracing, runtime modification, and memory inspection. Designed for command-line debugging with deep system integration for comprehensive Rust application analysis.", + "links": [] + }, + "p1w1iljGABgHoJjIRJYLY": { + "title": "rust-lldb", + "description": "`rust-lldb` is LLDB debugger enhanced with Rust-specific modifications for understanding Rust data structures and concepts. It includes pretty-printers for standard library types and comes bundled with the Rust compiler, providing better debugging experience for Rust applications.", + "links": [] + }, + "65nbahPj9qAb9y8dF8Jnd": { + "title": "Documenting with `rustdoc`", + "description": "", + "links": [] + }, + "WduD9VIcYSs_JTnuMNyxk": { + "title": "Performance and Profiling", + "description": "Performance profiling in Rust identifies bottlenecks using tools like `perf`, `cargo bench`, `criterion`, and `flamegraph`. These tools collect statistical data about runtime performance, helping developers optimize code efficiently by targeting actual problem areas rather than guessing.", + "links": [] + }, + "clQ26LFV_9AdQ4evnaxUK": { + "title": "Criterion.rs", + "description": "`Criterion.rs` is a statistics-driven microbenchmarking library for Rust that provides reliable performance analysis over time. It offers detailed feedback, automatic outlier detection, and statistical methods to compare algorithm performance and track regressions with actionable insights.", + "links": [] + } +} \ No newline at end of file diff --git a/public/roadmap-content/software-design-architecture.json b/public/roadmap-content/software-design-architecture.json new file mode 100644 index 000000000..fafe0dafc --- /dev/null +++ b/public/roadmap-content/software-design-architecture.json @@ -0,0 +1,1329 @@ +{ + "TJZgsxpfOmltUUChMzlEM": { + "title": "Clean Code", + "description": "Clean code is code that is easy to read, understand, and maintain. It follows a set of principles that are designed to make the code more readable, testable, and less error-prone. Some of the key principles of clean code include:\n\n* Clarity: The code should be easy to read and understand.\n* Simplicity: The code should be as simple as possible, avoiding unnecessary complexity.\n* Comments: Comments should be used sparingly and only when necessary to explain complex or non-obvious code.\n* Naming: Variables, functions, and classes should have meaningful and descriptive names.\n* Formatting: The code should be consistently formatted to improve readability.\n* Functionality: The code should be organized into small, single-purpose functions and classes.\n* Error handling: The code should handle errors in a consistent and predictable way.\n* Testing: The code should be testable and have a high test coverage.\n* Reusability: The code should be designed to be reusable and modular.\n* Performance: The code should be designed to be efficient and performant.\n\nLearn more from the following links:", + "links": [ + { + "title": "Introduction to Clean Code & Software Design Principles", + "url": "https://workat.tech/machine-coding/tutorial/introduction-clean-code-software-design-principles-nwu4qqc63e09", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "RgYq3YOJhPGSf5in1Rcdp": { + "title": "Programming Paradigms", + "description": "A programming paradigm is a fundamental style or approach to solving problems using a programming language. Different programming paradigms provide different ways of organizing and structuring code, and have different strengths and weaknesses. Some of the most common programming paradigms include:\n\n* Imperative programming\n* Functional programming\n* Object-oriented programming\n* Logic programming\n* Declarative programming\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Programming paradigm", + "url": "https://en.wikipedia.org/wiki/Programming_paradigm", + "type": "article" + } + ] + }, + "qZQDOe2MHBh8wNcmvkLQm": { + "title": "Object Oriented Programming", + "description": "Object-oriented programming (OOP) is a programming paradigm that is based on the concept of \"objects,\" which are instances of a class. In OOP, a class is a blueprint for creating objects, which have both data (attributes) and behavior (methods). The main idea behind OOP is to model real-world objects and their interactions, making it well-suited for creating complex and large-scale software systems.\n\nLearn more from the following links:", + "links": [ + { + "title": "Discover Object Oriented Programming", + "url": "https://opendsa.cs.vt.edu/ODSA/Books/Everything/html/IntroOO.html", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + }, + { + "title": "Software Development Tutorial - What is object-oriented language?s", + "url": "https://www.youtube.com/watch?app=desktop&v=SS-9y0H3Si8", + "type": "video" + } + ] + }, + "p96fNXv0Z4rEEXJR9hAYX": { + "title": "Design Principles", + "description": "", + "links": [] + }, + "gyQw885dvupmkohzJPg3a": { + "title": "Design Patterns", + "description": "Design patterns are general solutions to common problems that arise in software development. They provide a way to describe and communicate proven solutions to common design problems and they provide a common vocabulary for design. They are not specific to any particular programming language or technology, but rather describe the problem and the solution in a way that can be applied to many different contexts.\n\nThere are several different types of design patterns, including:\n\n* Creational patterns\n* Structural patterns\n* Behavioral patterns\n* Architectural patterns\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview - Software Design Pattern", + "url": "https://en.wikipedia.org/wiki/Software_design_pattern", + "type": "article" + }, + { + "title": "Explaining, imaging and simplifying design patterns", + "url": "https://refactoring.guru/design-patterns/what-is-pattern", + "type": "article" + }, + { + "title": "Explore top posts about Design Patterns", + "url": "https://app.daily.dev/tags/design-patterns?ref=roadmapsh", + "type": "article" + }, + { + "title": "What Are Design Patterns?", + "url": "https://www.youtube.com/watch?v=BWprw8UHIzA", + "type": "video" + } + ] + }, + "XBCxWdpvQyK2iIG2eEA1K": { + "title": "Architectural Principles", + "description": "Architectural principles refer to a set of guidelines or rules that are used to guide the design and development of a software architecture. These principles are intended to ensure that the resulting architecture is maintainable, scalable, and easy to understand and modify. Some common architectural principles include the separation of concerns, modularity, loose coupling, and high cohesion. Additionally, architectural principles are often used in conjunction with design patterns, which are reusable solutions to common software design problems.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Intro to Architectural Principles", + "url": "https://learn.microsoft.com/en-us/dotnet/architecture/modern-web-apps-azure/architectural-principles", + "type": "article" + }, + { + "title": "Principles of Software Design", + "url": "https://www.youtube.com/watch?v=TO9igqkPtfc", + "type": "video" + } + ] + }, + "En_hvwRvY6k_itsNCQBYE": { + "title": "Architectural Styles", + "description": "Architectural styles in software refer to the overall design and organization of a software system, and the principles and patterns that are used to guide the design. These styles provide a general framework for the design of a system, and can be used to ensure that the system is well-structured, maintainable, and scalable.\n\nSome common architectural styles in software include:\n\n* Microservices: where the system is built as a collection of small, independent, and loosely-coupled services.\n* Event-Driven: where the system reacts to specific events that occur, rather than being continuously polled for changes.\n* Layered: where the system is divided into a set of layers, each of which has a specific responsibility and communicates with the other layers through well-defined interfaces.\n* Service-Oriented: where the system is built as a collection of services that can be accessed over a network.\n* Data-Centric: where the system is focused on the storage, retrieval and manipulation of data, rather than the processing of data.\n* Component-Based: where the system is composed of reusable and independent software components.\n* Domain-Driven: where the system is organized around the core business domain and business entities.\n\nLearn more from the following links:", + "links": [ + { + "title": "What is Software Architecture & Styles?", + "url": "https://study.com/academy/lesson/software-architecture-styles-patterns-components.html", + "type": "article" + }, + { + "title": "Types of Architectural Styles in Software Engineering", + "url": "https://www.youtube.com/watch?v=2Pp0BcXN9YY", + "type": "video" + }, + { + "title": "10 Architecture Patterns Used In Enterprise Software Development Today", + "url": "https://www.youtube.com/watch?v=brt3ao8bvqy", + "type": "video" + } + ] + }, + "jq916t7svaMw5sFOcqZSi": { + "title": "Architectural Patterns", + "description": "Architectural patterns are a set of solutions that have been proven to work well for specific types of software systems. They provide a common vocabulary and set of best practices for designing and building software systems, and can help developers make better design decisions. Some common architectural patterns include:\n\n* Model-View-Controller (MVC): A pattern for separating the user interface, business logic, and data storage components of a system.\n* Microservices: A pattern for building systems as a collection of small, independently deployable services that communicate over a network.\n* Event-Driven: A pattern for building systems that respond to events and perform actions in response.\n* Layered: A pattern for organizing a system into layers, with each layer providing a specific set of services to the layer above it.\n* Pipe-and-Filter: A pattern for building systems as a series of independent, reusable processing elements that are connected together in a pipeline.\n* Command-Query Responsibility Segregation (CQRS): A pattern for separating the handling of commands (which change the state of the system) from the handling of queries (which retrieve information from the system)\n* Blackboard: A pattern for creating a centralized repository of information that can be accessed and modified by multiple independent modules or subsystems.\n* Microkernel: A pattern that aims to minimize the amount of code running in kernel mode and move as much functionality as possible into user-mode processes.\n* Serverless: A design pattern that allows developers to build and run applications and services without having to provision and manage servers.\n* Message Queues and Streams: A pattern that decouples different components of a system and enables asynchronous communication between them.\n* Event Sourcing: A pattern that stores all changes to the system's state as a sequence of events, rather than just the current state.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview - Architectural Pattern", + "url": "https://en.wikipedia.org/wiki/Architectural_pattern", + "type": "article" + }, + { + "title": "Architecture Patterns Used In Enterprise Software Development", + "url": "https://www.youtube.com/watch?v=BrT3AO8bVQY", + "type": "video" + } + ] + }, + "WrzsvLgo7cf2KjvJhtJEC": { + "title": "Enterprise Patterns", + "description": "Enterprise patterns are a set of design patterns that are commonly used in the development of enterprise software applications. These patterns provide a common vocabulary and a set of best practices for solving common problems that arise in the development of large, complex software systems. Some examples of enterprise patterns include:\n\n* Domain-Driven Design (DDD)\n* Model-View-Controller (MVC)\n* Service Oriented Architecture (SOA)\n* Command and Query Responsibility Segregation (CQRS)\n* Event Sourcing\n* Microservices\n* Event-Driven Architecture (EDA)\n\nThese patterns can help to improve the maintainability and scalability of the software, by providing a clear separation of concerns and allowing for a more modular and flexible architecture.\n\nLearn more from the following links:", + "links": [ + { + "title": "Software Architecture Patterns in Enterprise Software", + "url": "https://blog.devgenius.io/10-software-architecture-patterns-in-enterprise-software-development-fabacb5ed0c8", + "type": "article" + }, + { + "title": "Explore top posts about Enterprise", + "url": "https://app.daily.dev/tags/enterprise?ref=roadmapsh", + "type": "article" + }, + { + "title": "What are Enterprise Integration Patterns?", + "url": "https://www.youtube.com/watch?v=WNm3QmJadNs", + "type": "video" + } + ] + }, + "08qKtgnhJ3tlb5JKfTDf5": { + "title": "Clean Code Principles", + "description": "Clean code is code that is easy to read, understand, and maintain. It follows a set of principles that are designed to make the code more readable, testable, and less error-prone. Some of the key principles of clean code include:\n\n* Clarity: The code should be easy to read and understand.\n* Simplicity: The code should be as simple as possible, avoiding unnecessary complexity.\n* Comments: Comments should be used sparingly and only when necessary to explain complex or non-obvious code.\n* Naming: Variables, functions, and classes should have meaningful and descriptive names.\n* Formatting: The code should be consistently formatted to improve readability.\n* Functionality: The code should be organized into small, single-purpose functions and classes.\n* Error handling: The code should handle errors in a consistent and predictable way.\n* Testing: The code should be testable and have a high test coverage.\n* Reusability: The code should be designed to be reusable and modular.\n* Performance: The code should be designed to be efficient and performant.\n\nLearn more from the following links:", + "links": [ + { + "title": "Introduction to Clean Code & Software Design Principles", + "url": "https://workat.tech/machine-coding/tutorial/introduction-clean-code-software-design-principles-nwu4qqc63e09", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "2SOZvuEcy8Cy8ymN7x4L-": { + "title": "Be consistent", + "description": "Being consistent refers to maintaining a consistent pattern. This can include using consistent naming conventions, data structures, and interfaces throughout the system, as well as adhering to established design principles and best practices. Consistency can help to make the system more maintainable, understandable, and extendable.\n\nLearn more from the following links:", + "links": [ + { + "title": "10 Tips for Writing Clean Code", + "url": "https://www.pluralsight.com/blog/software-development/10-steps-to-clean-code", + "type": "article" + } + ] + }, + "6Cd1BbGsmPJs_5jKhumyV": { + "title": "Meaningful names over comments", + "description": "You should follow the practice of giving clear and descriptive names to different components of a system, such as variables, functions, and classes. This can help to make the system more understandable and maintainable by clearly communicating the purpose of each component and its intended usage.\n\nLearn more from the following links:", + "links": [ + { + "title": "A Guide for Naming Things in Programming", + "url": "https://levelup.gitconnected.com/a-guide-for-naming-things-in-programming-2dc2d74879f8", + "type": "article" + } + ] + }, + "81WOL1nxb56ZbAOvxJ7NK": { + "title": "Indentation and Code Style", + "description": "Indentation is the practice of using whitespace to visually group related lines of code together, making it easier to read and understand the structure of the code. Code style refers to the conventions and guidelines used to format and structure code, such as naming conventions, commenting, and use of whitespace.\n\nHaving a consistent indentation and code style can help to make the code more readable and understandable, which can improve the maintainability of the system.\n\nLearn more from the following links:", + "links": [ + { + "title": "Clean Code – Formatting", + "url": "https://www.baeldung.com/cs/clean-code-formatting", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "XEwC6Fyf2DNNHQsoGTrQj": { + "title": "Keep methods / classes / files small", + "description": "You should design and implement small, focused components that serve a specific purpose, rather than large, monolithic components that try to do everything. This can help to improve the maintainability and scalability of the system by making it easier to understand, test, and modify individual components.", + "links": [] + }, + "5S5A5wCJUCNPLlHJ5fRjU": { + "title": "Pure functions", + "description": "A pure function is a specific type of function that meets the following criteria:\n\n* It takes some input, known as arguments, and returns a value or output.\n* It does not cause any observable side effects, such as modifying the state of the system or interacting with external resources.\n* Given the same input, it will always return the same output.\n* It does not depend on any state or variables that are outside of its scope.\n\nPure functions are considered to be more predictable and easier to test, as their behavior is determined solely by the input they receive and their internal logic. They also make it easier to reason about the behavior of a program, since the output of a pure function is not affected by any external factors. Pure functions are often used in functional programming, where they are considered a key principle. They are also useful in concurrent and parallel programming, as they are less prone to race conditions and other concurrency-related issues.", + "links": [] + }, + "qZzl0hAD2LkShsPql1IlZ": { + "title": "Minimize cyclomatic complexity", + "description": "Cyclomatic complexity is a measure of the structural complexity of a program, which is determined by the number of linearly independent paths through a program's control flow. High cyclomatic complexity can make a program difficult to understand, test, and maintain, so it's often desirable to minimize it in system architecture.\n\nHere are some ways to minimize cyclomatic complexity in system architecture:\n\n* Break down complex functions into smaller, simpler functions that perform specific tasks.\n* Use control structures, such as if-else statements and loops, in a consistent and predictable way.\n* Use functional programming concepts and techniques, such as immutability and pure functions, to reduce the need for complex control flow.\n* Use design patterns, such as the state pattern, to simplify complex control flow.\n* Regularly review the code and refactor it to simplify the control flow.\n* Use static code analysis tools that can detect and report high cyclomatic complexity in the code.\n\nBy following these best practices, the system architecture will be more maintainable, testable, and less error-prone.\n\nLearn more from the following links:", + "links": [ + { + "title": "How to reduce cyclomatic complexity?", + "url": "https://kasp9023.medium.com/how-to-make-your-code-more-readable-focus-on-the-happy-path-and-reduce-cyclomatic-complexity-66802b8897b5", + "type": "article" + } + ] + }, + "yyKvmutbxu3iVHTuqr5q4": { + "title": "Avoid passing nulls, booleans", + "description": "Passing nulls or Booleans can lead to unexpected behavior and difficult-to-debug errors in a program. Here are some ways to avoid passing nulls or Booleans in system architecture:\n\n* Use Optionals or Maybe types instead of nulls to indicate the absence of a value. This makes it clear when a value is missing and prevents null reference exceptions.\n* Use a default value for function arguments instead of allowing them to be null or Boolean. This eliminates the need to check for null or Boolean values and reduces the potential for errors.\n* Use the Null Object pattern to replace null values with a special object that has a defined behavior. This eliminates the need to check for null values and makes the code more readable.\n* Use the Ternary operator (?:) instead of if-else statements when working with Booleans. This can make the code more concise and easier to read.\n* Use the assert function to check the validity of function arguments and throw an exception if they are invalid.\n\nBy following these best practices, the system architecture will be more robust and less error-prone.", + "links": [] + }, + "OoCCy-3W5y7bUcKz_iyBw": { + "title": "Keep framework code distant", + "description": "Keeping framework code distant refers to separating the application's code from the framework's code. By doing so, it makes it easier to maintain, test, and upgrade the application's codebase and the framework independently.\n\nHere are some ways to keep framework code distant in system architecture:\n\n1. Use an abstraction layer to separate the application code from the framework code. This allows the application code to be written without the need to know the specifics of the framework.\n2. Use dependency injection to decouple the application code from the framework code. This allows the application code to use the framework's functionality without having to instantiate the framework objects directly.\n3. Avoid using framework-specific libraries or classes in the application code. This makes it easier to switch to a different framework in the future if needed.\n4. Use a standard interface for the application code to interact with the framework. This allows the application code to be written without the need to know the specifics of the framework.\n5. Keep the application and the framework code in separate projects and/or repositories.\n\nBy following these best practices, the system architecture will be more maintainable, testable, and less error-prone, and it will be easier to upgrade or switch the framework if needed.\n\nLearn more from the following links:", + "links": [ + { + "title": "Clean architecture", + "url": "https://pusher.com/tutorials/clean-architecture-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "S1m7ty7Qrzu1rr4Jl-WgM": { + "title": "Use correct constructs", + "description": "In the context of clean code principles, \"using correct constructs\" refers to using appropriate programming constructs, such as loops, conditionals, and functions, in a way that makes the code easy to understand, maintain, and modify.\n\nWhen using correct constructs, the code should be organized in a logical and intuitive way, making use of appropriate control flow statements and data structures to accomplish the task at hand. This also means that the code should avoid using unnecessary or overly complex constructs that make the code harder to understand or reason about.\n\nAdditionally, correct constructs also means to use the right constructs for the right problem, for example, if you want to iterate over an array, use a for loop instead of recursion and also, you should avoid using global variables and instead use function arguments and return values to pass data between different parts of the code.\n\nBy using correct constructs, the code will be more readable, more maintainable, and less prone to bugs, making it easier for other developers to understand, debug and extend the code.", + "links": [] + }, + "mzt7fvx6ab3tmG1R1NcLO": { + "title": "Tests should be fast and independent", + "description": "", + "links": [] + }, + "kp86Vc3uue3IxTN9B9p59": { + "title": "Organize code by actor it belongs to", + "description": "", + "links": [] + }, + "tLbckKmfVxgn59j_dlh8b": { + "title": "Command query separation", + "description": "Command-Query Separation (CQS) is a software design principle that separates the responsibilities of a method or function into two categories: commands and queries. Commands are methods that change the state of the system, while queries are methods that return information but do not change the state of the system.\n\nLearn more from the following links:", + "links": [ + { + "title": "CQS Pattern", + "url": "https://martinfowler.com/bliki/CommandQuerySeparation.html", + "type": "article" + } + ] + }, + "9naCfoHF1LW1OEsVZGi8v": { + "title": "Keep it simple and refactor often", + "description": "Keeping framework code distant refers to separating the application's code from the framework's code. By doing so, it makes it easier to maintain, test, and upgrade the application's codebase and the framework independently.\n\nHere are some ways to keep framework code distant in system architecture:\n\n1. Use an abstraction layer to separate the application code from the framework code. This allows the application code to be written without the need to know the specifics of the framework.\n2. Use dependency injection to decouple the application code from the framework code. This allows the application code to use the framework's functionality without having to instantiate the framework objects directly.\n3. Avoid using framework-specific libraries or classes in the application code. This makes it easier to switch to a different framework in the future if needed.\n4. Use a standard interface for the application code to interact with the framework. This allows the application code to be written without the need to know the specifics of the framework.\n5. Keep the application and the framework code in separate projects and/or repositories.\n\nBy following these best practices, the system architecture will be more maintainable, testable, and less error-prone, and it will be easier to upgrade or switch the framework if needed.\n\nLearn more from the following links:", + "links": [ + { + "title": "Clean architecture", + "url": "https://pusher.com/tutorials/clean-architecture-introduction/", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "TDhTYdEyBuOnDKcQJzTAk": { + "title": "Programming Paradigms", + "description": "A programming paradigm is a fundamental style or approach to solving problems using a programming language. Different programming paradigms provide different ways of organizing and structuring code, and have different strengths and weaknesses. Some of the most common programming paradigms include:\n\n* Imperative programming\n* Functional programming\n* Object-oriented programming\n* Logic programming\n* Declarative programming\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Programming paradigm", + "url": "https://en.wikipedia.org/wiki/Programming_paradigm", + "type": "article" + } + ] + }, + "VhSEH_RoWFt1z2lial7xZ": { + "title": "Structured Programming", + "description": "Structured programming is a programming paradigm that emphasizes the use of well-structured control flow constructs such as loops, conditionals, and subroutines. It was developed in the 1960s and 1970s as a reaction to the \"spaghetti code\" produced by the widespread use of goto statements.\n\nLearn more from the following links:", + "links": [ + { + "title": "Structured Programming Wikipedia", + "url": "https://en.wikipedia.org/wiki/Structured_programming", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "YswaOqZNYcmDwly2IXrTT": { + "title": "Functional Programming", + "description": "Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids changing-state and mutable data. It emphasizes the use of functions to solve problems, often using higher-order functions, immutability, and recursion. Instead of modifying data, functional programming creates new data structures.\n\nLearn more from the following links:", + "links": [ + { + "title": "What is Functional Programming?", + "url": "https://medium.com/javascript-scene/master-the-javascript-interview-what-is-functional-programming-7f218c68b3a0", + "type": "article" + }, + { + "title": "Explore top posts about Functional Programming", + "url": "https://app.daily.dev/tags/functional-programming?ref=roadmapsh", + "type": "article" + } + ] + }, + "VZrERRRYhmqDx4slnZtdc": { + "title": "Object Oriented Programming", + "description": "Object-oriented programming (OOP) is a programming paradigm that uses objects and classes to structure and organize code. In OOP, an object is an instance of a class, which is a template that defines the properties and behaviors of the object. OOP is based on the principles of encapsulation, inheritance, and polymorphism.\n\nLearn more from the following links:", + "links": [ + { + "title": "What is Object Oriented Programming?", + "url": "https://www.freecodecamp.org/news/what-is-object-oriented-programming/", + "type": "article" + }, + { + "title": "OOP introduction", + "url": "https://www.geeksforgeeks.org/introduction-of-object-oriented-programming/", + "type": "article" + }, + { + "title": "Explore top posts about OOP", + "url": "https://app.daily.dev/tags/oop?ref=roadmapsh", + "type": "article" + } + ] + }, + "HhYdURE4X-a9GVwJhAyE0": { + "title": "Object Oriented Programming", + "description": "Object-oriented programming (OOP) is a programming paradigm that is based on the concept of \"objects,\" which are instances of a class. In OOP, a class is a blueprint for creating objects, which have both data (attributes) and behavior (methods). The main idea behind OOP is to model real-world objects and their interactions, making it well-suited for creating complex and large-scale software systems.\n\nLearn more from the following links:", + "links": [ + { + "title": "Discover Object Oriented Programming", + "url": "https://opendsa.cs.vt.edu/ODSA/Books/Everything/html/IntroOO.html", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + }, + { + "title": "Software Development Tutorial - What is object-oriented language?s", + "url": "https://www.youtube.com/watch?app=desktop&v=SS-9y0H3Si8", + "type": "video" + } + ] + }, + "0VO_-1g-TS29y0Ji2yCjc": { + "title": "Model-Driven Design", + "description": "Model-driven design (MDD) is a software development methodology in which the design of a system is represented by a set of models, and the models are used to drive the development of the system. MDD is based on the idea that the design of a system can be represented by a set of models, and that these models can be used to generate the code for the system.\n\nThe main advantage of using MDD is that it allows for a clear separation of concerns between the design and implementation of a system. The models represent the design of the system, and the code is generated from the models, which makes it easier to maintain and evolve the system. Additionally, MDD can also improve the quality of the code, as the models can be used to check for design errors and inconsistencies before the code is generated.\n\nLearn more from the following links:", + "links": [ + { + "title": "Model Driven Design – theory to practice", + "url": "https://www.todaysoftmag.com/article/1529/model-driven-design-theory-to-practice", + "type": "article" + } + ] + }, + "I25ghe8xYWpZ-9pRcHfOh": { + "title": "Domain Models", + "description": "A domain model is a representation of a specific area of knowledge or business that is used to model the objects and concepts within that domain, and to capture the relationships and constraints between them. In object-oriented programming (OOP), a domain model is typically represented by a set of classes and interfaces, with each class or interface representing a specific concept or object within the domain.\n\nA domain model is used to provide a clear and consistent representation of the problem domain, and to capture the business requirements and constraints of the system. It is also used to guide the design of the system and to ensure that the system accurately reflects the real-world problem it is intended to solve.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Domain model", + "url": "https://en.wikipedia.org/wiki/Domain_model", + "type": "article" + }, + { + "title": "Domain Driven Design", + "url": "https://khalilstemmler.com/articles/categories/domain-driven-design/", + "type": "article" + } + ] + }, + "c6n-wOHylTbzpxqgoXtdw": { + "title": "Class Variants", + "description": "A class invariant is a set of conditions that must be true for any object of a class, at any point in time. In object-oriented programming (OOP), class invariants are used to define the valid states of an object and to ensure that the object always remains in a valid state.\n\nClass invariants are typically defined in the constructor of a class and are enforced through the use of private methods and data members that are used to validate the state of the object. They are also checked in the class's methods before and after any operation that can change the state of the object.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Class invariant", + "url": "https://en.wikipedia.org/wiki/Class_invariant", + "type": "article" + }, + { + "title": "The concept of class invariant in object-oriented programming", + "url": "https://arxiv.org/abs/2109.06557", + "type": "article" + } + ] + }, + "HN160YgryBBtVGjnWxNie": { + "title": "Layered Architectures", + "description": "A layered architecture is a software design pattern in which the functionality of a system is divided into a set of layers, with each layer having a specific responsibility and interacting with the layers above and below it. The main idea behind a layered architecture is to separate the concerns of the system into distinct and independent layers, making the code more modular, easier to understand, test, and modify.\n\nThere are several types of layered architectures, but a common one is the three-layer architecture which consists of:\n\n* Presentation Layer\n* Business Layer\n* Data Access Layer\n\nLearn more from the following links:", + "links": [ + { + "title": "Software Architecture Patterns — Layered Architecture", + "url": "https://priyalwalpita.medium.com/software-architecture-patterns-layered-architecture-a3b89b71a057", + "type": "article" + }, + { + "title": "5 Primary Layers in Software Architecture?", + "url": "https://www.indeed.com/career-advice/career-development/what-are-the-layers-in-software-architecture", + "type": "article" + }, + { + "title": "Explore top posts about Architecture", + "url": "https://app.daily.dev/tags/architecture?ref=roadmapsh", + "type": "article" + } + ] + }, + "kWNQd3paQrhMHMJzM35w8": { + "title": "Domain Language", + "description": "A domain language is a specific vocabulary and set of concepts used to describe and communicate about a specific area of knowledge or business. In software development, a domain language is used to model the objects and concepts within a specific domain, and to capture the relationships and constraints between them.\n\nA domain language is used to provide a common understanding of the problem domain among all stakeholders, including developers, business analysts, and domain experts. It is also used to ensure that the software system accurately reflects the real-world problem it is intended to solve.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Domain-specific language", + "url": "https://en.wikipedia.org/wiki/Domain-specific_language", + "type": "article" + }, + { + "title": "What are Domain Languages (DSLs)?", + "url": "https://www.jetbrains.com/mps/concepts/domain-specific-languages/", + "type": "article" + } + ] + }, + "nVaoI4IDPVEsdtFcjGNRw": { + "title": "Anemic Models", + "description": "An Anemic model, also known as an anemic domain model, is a type of domain model in which the domain objects only contain data (attributes) and lack behavior. An anemic model often results in the use of data-transfer objects (DTOs) and service layer to handle the behavior.\n\nAn anemic model is considered an anti-pattern in object-oriented programming (OOP) because it violates the principles of encapsulation and separation of concerns. In an anemic model, the behavior is separated from the data, and is typically implemented in a separate service layer, which can lead to a complex, tightly coupled, and hard-to-maintain codebase.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Anemic Domain Model", + "url": "https://en.wikipedia.org/wiki/Anemic_domain_model", + "type": "article" + }, + { + "title": "What is an Anaemic Domain Model?", + "url": "https://www.ensonodigital.com/blog/anaemic-domain-model-vs-rich-domain-model", + "type": "article" + } + ] + }, + "RMkEE7c0jdVFqZ4fmjL6Y": { + "title": "Abstract Classes", + "description": "An abstract class is a class in object-oriented programming (OOP) that cannot be instantiated. Instead, it serves as a template or blueprint for other classes to inherit from. An abstract class can contain both abstract and non-abstract methods (abstract methods are methods that do not have any implementation, they just have a signature).\n\nAbstract classes are used to provide a common interface and implementation for a group of related classes. They are also used to define common behavior that must be implemented by all subclasses. A subclass that inherits from an abstract class is called a concrete class, and it must provide an implementation for all the abstract methods declared in the parent class.\n\nLearn more from the following resources:", + "links": [ + { + "title": "What is an Abstract Class in Object Oriented Programming", + "url": "https://computinglearner.com/abstract-class-in-object-oriented-programming/", + "type": "article" + } + ] + }, + "hd6GJ-H4p9I4aaiRTni57": { + "title": "Concrete Classes", + "description": "A concrete class is a class in object-oriented programming (OOP) that can be instantiated, meaning objects can be created from it. A concrete class is a class that provides an implementation for all of the abstract methods declared in its parent class, if it inherits from an abstract class. A concrete class can also be a class that does not inherit from an abstract class, in that case it can have implementation for all of its methods.\n\nConcrete classes are used to provide specific implementation details for a group of related classes that inherit from a common abstract class. They are also used to define unique behavior for a specific class. A concrete class can have its own methods and variables, and can also override the methods of its parent class.", + "links": [] + }, + "b-YIbw-r-nESVt_PUFQeq": { + "title": "Scope / Visibility", + "description": "Scope visibility refers to the accessibility or visibility of variables, functions, and other elements in a program, depending on the context in which they are defined. In object-oriented programming (OOP), scope visibility is controlled through the use of access modifiers, such as \"public,\" \"private,\" and \"protected.\"\n\n* Public: A public element can be accessed from anywhere in the program, both within the class and outside of it.\n* Private: A private element can only be accessed within the class in which it is defined. It is not accessible to other classes, even if they inherit from the class.\n* Protected: A protected element can only be accessed within the class and its subclasses.\n\nThere are variations of scope visibility based on the programming language, but these are the most common.", + "links": [] + }, + "SrcPhS4F7aT80qNjbv54f": { + "title": "Interfaces", + "description": "In object-oriented programming (OOP), an interface is a contract or a set of methods that a class must implement. It defines a common set of methods that a class must provide, but it does not provide any implementation details. An interface can include both method signatures and constants.\n\nInterfaces are used to define a common behavior for a group of related classes, and to provide a way for objects of different classes to be treated polymorphically. A class that implements an interface must provide an implementation for all of the methods declared in the interface. A class can implement multiple interfaces, but can only inherit from one base class.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Fundamental concepts: What's an Interface?", + "url": "https://www.youtube.com/watch?v=o1jBgdhQsGo", + "type": "video" + } + ] + }, + "Dj36yLBShoazj7SAw6a_A": { + "title": "Inheritance", + "description": "Inheritance is a fundamental concept in object-oriented programming (OOP) that allows a new class to inherit the properties and methods of an existing class. The class that is inherited from is called the parent or super class, while the class that inherits is called the child or sub class. Inheritance enables code reuse and allows for a hierarchical organization of classes, where a child class can inherit the properties and methods of its parent class and potentially add or override them. The main advantage of inheritance is that it allows for a clean and organized way to reuse code and share functionality among classes.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Inheritance (object-oriented programming)", + "url": "https://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)", + "type": "article" + }, + { + "title": "What is inheritance in programming?", + "url": "https://www.youtube.com/watch?v=ajOYOxCanhE", + "type": "video" + } + ] + }, + "4DVW4teisMz8-58XttMGt": { + "title": "Polymorphism", + "description": "Polymorphism is a concept in object-oriented programming (OOP) that allows objects of different classes to be treated as objects of a common parent class. This is achieved by defining a common interface for all classes that need to be treated polymorphically. The word polymorphism is derived from Greek, \"poly\" means many and \"morph\" means form.\n\nThere are two types of polymorphism:\n\n* Compile-time polymorphism (also called static polymorphism or early binding) occurs when the type of the object that is going to be acted upon is determined at compile-time. This is achieved through method overloading, which allows multiple methods to have the same name but different parameters within the same class.\n* Run-time polymorphism (also called dynamic polymorphism or late binding) occurs when the type of the object is determined at run-time. This is achieved through method overriding, which allows a child class to provide a specific implementation of a method that is already defined in its parent class.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Polymorphism in programming", + "url": "https://www.bmc.com/blogs/polymorphism-programming/", + "type": "article" + }, + { + "title": "What is polymorphism in programming?", + "url": "https://www.youtube.com/watch?v=tIWm3I_Zu7I", + "type": "video" + } + ] + }, + "VA8FMrhF4non9x-J3urY8": { + "title": "Abstraction", + "description": "Abstraction is a concept in object-oriented programming (OOP) that refers to the process of hiding the implementation details of an object and exposing only its essential features. It enables the use of objects without the need to understand the underlying complexity of their internal structure and behavior.\n\nThere are two types of abstraction:\n\n* Data abstraction: refers to hiding the internal representation of data and providing a simplified view of the data through a set of well-defined interfaces.\n* Behavioral abstraction: refers to hiding the internal behavior of an object and providing a simplified view of its capabilities through a set of well-defined interfaces.\n\nLearn more from the following links:", + "links": [ + { + "title": "Tutorial - Abstraction", + "url": "https://www.youtube.com/watch?v=OF55HZPE7lQ", + "type": "video" + } + ] + }, + "GJxfVjhiLuuc36hatx9dP": { + "title": "Encapsulation", + "description": "Encapsulation is a concept in object-oriented programming (OOP) that refers to the practice of wrapping an object's internal data and behavior within a defined interface, and hiding the implementation details from the outside world. It is one of the fundamental concepts of OOP and is closely related to the concepts of data hiding and information hiding.\n\nEncapsulation is achieved by using access modifiers (such as \"public,\" \"private,\" and \"protected\") to control the visibility and accessibility of an object's data and methods. For example, data members of a class can be declared as private, which means they can only be accessed by methods within the class, while methods can be declared as public, which means they can be called by any code that has a reference to the object.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Encapsulation", + "url": "https://en.wikipedia.org/wiki/Encapsulation_(computer_programming)", + "type": "article" + }, + { + "title": "Explore top posts about General Programming", + "url": "https://app.daily.dev/tags/general-programming?ref=roadmapsh", + "type": "article" + }, + { + "title": "Tutorial - What is encapsulation in programming?", + "url": "https://www.youtube.com/watch?v=sNKKxc4QHqA", + "type": "video" + } + ] + }, + "9dMbo4Q1_Sd9wW6-HSCA9": { + "title": "Design Principles", + "description": "", + "links": [] + }, + "Izno7xX7wDvwPEg7f_d1Y": { + "title": "Composition over Inheritance", + "description": "Composition over inheritance is a programming principle that suggests that it is better to use composition, a mechanism for assembling objects, to create complex objects, rather than using inheritance, which is a mechanism for creating new classes based on existing ones.\n\nInheritance is a powerful mechanism for creating reusable code, but it can also lead to tightly coupled, hard-to-maintain code. This is because inherited classes are tightly bound to their parent classes and any changes made to the parent class will affect all of its child classes. This makes it hard to change or extend the code without affecting the entire class hierarchy.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Composition over Inheritance", + "url": "https://en.wikipedia.org/wiki/Composition_over_inheritance", + "type": "article" + }, + { + "title": "Tutorial - Composition over Inheritance", + "url": "https://www.youtube.com/watch?v=wfMtDGfHWpA", + "type": "video" + } + ] + }, + "DlefJ9JuJ1LdQYC4WSx6y": { + "title": "Encapsulate what varies", + "description": "Encapsulate what varies is a programming principle that suggests that code should be organized in such a way that the parts that are likely to change in the future are isolated from the parts that are unlikely to change. This is accomplished by creating interfaces and classes that separate the varying parts of the code from the stable parts.\n\nEncapsulating what varies allows for more flexibility in the code. When changes are needed, they can be made to the encapsulated parts without affecting the rest of the code. This makes it easier to understand, test, and maintain the code.\n\nLearn more from the following resources:", + "links": [ + { + "title": "What does it mean when one says “Encapsulate what varies”?", + "url": "https://softwareengineering.stackexchange.com/questions/337413/what-does-it-mean-when-one-says-encapsulate-what-varies", + "type": "article" + }, + { + "title": "Overview of Encapsulate What Varies", + "url": "https://bootcamp.uxdesign.cc/software-design-principles-every-developers-should-know-23d24735518e", + "type": "article" + } + ] + }, + "UZeY36dABmULhsHPhlzn_": { + "title": "Program against abstractions", + "description": "Programming against abstractions is a programming principle that suggests that code should be written in such a way that it is not tied to specific implementations, but rather to abstractions. This is accomplished by defining interfaces or abstract classes that define the behavior of a group of related classes without specifying their implementation.\n\nProgramming against abstractions allows for more flexibility in the code. When changes are needed, they can be made to the implementation of the abstractions without affecting the code that uses them. This makes it easier to understand, test, and maintain the code.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Overview of Abstraction principle", + "url": "https://en.wikipedia.org/wiki/Abstraction_principle_(computer_programming)", + "type": "article" + } + ] + }, + "WzUhKlmFB9alTlAyV-MWJ": { + "title": "Hollywood Principle", + "description": "The Hollywood Principle is a software development principle that states: \"Don't call us, we'll call you.\" It suggests that high-level components should dictate the flow of control in an application, rather than low-level components.\n\nThis principle is often used in the context of inversion of control (IoC) and dependency injection. In traditional software development, low-level components are responsible for creating and managing the high-level components that they depend on. With IoC, the high-level components dictate the flow of control, and the low-level components are created and managed by a separate mechanism.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Tutorial - Hollywood Principle", + "url": "https://www.youtube.com/watch?v=lRuygpsXE5s", + "type": "video" + } + ] + }, + "vnLhItObDgp_XaDmplBsJ": { + "title": "Law of Demeter", + "description": "", + "links": [] + }, + "0rGdh72HjqPZa2bCbY9Gz": { + "title": "Tell, don't ask", + "description": "", + "links": [] + }, + "3XckqZA--knUb8IYKOeVy": { + "title": "SOLID", + "description": "SOLID is an acronym that stands for five principles of object-oriented software development, which were first introduced by Robert C. Martin in the early 2000s. These principles are:\n\n* Single Responsibility Principle (SRP)\n* Open/Closed Principle (OCP)\n* Liskov Substitution Principle (LSP)\n* Interface Segregation Principle (ISP)\n* Dependency Inversion Principle (DIP)\n\nLearn more from the following resources:", + "links": [ + { + "title": "Get Started with SOLID", + "url": "https://www.bmc.com/blogs/solid-design-principles/", + "type": "article" + }, + { + "title": "SOLID Principles", + "url": "https://khalilstemmler.com/articles/tags/solid/", + "type": "article" + }, + { + "title": "Tutorial - What are SOLID principle?", + "url": "https://www.youtube.com/watch?v=aUCo5cy32kE", + "type": "video" + } + ] + }, + "ltBnVWZ3UMAuUvDkU6o4P": { + "title": "DRY", + "description": "DRY (Don't Repeat Yourself) is a software development principle that suggests that code should not have duplicate functionality. The idea is to keep the codebase as simple as possible by eliminating redundancy and duplication. The goal is to reduce complexity and improve maintainability by ensuring that each piece of knowledge is expressed in a single, unambiguous way within the system.\n\nThe DRY principle is closely related to the Single Responsibility Principle (SRP) and the Open-Closed Principle (OCP), which are part of the SOLID principles. The DRY principle aims to reduce the amount of duplicate code by creating abstractions that can be reused across the system.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Overview of Don't repeat yourself (DRY)", + "url": "https://en.wikipedia.org/wiki/Don%27t_repeat_yourself", + "type": "article" + }, + { + "title": "What is DRY in programming?", + "url": "https://www.youtube.com/watch?v=Rv3RIc_ziOY", + "type": "video" + } + ] + }, + "eEO-WeNIyjErBE53n8JsD": { + "title": "YAGNI", + "description": "YAGNI (You Ain't Gonna Need It) is a software development principle that suggests that developers should not add functionality to a codebase unless it is immediately necessary. The idea is to avoid creating unnecessary complexity in the codebase by only adding features that are actually needed.\n\nThe YAGNI principle is closely related to the Single Responsibility Principle (SRP) and the Open-Closed Principle (OCP), which are part of the SOLID principles. YAGNI aims to keep the codebase as simple as possible by avoiding the creation of unnecessary abstractions and functionality.\n\nLearn more from the following resources:", + "links": [ + { + "title": "YAGNI (You Aren't Gonna Need It) Principle Helps in Efficiency", + "url": "https://builtin.com/software-engineering-perspectives/yagni", + "type": "article" + }, + { + "title": "What is YAGNI coding rule, and Why it helps?", + "url": "https://www.youtube.com/watch?v=2vys1q1dKc4", + "type": "video" + } + ] + }, + "Jd79KXxZavpnp3mtE1q0n": { + "title": "Design Patterns", + "description": "Design patterns are general solutions to common problems that arise in software development. They provide a way to describe and communicate proven solutions to common design problems and they provide a common vocabulary for design. They are not specific to any particular programming language or technology, but rather describe the problem and the solution in a way that can be applied to many different contexts.\n\nThere are several different types of design patterns, including:\n\n* Creational patterns\n* Structural patterns\n* Behavioral patterns\n* Architectural patterns\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview - Software Design Pattern", + "url": "https://en.wikipedia.org/wiki/Software_design_pattern", + "type": "article" + }, + { + "title": "Explaining, imaging and simplifying design patterns", + "url": "https://refactoring.guru/design-patterns/what-is-pattern", + "type": "article" + }, + { + "title": "Explore top posts about Design Patterns", + "url": "https://app.daily.dev/tags/design-patterns?ref=roadmapsh", + "type": "article" + }, + { + "title": "What Are Design Patterns?", + "url": "https://www.youtube.com/watch?v=BWprw8UHIzA", + "type": "video" + } + ] + }, + "hlHl00ELlK9YdnzHDGnEW": { + "title": "GoF Design Patterns", + "description": "The Gang of Four (GoF) design patterns are a set of design patterns for object-oriented software development that were first described in the book \"Design Patterns: Elements of Reusable Object-Oriented Software\" by Erich Gamma, Richard Helm, Ralph Johnson, and John Vlissides (also known as the Gang of Four).\n\nThe GoF design patterns are divided into three categories: Creational, Structural and Behavioral.\n\n* Creational Patterns\n* Structural Patterns\n* Behavioral Patterns\n\nLearn more from the following links:", + "links": [ + { + "title": "Gangs of Four (GoF) Design Patterns", + "url": "https://www.digitalocean.com/community/tutorials/gangs-of-four-gof-design-patterns", + "type": "article" + }, + { + "title": "Tutorial - Builder Pattern (Gang of Four Design Patterns Series)", + "url": "https://www.youtube.com/watch?v=_sa2WlAFWQos", + "type": "video" + } + ] + }, + "6VoDGFOPHj5p_gvaZ8kTt": { + "title": "PoSA Patterns", + "description": "POSA (Pattern-Oriented Software Architecture) is a set of design patterns for developing software systems that can scale and adapt to changing requirements. These patterns were first described in the book \"Patterns of Scalable, Reliable Services\" by Kevin Hoffman.\n\nPOSA patterns are divided into four categories:\n\n* Partitioning Patterns\n* Placement Patterns\n* Routing Patterns\n* Federation Patterns\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Pattern-Oriented Software Architecture", + "url": "https://en.wikipedia.org/wiki/Pattern-Oriented_Software_Architecture", + "type": "article" + }, + { + "title": "POSA Pattern Examples", + "url": "https://www.youtube.com/watch?v=iYNa_KcWxCU", + "type": "video" + } + ] + }, + "dBq7ni-of5v1kxpdmh227": { + "title": "Architectural Principles", + "description": "", + "links": [] + }, + "8Bm0sRhUg6wZtnvtTmpgY": { + "title": "Component Principles", + "description": "Component principles in software architecture refer to guidelines for designing and implementing software components that are modular, reusable, and easy to understand, test, and maintain. Some of the key component principles in software architecture include:\n\n* High cohesion\n* Low coupling\n* Separation of concerns\n* Interface-based design\n* Reusability\n* Testability\n* Modularity\n* Interoperability\n\nBy following these component principles, software can be developed in a way that is easy to understand, maintain, and extend, and that is less prone to bugs. It also enables better code reuse, and makes it easier to test and change the code, and also enables better code reuse, as components can be reused in different contexts.\n\nLearn more from the following links:", + "links": [ + { + "title": "Component-Based Architecture", + "url": "https://www.tutorialspoint.com/software_architecture_design/component_based_architecture.htm", + "type": "article" + } + ] + }, + "b_PvjjL2ZpEKETa5_bd0v": { + "title": "Policy vs Detail", + "description": "In software architecture, the distinction between **policy** and **detail** refers to the separation of high-level decisions and low-level implementation details.\n\nPolicy refers to the high-level decisions that define the overall behavior and structure of the system. These decisions include things like the overall architecture, the system's interface, and the major components and their interactions. Policy decisions are often made by architects and designers, and they set the overall direction for the system.\n\nDetail refers to the low-level implementation details that are required to implement the policy decisions. These include things like the specific algorithms, data structures, and code that make up the system's components. Details are often implemented by developers and are responsible for the actual functioning of the system.", + "links": [] + }, + "TXus3R5vVQDBeBag6B5qs": { + "title": "Coupling and Cohesion", + "description": "Coupling and cohesion are two principles in software architecture that are used to measure the degree of interdependence between components in a system.\n\nCoupling refers to the degree to which one component depends on another component. High coupling means that a change in one component will likely affect other components, making the system more difficult to understand, test, and maintain. Low coupling, on the other hand, means that changes to one component have minimal impact on other components, making the system more modular and easier to understand, test, and maintain.\n\nCohesion, on the other hand, refers to the degree to which the responsibilities of a component are related to each other. High cohesion means that a component has a single, well-defined purpose and that all its functionality and data is related to that purpose. Low cohesion, on the other hand, means that a component has multiple, unrelated responsibilities, making it more difficult to understand, test, and maintain.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Cohesion and Coupling in Software Engineering", + "url": "https://www.youtube.com/watch?v=NweTzHYBgYU", + "type": "video" + } + ] + }, + "-Kw8hJhgQH2qInUFj2TUe": { + "title": "Boundaries", + "description": "In software architecture, boundaries refer to the interfaces or the points of separation between different components or systems. These boundaries can be physical, such as between different microservices in a distributed system, or logical, such as between different layers in an application.\n\nBoundaries are important because they define the points of interaction between different components or systems, and they dictate how those components or systems will communicate with each other. By defining clear boundaries, it makes it easier to understand, test, and maintain the system, as the interactions between components or systems are well-defined and easy to reason about.\n\nTo learn more, visit the following links:", + "links": [ + { + "title": "Boundaries in Software Architecture", + "url": "https://www.open.edu/openlearn/science-maths-technology/approaches-software-development/content-section-1.1.4", + "type": "article" + } + ] + }, + "37xWxG2D9lVuDsHUgLfzP": { + "title": "Architectural Styles", + "description": "Architectural styles in software refer to the overall design and organization of a software system, and the principles and patterns that are used to guide the design. These styles provide a general framework for the design of a system, and can be used to ensure that the system is well-structured, maintainable, and scalable.\n\nSome common architectural styles in software include:\n\n* Microservices: where the system is built as a collection of small, independent, and loosely-coupled services.\n* Event-Driven: where the system reacts to specific events that occur, rather than being continuously polled for changes.\n* Layered: where the system is divided into a set of layers, each of which has a specific responsibility and communicates with the other layers through well-defined interfaces.\n* Service-Oriented: where the system is built as a collection of services that can be accessed over a network.\n* Data-Centric: where the system is focused on the storage, retrieval and manipulation of data, rather than the processing of data.\n* Component-Based: where the system is composed of reusable and independent software components.\n* Domain-Driven: where the system is organized around the core business domain and business entities.\n\nLearn more from the following links:", + "links": [ + { + "title": "What is Software Architecture & Styles?", + "url": "https://study.com/academy/lesson/software-architecture-styles-patterns-components.html", + "type": "article" + }, + { + "title": "Types of Architectural Styles in Software Engineering", + "url": "https://www.youtube.com/watch?v=2Pp0BcXN9YY", + "type": "video" + }, + { + "title": "10 Architecture Patterns Used In Enterprise Software Development Today", + "url": "https://www.youtube.com/watch?v=brt3ao8bvqy", + "type": "video" + } + ] + }, + "j9j45Auf60kIskyEMUGE3": { + "title": "Messaging", + "description": "Messaging is a key concept in several architectural styles, including event-driven architecture (EDA), microservices, and message-driven architecture (MDA).\n\n* Event-driven architecture (EDA)\n* Microservices\n* Message-driven architecture (MDA)\n\nIn general, messaging is a powerful concept that allows for the decoupling and scalability of systems and it's used in different architectural styles to improve the flexibility and scalability of the system by allowing for loose coupling between components and making it easier to add new features or modify existing ones.\n\nLearn more from the following links:", + "links": [ + { + "title": "Architectural Styles in Software Engineering", + "url": "https://shapingsoftware.com/2009/02/09/architectural-styles/", + "type": "article" + }, + { + "title": "Architectural Messaging Patterns", + "url": "https://www.redhat.com/architect/architectural-messaging-patterns", + "type": "article" + } + ] + }, + "KtzcJBb6-EcIoXnwYvE7a": { + "title": "Event-Driven", + "description": "Event-driven architecture (EDA) is a software design pattern in which the system reacts to specific events that occur, rather than being continuously polled for changes. In EDA, events are messages that are sent asynchronously between components, and the components react to the events they are interested in.\n\nThe main advantage of using EDA is that it allows for a clear separation of concerns between the components, and it can improve the scalability and fault-tolerance of the system. Additionally, it allows for loose coupling between components, meaning that the components are not aware of each other's existence, and can be developed, deployed, and scaled independently.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Event-driven programming", + "url": "https://en.wikipedia.org/wiki/Event-driven_programming", + "type": "article" + }, + { + "title": "What is event-driven architecture?", + "url": "https://www.redhat.com/en/topics/integration/what-is-event-driven-architecture", + "type": "article" + } + ] + }, + "SX4vOVJY9slOXGwX_q1au": { + "title": "Publish-Subscribe", + "description": "The publish-subscribe pattern is a messaging pattern in which a publisher sends a message to a topic, and any number of subscribers can subscribe to that topic to receive the message. The publish-subscribe pattern is also known as the \"observer pattern\" and is a way of implementing communication between different parts of an application in a decoupled way.\n\nThe main advantage of using the publish-subscribe pattern is that it allows for a clear separation of concerns between the publisher and the subscribers, and it can improve the flexibility and scalability of the system. Additionally, it allows for loose coupling between components, meaning that the publisher and subscribers are not aware of each other's existence, and can be developed, deployed, and scaled independently.\n\nLearn more from the following links:", + "links": [ + { + "title": "Tutorial - Publish–subscribe pattern", + "url": "https://en.wikipedia.org/wiki/Publish%E2%80%93subscribe_pattern", + "type": "article" + }, + { + "title": "Publish-Subscribe Architecture (Explained by Example)", + "url": "https://www.youtube.com/watch?v=O1PgqUqZKTA", + "type": "video" + } + ] + }, + "3V74lLPlcOXFB-QRTUA5j": { + "title": "Distributed", + "description": "Distributed systems refer to the design and organization of software components that are distributed across multiple devices or locations, connected via a network, and work together to achieve a common goal. The main challenge in designing distributed systems is dealing with the inherent complexity that arises from the distribution of components and the communication between them, and it requires techniques such as load balancing, replication, and partitioning to improve scalability, fault-tolerance, and performance. Additionally, security and coordination are also important aspects of distributed systems.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Distributed Architecture", + "url": "https://www.tutorialspoint.com/software_architecture_design/distributed_architecture.htm", + "type": "article" + } + ] + }, + "ZGIMUaNfBwE5b6O1yexSz": { + "title": "Client-Server", + "description": "The client-server architecture is a common architecture pattern used in distributed systems, where a client (or multiple clients) send requests to a server, and the server responds to those requests. The client and server are separate entities that communicate over a network, such as the Internet or a local network.\n\nThe client is responsible for presenting the user interface and handling user input, while the server is responsible for processing the requests and returning the appropriate response. The server can also handle tasks such as data storage, security, and business logic.\n\nLearn more from the following links:", + "links": [ + { + "title": "Intro to Client-server Architecture", + "url": "https://cs.uwaterloo.ca/~m2nagapp/courses/CS446/1195/Arch_Design_Activity/ClientServer.pdf", + "type": "article" + } + ] + }, + "Cf9Z2wxBcbnNg_q9PA6xA": { + "title": "Peer-to-Peer", + "description": "Peer-to-peer (P2P) architecture is a distributed computing architecture in which each node (peer) in the network acts as both a client and a server. In P2P architecture, there is no central authority or server that manages the network, and each node communicates directly with other nodes to exchange information, share resources, and perform computations.\n\nThe main advantage of using P2P architecture is that it allows for a more decentralized and fault-tolerant system. As there is no central authority, there is no single point of failure, and the network can continue to function even if some nodes fail. Additionally, P2P architecture can also improve scalability as the number of nodes in the network increases.\n\nLearn more from the following links:", + "links": [ + { + "title": "Peer to Peer Architecture", + "url": "https://student.cs.uwaterloo.ca/~cs446/1171/Arch_Design_Activity/Peer2Peer.pdf", + "type": "article" + }, + { + "title": "Explore top posts about Peer-to-Peer", + "url": "https://app.daily.dev/tags/peer-to-peer?ref=roadmapsh", + "type": "article" + } + ] + }, + "86Jw9kMBD7YP5nTV5jTz-": { + "title": "Structural", + "description": "Structural architecture in software refers to the organization and design of the components of a software system, and how they interact with each other. It deals with the physical organization of the system, and the relationships between the different components.\n\nThere are several different structural architecture patterns and styles that can be used to design software systems, including:\n\n* Monolithic: where the system is built as a single, integrated, and self-contained unit.\n* Layered: where the system is divided into a set of layers, each of which has a specific responsibility and communicates with the other layers through well-defined interfaces.\n* Microservices: where the system is built as a collection of small, independent, and loosely-coupled services.\n* Event-driven: where the system reacts to specific events that occur, rather than being continuously polled for changes.\n* Client-Server: where a client sends requests to a server, and the server responds to those requests\n* Peer-to-Peer: where each node in the network acts as both a client and a server\n* Component-based: where the system is composed of reusable and independent software components\n* Domain-Driven: where the system is organized around the core business domain and business entities.", + "links": [] + }, + "a0geFJWl-vi3mYytTjYdb": { + "title": "Component-Based", + "description": "In software architecture, component-based design (CBD) is an approach to designing software systems by composing them from a set of reusable and independent software components. These components encapsulate specific functionality and can be easily integrated into different parts of the system, allowing for a more modular and flexible design.\n\nIn CBD, a software system is divided into a set of components, each of which has a well-defined interface and a specific responsibility. These components can be developed, tested, and deployed independently, making it easier to add new features, modify existing ones, and maintain the system.\n\nLearn more from the following links:", + "links": [ + { + "title": "Component Based Software architecture", + "url": "https://www.tutorialspoint.com/software_architecture_design/component_based_architecture.htm", + "type": "article" + } + ] + }, + "xYPR_X1KhBwdpqYzNJiuT": { + "title": "Monolithic", + "description": "In software architecture, monolithic architecture is a design approach in which a software system is built as a single, integrated, and self-contained unit. In a monolithic architecture, all the components of the system are tightly coupled and depend on each other. This means that changes in one part of the system may affect other parts of the system.\n\nA monolithic architecture is often used for small to medium-sized systems, where the complexity of the system is manageable and the need for scalability and flexibility is not as high. In a monolithic architecture, the entire system is typically built, deployed, and executed as a single unit, which can make it easier to understand and manage the system.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Monolithic Architecture", + "url": "https://www.atlassian.com/microservices/microservices-architecture/microservices-vs-monolith", + "type": "article" + }, + { + "title": "What is Monolithic architecture?", + "url": "https://www.techtarget.com/whatis/definition/monolithic-architecture", + "type": "article" + }, + { + "title": "What is Software Architecture? (Monolithic vs. Layered vs. Microservice)s", + "url": "https://www.youtube.com/watch?v=_07NtoK-Kns", + "type": "video" + } + ] + }, + "IELEJcKYdZ6VN-UIq-Wln": { + "title": "Layered", + "description": "In software architecture, layered architecture is a design approach in which a software system is divided into a set of layers, each of which has a specific responsibility and communicates with the other layers through well-defined interfaces. This approach allows for a more modular and flexible design, where each layer can be developed, tested, and deployed independently, making it easier to add new features, modify existing ones, and maintain the system.\n\nA layered architecture is often used for large and complex systems, where the need for scalability and flexibility is high. Each layer in a layered architecture is responsible for a specific functionality and can be thought of as a \"black box\" with a well-defined interface. The layers communicate with each other through these interfaces, allowing for a clear separation of concerns.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get started with Layered Architecture", + "url": "https://cs.uwaterloo.ca/~m2nagapp/courses/CS446/1195/Arch_Design_Activity/Layered.pdf", + "type": "article" + }, + { + "title": "Layered Architectures", + "url": "https://www.youtube.com/watch?v=0kpTKLTx8f4", + "type": "video" + } + ] + }, + "gJYff_qD6XS3dg3I-jJFK": { + "title": "Architectural Patterns", + "description": "", + "links": [] + }, + "CD20zA6k9FxUpMgHnNYRJ": { + "title": "Domain-Driven Design", + "description": "Domain-Driven Design (DDD) is an architectural pattern that is used to design software systems based on the core business domain and business entities, it's focused on creating a clear and accurate representation of the business domain within the software system, and on aligning the software system with the business goals and objectives. DDD provides several advantages over other architectural patterns, such as alignment with business goals and objectives, improved communication between domain experts and developers, a clear and expressive model of the business domain and improved scalability and maintainability. It's implemented using a set of principles and patterns such as strategic design, subdomains, bounded context, entities, value objects, aggregate, and repository.\n\nLearn more from the following links:", + "links": [ + { + "title": "Modern Software Architecture (#1): Domain Driven Design", + "url": "https://medium.com/modern-software-architecture/modern-software-architecture-1-domain-driven-design-f06fad8695f9", + "type": "article" + }, + { + "title": "The Concept of Domain-Driven Design Explained", + "url": "https://medium.com/microtica/the-concept-of-domain-driven-design-explained-3184c0fd7c3f", + "type": "article" + }, + { + "title": "Explore top posts about Domain-Driven Design", + "url": "https://app.daily.dev/tags/domain-driven-design?ref=roadmapsh", + "type": "article" + }, + { + "title": "What is DDD (Domain-Driven Design) ?", + "url": "https://www.youtube.com/watch?v=Tnecs_7OT74", + "type": "video" + }, + { + "title": "Domain-Driven Design patterns for a distributed system", + "url": "https://www.youtube.com/watch?v=i3d_jzpf0gE", + "type": "video" + } + ] + }, + "-arChRC9zG2DBmuSTHW0J": { + "title": "Model-View Controller", + "description": "Model-View-Controller (MVC) is an architectural pattern that separates the concerns of a software system into three distinct components: the model, the view, and the controller, where the model represents the data and the business logic of the system, the view represents the user interface of the system and the controller acts as an intermediary between the model and the view. The main goal of MVC is to separate the concerns of the system, making it easier to understand, maintain and evolve, it's widely used in web development.\n\nLearn more from the following links:", + "links": [ + { + "title": "MVC Framework - Introduction", + "url": "https://www.tutorialspoint.com/mvc_framework/mvc_framework_introduction.htm", + "type": "article" + }, + { + "title": "Tutorial - MVC Architectural Pattern", + "url": "https://www.youtube.com/watch?v=e9S90R-Y24Q", + "type": "video" + } + ] + }, + "eJsCCURZAURCKnOK-XeQe": { + "title": "Microservices", + "description": "Microservices is an architectural pattern that is used to design software systems as a collection of small, independent, and loosely-coupled services. Each service is responsible for a specific functionality and can be developed, deployed, and scaled independently. The main advantage of a microservices architecture is that it allows for a more flexible and scalable system, it also improves fault isolation and enables faster deployment. It's often used in combination with other architectural patterns and styles such as event-driven architecture, CQRS, and service-oriented architecture.\n\nLearn more from the following links:", + "links": [ + { + "title": "Brief of Microservices", + "url": "https://microservices.io/patterns/microservices.html", + "type": "article" + }, + { + "title": "Explore top posts about Microservices", + "url": "https://app.daily.dev/tags/microservices?ref=roadmapsh", + "type": "article" + }, + { + "title": "Tutorial - Microservices Architectural Pattern", + "url": "https://www.youtube.com/watch?v=8BPDv038oMI", + "type": "video" + }, + { + "title": "Get started with Microservices Design Patterns", + "url": "https://www.youtube.com/watch?v=xuH81XGWeGQ", + "type": "video" + } + ] + }, + "Kk7u2B67Fdg2sU8E_PGqr": { + "title": "Blackboard Pattern", + "description": "The Blackboard architectural pattern is a software design pattern that allows for the creation of a centralized repository of information that can be accessed and modified by multiple independent modules or subsystems. The blackboard serves as a communication and coordination mechanism between these modules, allowing them to share information and collaborate to achieve a common goal. This pattern is often used in artificial intelligence and decision-making systems, where multiple processes or agents need to share and reason over complex data.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Blackboard (design pattern)", + "url": "https://en.wikipedia.org/wiki/Blackboard_(design_pattern)", + "type": "article" + }, + { + "title": "Architectural Patterns: Blackboard", + "url": "http://www.openloop.com/softwareEngineering/patterns/architecturePattern/arch_Blackboard.htm", + "type": "article" + } + ] + }, + "r-Yeca-gpdFM8iq7f0lYQ": { + "title": "Microkernel", + "description": "A microkernel is an architectural pattern in operating system design that aims to minimize the amount of code running in kernel mode (i.e., privileged mode with direct access to hardware resources) and instead move as much functionality as possible into user mode. This is done by providing a small, minimalistic core kernel that only handles basic tasks such as memory management, process scheduling, and inter-process communication (IPC), and leaving all other functionality to be implemented in user-mode processes.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Microkernel Architecture", + "url": "https://www.oreilly.com/library/view/software-architecture-patterns/9781491971437/ch03.html", + "type": "article" + }, + { + "title": "Microkernel Architectural Pattern | Software Architecture", + "url": "https://www.youtube.com/watch?v=h3icQDMRLd8", + "type": "video" + } + ] + }, + "5WSvAA3h3lmelL53UJSMy": { + "title": "Serverless Architecture", + "description": "Serverless architecture is a design pattern that allows developers to build and run applications and services without having to provision and manage servers. Instead, these applications and services are executed in a fully managed environment, such as AWS Lambda, Azure Functions, or Google Cloud Functions, where the infrastructure and scaling are handled automatically by the cloud provider.\n\nThis architecture pattern mainly focuses on the business logic and event-driven execution, rather than on server management. It allows developers to write and deploy code in small, single-purpose functions that are triggered by specific events, such as changes in a database or the arrival of new data in a stream.\n\nLearn more from the following links:", + "links": [ + { + "title": "Serverless Architecture Patterns in AWS", + "url": "https://waswani.medium.com/serverless-architecture-patterns-in-aws-edeab0e46a32", + "type": "article" + }, + { + "title": "Explore top posts about Architecture", + "url": "https://app.daily.dev/tags/architecture?ref=roadmapsh", + "type": "article" + } + ] + }, + "GAs6NHBkUgxan3hyPvVs7": { + "title": "Message Queues / Streams", + "description": "Message queues and streams are architectural patterns that are used to decouple different components of a system and enable asynchronous communication between them.\n\nMessage Queues: A message queue is a software component that allows multiple systems or applications to communicate with each other by passing messages between them. Messages are stored in a queue, and each message is processed by a single consumer. This pattern is useful for systems where there is a high degree of variability in the rate of message production and consumption, and where the sender and receiver do not need to be active at the same time. Examples of message queue systems are Apache Kafka, RabbitMQ, and Amazon SQS.\n\nLearn more from the following links:", + "links": [ + { + "title": "System Design — Message Queues", + "url": "https://medium.com/must-know-computer-science/system-design-message-queues-245612428a22", + "type": "article" + }, + { + "title": "Overview of Message Queue pattern", + "url": "https://badia-kharroubi.gitbooks.io/microservices-architecture/content/patterns/communication-patterns/message-queue-pattern.html", + "type": "article" + } + ] + }, + "K8X_-bsiy7gboInPzbiEb": { + "title": "Event Sourcing", + "description": "Event sourcing is an architectural pattern that is used to build systems that need to maintain a history of all the changes that have occurred over time. This pattern stores all changes to the system's state as a sequence of events, rather than just the current state.\n\nIn Event sourcing, all changes to the state of the system are treated as events, and these events are stored in an append-only log, also known as an event store. The current state of the system can be reconstructed from the event log at any given point in time by replaying the events from the log.\n\nLearn more from the following links:", + "links": [ + { + "title": "Event Sourcing Pattern", + "url": "https://learn.microsoft.com/en-us/azure/architecture/patterns/event-sourcing", + "type": "article" + }, + { + "title": "Explore top posts about Architecture", + "url": "https://app.daily.dev/tags/architecture?ref=roadmapsh", + "type": "article" + }, + { + "title": "Event Sourcing Example & Explained", + "url": "https://www.youtube.com/watch?v=AUj4M-st3ic&list=PLThyvG1mlMzkRKJnhzvxtSAbY8oxENLUQ&ab_channel=CodeOpinion", + "type": "video" + } + ] + }, + "FysFru2FJN4d4gj11gv--": { + "title": "SOA", + "description": "SOA (Service-Oriented Architecture) is an architectural pattern that is used to design and organize software systems as a collection of services that can be accessed over a network, these services are autonomous, self-contained units of functionality that can be reused and combined to create new functionality. SOA services are designed to be loosely coupled, meaning that they do not depend on the implementation details of other services, they communicate with each other through well-defined interfaces, usually using a protocol such as HTTP or SOAP. SOA provides several advantages over other architectural patterns, such as reusability, modularity, interoperability, and scalability. It can be implemented using a variety of technologies, such as Web Services, REST, and microservices.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Service-Oriented Architecture", + "url": "https://medium.com/design-microservices-architecture-with-patterns/service-oriented-architecture-1e4716fbca17", + "type": "article" + }, + { + "title": "Explore top posts about Architecture", + "url": "https://app.daily.dev/tags/architecture?ref=roadmapsh", + "type": "article" + }, + { + "title": "Tutorial - Service-Oriented Architecture -SOA", + "url": "https://www.youtube.com/watch?v=jNiEMmoTDoE", + "type": "video" + }, + { + "title": "What is Service-Oriented Architecture", + "url": "https://www.youtube.com/watch?v=_dFJOSR-aFs", + "type": "video" + } + ] + }, + "IU86cGkLPMXUJKvTBywPu": { + "title": "CQRS", + "description": "CQRS (Command Query Responsibility Segregation) is an architectural pattern that is used to separate the responsibilities of reading and writing data in a software system. In a CQRS architecture, the system is divided into two separate parts: the command side and the query side.\n\nThe command side is responsible for processing commands and updating the system's state, while the query side is responsible for reading the current state of the system and returning the results to the client. The command and query sides can use different data models, storage mechanisms, and even different technologies.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Get Started with CQRS Pattern", + "url": "https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs", + "type": "article" + }, + { + "title": "CQRS Software Architecture Pattern: The Good, Bad, and the Ugly", + "url": "https://betterprogramming.pub/cqrs-software-architecture-pattern-the-good-the-bad-and-the-ugly-e9d6e7a34daf", + "type": "article" + } + ] + }, + "h0aeBhQRkDxNeFwDxT4Tf": { + "title": "Enterprise Patterns", + "description": "Enterprise patterns are a set of design patterns that are commonly used in the development of enterprise software applications. These patterns provide a common vocabulary and a set of best practices for solving common problems that arise in the development of large, complex software systems. Some examples of enterprise patterns include:\n\n* Domain-Driven Design (DDD)\n* Model-View-Controller (MVC)\n* Service Oriented Architecture (SOA)\n* Command and Query Responsibility Segregation (CQRS)\n* Event Sourcing\n* Microservices\n* Event-Driven Architecture (EDA)\n\nThese patterns can help to improve the maintainability and scalability of the software, by providing a clear separation of concerns and allowing for a more modular and flexible architecture.\n\nLearn more from the following links:", + "links": [ + { + "title": "Software Architecture Patterns in Enterprise Software", + "url": "https://blog.devgenius.io/10-software-architecture-patterns-in-enterprise-software-development-fabacb5ed0c8", + "type": "article" + }, + { + "title": "Explore top posts about Enterprise", + "url": "https://app.daily.dev/tags/enterprise?ref=roadmapsh", + "type": "article" + }, + { + "title": "What are Enterprise Integration Patterns?", + "url": "https://www.youtube.com/watch?v=WNm3QmJadNs", + "type": "video" + } + ] + }, + "y_Qj7KITSB8aUWHwiZ2It": { + "title": "DTOs", + "description": "The Data Transfer Object Design Pattern is one of the enterprise application architecture patterns that calls for the use of objects that aggregate and encapsulate data for transfer. A Data Transfer Object is, essentially, like a data structure. It should not contain any business logic but should contain serialization and deserialization mechanisms.\n\nLearn more from the following links:", + "links": [ + { + "title": "Data Transfer Object pattern and Mappers", + "url": "https://medium.com/@abdalrhmanalkraien/data-transfer-object-pattern-and-mapper-116508bc9df0", + "type": "article" + } + ] + }, + "tb0X1HtuiGwz7YhQ5xPsV": { + "title": "Identity Maps", + "description": "Identity Maps is a pattern used in enterprise application development to maintain a map of objects that have been loaded from the database, keyed by their unique identifier. It is used to ensure that multiple copies of the same object are not created in memory when the same data is accessed multiple times.\n\nThe identity map pattern is typically used in conjunction with an ORM (Object-Relational Mapping) tool. When an object is loaded from the database, it is first checked against the identity map to see if it has already been loaded. If it has, the existing object is returned, instead of creating a new copy.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Identity map pattern", + "url": "https://en.wikipedia.org/wiki/Identity_map_pattern", + "type": "article" + }, + { + "title": "Tutorial - Identity Map Design Pattern", + "url": "https://youtube.com/watch?v=erDxkIyNudY", + "type": "video" + } + ] + }, + "gQ7Xj8tsl6IlCcyJgSz46": { + "title": "Usecases", + "description": "Use Cases are a pattern used in enterprise application development to represent the functional requirements of a system. They describe the interactions between the system and its users, and the steps that are required to accomplish a specific goal. Use cases are a way to capture the requirements of the system in a way that is easily understood by both the development team and the stakeholders.\n\nA use case is a description of a sequence of actions that a system performs in response to a request from a user, in order to achieve a specific goal. A use case typically includes:\n\n* The actor (user) who initiates the action\n* The goal that the actor wants to achieve\n* The steps required to achieve the goal, including any alternative paths or error conditions\n* The expected outcome of the interaction\n\nUse cases are often used to drive the design and development of the system, as they provide a clear and detailed understanding of the requirements.\n\nLearn more from the following links:", + "links": [ + { + "title": "Use Case Patterns", + "url": "https://caminao.blog/how-to-implement-symbolic-representations/patterns/functional-patterns/use-case-patterns/", + "type": "article" + } + ] + }, + "8y0ot5sbplUIUyXe9gvc8": { + "title": "Repositories", + "description": "Repositories are a pattern used in enterprise application development to provide a consistent and abstracted way to access data storage. Repositories act as an abstraction layer between the application and the data storage, providing a consistent and simple API for data access and manipulation.\n\nA repository is a pattern that can be used to organize the data access code and encapsulate the logic of retrieving and storing objects. Repositories provide a way to separate the concerns of the data access from the rest of the application, allowing the application code to be written against an interface and not a specific data storage technology.\n\nLearn more from the following links:", + "links": [ + { + "title": "Introduction to Repository Design Patterns", + "url": "https://cubettech.com/resources/blog/introduction-to-repository-design-pattern/", + "type": "article" + }, + { + "title": "Tutorial - Repository Design Pattern", + "url": "https://www.youtube.com/watch?v=mb6bwnEaZ3U", + "type": "video" + } + ] + }, + "ndUTgl2YBzOdu1MQKJocu": { + "title": "Mappers", + "description": "Mappers are a pattern used in enterprise application development to provide a consistent and abstracted way to map between different data models. They act as an abstraction layer between the application and the data storage, providing a consistent and simple API for data transformation.\n\nA mapper is a component that can be used to convert data from one format or model to another. For example, a mapper can be used to convert data from a database model to a domain model, or from a domain model to a data transfer object (DTO).\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview of Data Mapper Pattern", + "url": "https://en.wikipedia.org/wiki/Data_mapper_pattern", + "type": "article" + }, + { + "title": "Tutorial - Mappers", + "url": "https://www.youtube.com/watch?v=7noMLStHcTE", + "type": "video" + } + ] + }, + "tyReIY4iO8kmyc_LPafp1": { + "title": "Transaction Script", + "description": "Transaction Script is a pattern used in enterprise application development that organizes business logic into a single procedural script. It is often used for simple CRUD (create, read, update, delete) operations, where all of the logic for a specific transaction is contained in a single script or function. This pattern is simple to implement and easy to understand, but can become unwieldy as the complexity of the application increases. Alternative patterns such as Domain-Driven Design (DDD) and the Active Record pattern may be more appropriate for more complex applications.\n\nLearn more from the following links:", + "links": [ + { + "title": "Transaction Script Pattern", + "url": "https://gunnarpeipman.com/transaction-script-pattern/", + "type": "article" + }, + { + "title": "Tutorial - Transaction Script Design Pattern", + "url": "https://www.youtube.com/watch?v=fnsU9cqcY3I", + "type": "video" + } + ] + }, + "j_SUD3SxpKYZstN9LSP82": { + "title": "Commands / Queries", + "description": "The Command and Query Responsibility Segregation (CQRS) pattern is a technique used in enterprise application development to separate the responsibilities of handling command (write) operations and query (read) operations for performing actions that change the state of the system, such as creating, updating, or deleting data. These operations are handled by Command Handlers, which are responsible for validating the data and executing the appropriate business logic.\n\nQueries are used for retrieving data from the system, such as reading data from a database or a cache. These operations are handled by Query Handlers, which are responsible for executing the appropriate query and returning the data to the caller.\n\nLearn more from the following links:", + "links": [ + { + "title": "Get Started with CQRS Pattern", + "url": "https://learn.microsoft.com/en-us/azure/architecture/patterns/cqrs", + "type": "article" + } + ] + }, + "Ks6njbfxOHiZ_TrJDnVtk": { + "title": "Value Objects", + "description": "Value Objects are a pattern used in enterprise application development to represent simple, immutable values that are used to model domain concepts. They are typically used to encapsulate data that is not an entity, but is important to the domain.\n\nA Value Object is defined by its value rather than its identity, meaning that two Value Objects with the same value are considered to be equal, regardless of their identity.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview - Implement Value Objects", + "url": "https://learn.microsoft.com/en-us/dotnet/architecture/microservices/microservice-ddd-cqrs-patterns/implement-value-objects", + "type": "article" + }, + { + "title": "Intro to Value object", + "url": "https://en.wikipedia.org/wiki/Value_object", + "type": "article" + } + ] + }, + "NpSfbzYtGebmfrifkKsUf": { + "title": "Domain Models", + "description": "Domain Models are a pattern used in enterprise application development to represent the business concepts and rules of a specific domain. They are typically used to model the problem domain, or the area of expertise of a specific business.\n\nA Domain Model is a collection of objects that represent the real-world concepts and entities of the domain. These objects are typically modeled as classes or types, and they encapsulate the data and behavior that is specific to the domain. They are responsible for representing the state and behavior of the business concepts they model, and for enforcing the rules and constraints of the domain.\n\nLearn more from the following links:", + "links": [ + { + "title": "Overview - Domain Models", + "url": "https://sparxsystems.com/enterprise_architect_user_guide/14.0/model_domains/specialized_models.html", + "type": "article" + }, + { + "title": "Tutorial - Domain Model Pattern", + "url": "https://www.youtube.com/watch?v=75EGANiqADw", + "type": "video" + } + ] + }, + "VnW_7dl5G0IFL9W3YF_W3": { + "title": "Entities", + "description": "Entities are a pattern used in enterprise application development to represent the business concepts that have a unique identity and a lifetime. They are typically used to model real-world objects or concepts that have a distinct identity and a lifecycle, such as a customer, an order, or an account.\n\nAn Entity is defined by its identity, meaning that two entities with the same identity are considered to be the same, regardless of their state. Entities usually have a unique identifier, such as a primary key, that is used to identify them. They also have an associated set of properties or attributes that describe their state.", + "links": [] + }, + "SYYulHfDceIyDkDT5fcqj": { + "title": "ORMs", + "description": "ORM stands for Object-Relational Mapping, it is a technique used in enterprise application development to map between the object-oriented programming model and the relational database model. It allows developers to work with objects in their code, while the ORM tool takes care of translating those objects into the appropriate database operations.\n\nORMs are designed to abstract away the complexity of working with a relational database and allow developers to interact with the database using a higher-level, object-oriented API. They provide a set of libraries and tools that map the objects in the code to the tables and rows in the database, and vice versa. This allows developers to work with the data using a familiar object-oriented paradigm, rather than having to write complex SQL queries.\n\nLearn more from the following links:", + "links": [ + { + "title": "Why do you need an ORM?", + "url": "https://enterprisecraftsmanship.com/posts/do-you-need-an-orm/", + "type": "article" + }, + { + "title": "Explore top posts about Backend Development", + "url": "https://app.daily.dev/tags/backend?ref=roadmapsh", + "type": "article" + } + ] + } +} \ No newline at end of file