diff --git a/public/roadmap-content/android.json b/public/roadmap-content/android.json index 249fdf040..c0a98e3c6 100644 --- a/public/roadmap-content/android.json +++ b/public/roadmap-content/android.json @@ -1,21 +1,37 @@ { "Suws-7f_6Z1ChpfcnxX2M": { "title": "Pick a Language", - "description": "When developing for Android, one crucial step is picking a programming language to use. There are multiple languages you can choose from, but the three most popular ones are Java, Kotlin, and C++. Java is the original language used for Android development and is widely used, making it a good choice for beginners due to the wealth of resources and developer communities. Kotlin is a newer option that is fully supported by Google and Android Studio, and addressing many of the drawbacks of Java which makes it a popular choice for many developers. Lastly, C++ can be used in Android development through the Android Native Development Kit (NDK), though it comes with more complexities and is usually not recommended for beginners. Your selection might depend on your existing familiarity with these languages, the complexity and specific requirements of your project, and the resources or libraries you wish to use.", - "links": [] + "description": "When developing for Android, one crucial step is picking a programming language to use. There are multiple languages you can choose from, but the three most popular ones are Java, Kotlin, and C++.\n\nJava is the original language used for Android development and is widely used, making it a good choice for beginners due to the wealth of resources and developer communities. Kotlin is a newer option that is fully supported by Google and Android Studio, and addressing many of the drawbacks of Java which makes it a popular choice for many developers.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Pick a Language", + "url": "https://developer.android.com/studio/write/java8-support", + "type": "article" + }, + { + "title": "Kotlin vs Java", + "url": "https://developer.android.com/kotlin", + "type": "article" + } + ] }, "qIzUv8-GgQnkqChEdgD50": { "title": "Kotlin", - "description": "`Kotlin` is a cross-platform, statically typed general-purpose programming language with type inference. Developed by JetBrains, the makers of the world’s leading IDEs, Kotlin has a syntax, which is more expressive and concise. This allows for more readable and maintainable code. It is fully interoperable with Java and comes with no limitations. It can be used almost everywhere Java is used today, for server-side development, Android apps, and much more. Kotlin introduces several improvements for programmers over Java, which makes it a preferred choice for many developers. With more concise code base and modern programming concept support - it's certainly a future of Android app development.\n\nUse following resources to learn more:", + "description": "`Kotlin` is a cross-platform, statically typed general-purpose programming language with type inference. Developed by JetBrains, the makers of the world’s leading IDEs, Kotlin has a syntax, which is more expressive and concise. This allows for more readable and maintainable code. It is fully interoperable with Java and comes with no limitations. It can be used almost everywhere Java is used today, for server-side development, Android apps, and much more. Kotlin introduces several improvements for programmers over Java, which makes it a preferred choice for many developers. With more concise code base and modern programming concept support - it's certainly a future of Android app development.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Learn Kotlin - w3schools", - "url": "https://www.w3schools.com/kotlin/", + "title": "Kotlin", + "url": "https://kotlinlang.org/", + "type": "article" + }, + { + "title": "Kotlin Documentation", + "url": "https://kotlinlang.org/docs/home.html", "type": "article" }, { - "title": "Explore top posts about Kotlin", - "url": "https://app.daily.dev/tags/kotlin?ref=roadmapsh", + "title": "Learn Kotlin - w3schools", + "url": "https://www.w3schools.com/kotlin/", "type": "article" }, { @@ -27,38 +43,119 @@ }, "RBABbkzD_uNFwEO-hssZO": { "title": "Java", - "description": "Java is a popular programming language used for Android development due to its robustness and ease of use. Its object-oriented structure allows developers to create modular programs and reusable code. The language was built with the philosophy of \"write once, run anywhere\" (WORA), meaning compiled Java code can run on all platforms without the need for recompilation. Android’s API and core libraries are primarily written in Java, therefore understanding Java is fundamental in creating diverse and powerful Android apps. Java is a statically-typed language, which can be beneficial for detecting errors at compile-time rather than at runtime. Oracle, who owns Java, provides comprehensive documentation and support for the language.", - "links": [] + "description": "Java is a popular programming language used for Android development due to its robustness and ease of use. Its object-oriented structure allows developers to create modular programs and reusable code. The language was built with the philosophy of \"write once, run anywhere\" (WORA), meaning compiled Java code can run on all platforms without the need for recompilation. Android’s API and core libraries are primarily written in Java, therefore understanding Java is fundamental in creating diverse and powerful Android apps.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Java Roadmap", + "url": "https://roadmap.sh/java", + "type": "article" + }, + { + "title": "Java", + "url": "https://www.oracle.com/java/technologies/javase-jdk11-downloads.html", + "type": "article" + }, + { + "title": "Java Documentation", + "url": "https://docs.oracle.com/en/java/javase/11/docs/api/", + "type": "article" + } + ] }, "HlUUGj3dOZ68t4gIjerXh": { "title": "The Fundamentals", - "description": "\"The Fundamentals\" of Android primarily concentrate on 5 components; Activities, Services, Broadcast Receivers, Content Providers, and Intents. **Activities** are essentially what you see on your screen; each screen in an app is a separate activity. **Services** run in the background to perform long-running operations or to perform work for remote processes. They do not provide a user interface. **Broadcast Receivers** respond to broadcast messages from other applications or from the system itself. These messages are often in the form of Intents. **Content Providers** manage a shared set of app data that other apps can query or modify, through a structured interface. Finally, **Intents** are messaging objects which facilitate the communication between the aforementioned components. Understanding these five core concepts is key to mastering Android fundamentals.", - "links": [] + "description": "\"The Fundamentals\" of Android primarily concentrate on 5 components; Activities, Services, Broadcast Receivers, Content Providers, and Intents. **Activities** are essentially what you see on your screen; each screen in an app is a separate activity. **Services** run in the background to perform long-running operations or to perform work for remote processes. They do not provide a user interface. **Broadcast Receivers** respond to broadcast messages from other applications or from the system itself. These messages are often in the form of Intents. **Content Providers** manage a shared set of app data that other apps can query or modify, through a structured interface. Finally, **Intents** are messaging objects which facilitate the communication between the aforementioned components. Understanding these five core concepts is key to mastering Android fundamentals.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "The Fundamentals", + "url": "https://developer.android.com/guide/components/fundamentals", + "type": "article" + } + ] }, "ZRGsokU313Ky-anWbWK6q": { "title": "Development IDE", - "description": "\"Development IDE\" refers to Development Integrated Development Environment that is vital for Android App development. For Android, the primary IDE is **Android Studio**. This official IDE from Google includes everything you need to build an Android app, such as a code editor, code analysis tools, emulators for all of Android's supported OS versions and hardware configurations, and more. Other popular IDEs include **Eclipse** (with an Android Developer Tools plugin), **NetBeans**, and **IntelliJ IDEA**. Each of these IDEs tends to have its own set of specialized features, but all are designed to provide the tools and services needed for Android development. The choice of IDE often depends on the specific needs and preferences of the developer or development team.", - "links": [] + "description": "Development IDE refers to Development Integrated Development Environment that is vital for Android App development. For Android, the primary IDE is **Android Studio**. This official IDE from Google includes everything you need to build an Android app, such as a code editor, code analysis tools, emulators for all of Android's supported OS versions and hardware configurations, and more. Other popular IDEs include **Eclipse** (with an Android Developer Tools plugin), **NetBeans**, and **IntelliJ IDEA**. Each of these IDEs tends to have its own set of specialized features, but all are designed to provide the tools and services needed for Android development. The choice of IDE often depends on the specific needs and preferences of the developer or development team.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android Studio", + "url": "https://developer.android.com/studio", + "type": "article" + }, + { + "title": "Android Studio Documentation", + "url": "https://developer.android.com/studio/intro", + "type": "article" + }, + { + "title": "Android Studio Plugins", + "url": "https://developer.android.com/studio/intro/studio-plugins", + "type": "article" + } + ] }, "jl1FsQ5-WGKeFyaILNt_p": { "title": "Basics of Kotlin", - "description": "Kotlin is a statically-typed programming language that runs on the Java Virtual Machine (JVM) and can be used to develop all types of Android apps. It is Google's preferred language for Android app development. Kotlin's syntax is more concise than Java, which means less code to write and read, and fewer opportunities for errors. It provides several high-level features like lambdas, coroutines and higher order functions that help making the code more clean and understandable. Key basics of Kotlin include control flow statements (if, when, for, while), variables (mutable and non-mutable), null safety, classes and objects, inheritance, interfaces, and exception handling. While learning Kotlin, experience with Java will certainly be helpful, but it's not a prerequisite.", - "links": [] + "description": "Kotlin is a concise, multi-platform, and fun language developed by JetBrains. Learn how to use Kotlin for Android, server-side, and cross-platform development, and explore its features, news, and community. Kotlin is a statically-typed programming language that runs on the Java Virtual Machine (JVM) and can be used to develop all types of Android apps. It is Google's preferred language for Android app development.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Kotlin", + "url": "https://kotlinlang.org/", + "type": "article" + }, + { + "title": "Kotlin Docs", + "url": "https://kotlinlang.org/docs/getting-started.html", + "type": "article" + }, + { + "title": "Kotlin Tutorial for Beginners", + "url": "https://www.w3schools.com/kotlin/index.php", + "type": "article" + } + ] }, "j69erqfosSZMDlmKcnnn0": { "title": "Basics of OOP", - "description": "In Android development, understanding the `Basics of Object-Oriented Programming (OOP)` is crucial. OOP is a programming paradigm that uses \"Objects\" - entities that contain both data and functions that manipulate the data. Key concepts include `Classes`, which are blueprints from which objects are created; `Objects`, instances of a class; `Inheritance`, where one class acquires properties from another; `Polymorphism`, the ability of an object to take many forms; `Abstraction`, showing only necessary details and hiding implementation from the user; and `Encapsulation`, the concept of wrapping data and the methods that work on data within one unit. By understanding these fundamentals, you can create more efficient and effective Android apps.", - "links": [] + "description": "Understanding the `Basics of Object-Oriented Programming (OOP)` is crucial. OOP is a programming paradigm that uses \"Objects\" - entities that contain both data and functions that manipulate the data.\n\nKey concepts include `Classes`, which are blueprints from which objects are created; `Objects`, instances of a class; `Inheritance`, where one class acquires properties from another; `Polymorphism`, the ability of an object to take many forms; `Abstraction`, showing only necessary details and hiding implementation from the user; and `Encapsulation`, the concept of wrapping data and the methods that work on data within one unit.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Object-Oriented Programming - Wikipedia", + "url": "https://en.wikipedia.org/wiki/Object-oriented_programming", + "type": "article" + }, + { + "title": "OOP in Kotlin", + "url": "https://developer.android.com/codelabs/basic-android-kotlin-compose-classes-and-objects", + "type": "article" + } + ] }, "cNeT1dJDfgn0ndPzSxhSL": { "title": "Data Structures and Algorithms", - "description": "In Android, **data structures** are primarily used to collect, organize and perform operations on the stored data more effectively. They are essential for designing advanced-level Android applications. Examples include Array, Linked List, Stack, Queue, Hash Map, and Tree.\n\nMeanwhile, **algorithms** are a sequence of instructions or rules for performing a particular task. In Android, algorithms can be used for data searching, sorting, or performing complex business logic. Some commonly used algorithms are Binary Search, Bubble Sort, Selection Sort, etc. A deep understanding of data structures and algorithms is crucial in optimizing the performance and the memory consumption of the Android applications.", - "links": [] + "description": "**Data Structures** are primarily used to collect, organize and perform operations on the stored data more effectively. They are essential for designing advanced-level Android applications. Examples include Array, Linked List, Stack, Queue, Hash Map, and Tree.\n\n**Algorithms** are a sequence of instructions or rules for performing a particular task. In Android, algorithms can be used for data searching, sorting, or performing complex business logic. Some commonly used algorithms are Binary Search, Bubble Sort, Selection Sort, etc. A deep understanding of data structures and algorithms is crucial in optimizing the performance and the memory consumption of the Android applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Data Structures and Algorithms in Android", + "url": "https://medium.com/@pranamsharma.1997/importance-of-data-structure-and-algorithms-in-android-app-development-75eed9f73909", + "type": "article" + } + ] }, "FVxNjbDBxgf6vkZWw1Awt": { "title": "What is and how to use Gradle?", - "description": "**Using Gradle**: Gradle is a powerful build system used in Android development that allows you to define your project and dependencies, and distinguish between different build types and flavors. Gradle uses a domain-specific language (DSL) which gives developers almost complete control over the build process. When you trigger a build in Android Studio, Gradle is the tool working behind the scenes to compile and package your app. It looks at the dependencies you declared in your build.gradle files and create a build script accordingly. Using Gradle in Android development requires continuous editing of the build.gradle files to manage app dependencies, build variants, signing configurations, and other essential aspects related to building your app.\n\nVisit the following resources to learn more:", + "description": "Gradle is a powerful build system used in Android development that allows you to define your project and dependencies, and distinguish between different build types and flavors. Gradle uses a domain-specific language (DSL) which gives developers almost complete control over the build process. When you trigger a build in Android Studio, Gradle is the tool working behind the scenes to compile and package your app. It looks at the dependencies you declared in your build.gradle files and create a build script accordingly. Using Gradle in Android development requires continuous editing of the build.gradle files to manage app dependencies, build variants, signing configurations, and other essential aspects related to building your app.\n\nVisit the following resources to learn more:", "links": [ + { + "title": "Gradle Build Tool", + "url": "https://gradle.org/", + "type": "article" + }, + { + "title": "Gradle Documentation", + "url": "https://docs.gradle.org/current/userguide/getting_started_eng.html", + "type": "article" + }, { "title": "Get going with Gradle - PDF", "url": "https://assets.gradlehero.com/get-going-with-gradle/get-going-with-gradle-book.pdf", @@ -70,23 +167,23 @@ "type": "article" }, { - "title": "Introduction to Gradle for Complete Beginners - 25minutes", - "url": "https://youtu.be/-dtcEMLNmn0?si=NuIP-3wNpUrxfTxA", + "title": "Gradle Course for Beginners - 55minutes", + "url": "https://www.youtube.com/watch?v=R6Z-Sxb837I", "type": "video" }, { - "title": "Gradle Course for Beginners - 55minutes", - "url": "https://www.youtube.com/watch?v=R6Z-Sxb837I", + "title": "Introduction to Gradle for Complete Beginners - 25minutes", + "url": "https://youtu.be/-dtcEMLNmn0?si=NuIP-3wNpUrxfTxA", "type": "video" } ] }, "5m_7DvInF8C_4Ml1xVI6L": { "title": "Create a Basic Hello World App", - "description": "The \"Hello World\" app is a simple project that you can build when you're getting started with Android development. It's often the first program that beginners learn to build in a new system. It's usually considered the simplest form of program that displays a message to the user - \"Hello, World!\" In Android, this involves creating a new project from the Android Studio and setting up the main activity. The main activity file is primarily written in Java or Kotlin where you can code for the display message, while the layout design view can be created in the XML file.\n\nResources:", + "description": "The \"Hello World\" app is a simple project that you can build when you're getting started with Android development. It's often the first program that beginners learn to build in a new system. It's usually considered the simplest form of program that displays a message to the user - \"Hello, World!\" In Android, this involves creating a new project from the Android Studio and setting up the main activity. The main activity file is primarily written in Java or Kotlin where you can code for the display message, while the layout design view can be created in the XML file.\n\nVisit the follow resources to learn more:", "links": [ { - "title": "Create your first android app", + "title": "Create Your First Android Application", "url": "https://developer.android.com/codelabs/basic-android-kotlin-compose-first-app", "type": "article" } @@ -94,93 +191,261 @@ }, "5s1CqsYCOXjNroDHaGKGa": { "title": "Version Control", - "description": "_Version Control_ is a system that records changes to a file or set of files over time so that you can recall specific versions later. An essential tool for software development, it helps to track changes, enhance collaboration, and manage different versions of a project. Two common types of version control systems are Centralized Version Control System (CVCS) and Distributed Version Control System (DVCS). CVCS uses a central server to store all versions of a project, with users getting snapshots from that server. Examples include SVN and Perforce. On the other hand, DVCS allows multiple developers to work on a single project simultaneously. Each user has a complete backup of all versions of the work. Examples include Git and Mercurial.", - "links": [] + "description": "_Version Control_ is a system that records changes to a file or set of files over time so that you can recall specific versions later. An essential tool for software development, it helps to track changes, enhance collaboration, and manage different versions of a project. Two common types of version control systems are Centralized Version Control System (CVCS) and Distributed Version Control System (DVCS). CVCS uses a central server to store all versions of a project, with users getting snapshots from that server. Examples include SVN and Perforce. On the other hand, DVCS allows multiple developers to work on a single project simultaneously. Each user has a complete backup of all versions of the work. Examples include Git and Mercurial.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Version Control Systems", + "url": "https://en.wikipedia.org/wiki/Version_control", + "type": "article" + } + ] }, "rqSZ2ATeHbOdIQE9Jlb0B": { "title": "Git", - "description": "`Git` is a highly efficient and flexible distributed version control system that was created by Linus Torvalds, the creator of Linux. It allows multiple developers to work on a project concurrently, providing tools for non-linear development and tracking changes in any set of files. Git has a local repository with a complete history and version-tracking capabilities, allowing offline operations, unlike SVN. It ensures data integrity and provides strong support for non-linear development with features such as branching and merging. Yet, Git has a high learning curve and can be complex for beginners to understand the command line interface. Furthermore, Git also allows you to create `tags` to reference certain points in your history for milestone or version releases.", - "links": [] + "description": "`Git` is a highly efficient and flexible distributed version control system that was created by **Linus Torvalds**, the creator of Linux. It allows multiple developers to work on a project concurrently, providing tools for non-linear development and tracking changes in any set of files. Git has a local repository with a complete history and version-tracking capabilities, allowing offline operations, unlike SVN. It ensures data integrity and provides strong support for non-linear development with features such as branching and merging.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Git and Github Roadmap", + "url": "https://roadmap.sh/git-github", + "type": "article" + }, + { + "title": "Git", + "url": "https://git-scm.com/", + "type": "article" + }, + { + "title": "Git Documentation", + "url": "https://git-scm.com/docs", + "type": "article" + } + ] }, "H-2eb8fLwz8IKYXbeSVKK": { "title": "GitHub", - "description": "**GitHub** is a cloud-based hosting service for managing software version control using Git. It provides a platform for enabling multiple developers to work together on the same project at the same time. With GitHub, codes can be stored publicly, allowing for collaboration with other developers or privately for individual projects. Key features of GitHub include code sharing, task management, and version control, among others. GitHub also offers functionalities such as bug tracking, feature requests, and task management for the project. For Android development, it supports Gradle-based android projects, plugins for Android Studio and JetBrains IntelliJ IDEA, making version control operations more user-friendly.", - "links": [] + "description": "**GitHub** is a cloud-based hosting service for managing software version control using Git. It provides a platform for enabling multiple developers to work together on the same project at the same time. With GitHub, codes can be stored publicly, allowing for collaboration with other developers or privately for individual projects. Key features of GitHub include code sharing, task management, and version control, among others. GitHub also offers functionalities such as bug tracking, feature requests, and task management for the project.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Git and Github Roadmap", + "url": "https://roadmap.sh/git-github", + "type": "article" + }, + { + "title": "GitHub", + "url": "https://github.com/", + "type": "article" + }, + { + "title": "Github Documentation", + "url": "https://docs.github.com/", + "type": "article" + } + ] }, "5LFZdUiFYYU_1sYsouyan": { "title": "Bitbucket", - "description": "Bitbucket is a web-based hosting service that is owned by Atlassian. Bitbucket uses either Mercurial or Git revision control systems, allowing users to manage and maintain their code. This platform is mainly used for code and code review. Bitbucket provides both commercial plans and free accounts. It offers free accounts with an unlimited number of private repositories (which can have up to five users in the case of free accounts) as of September 2010. It originally offered only Mercurial support. Bitbucket integrates with other Atlassian software like JIRA, HipChat, Confluence and Bamboo.", - "links": [] + "description": "Bitbucket is a web-based hosting service that is owned by Atlassian. Bitbucket uses either Mercurial or Git revision control systems, allowing users to manage and maintain their code. This platform is mainly used for code and code review. Bitbucket provides both commercial plans and free accounts. It offers free accounts with an unlimited number of private repositories (which can have up to five users in the case of free accounts) as of September 2010. It originally offered only Mercurial support. Bitbucket integrates with other Atlassian software like JIRA, HipChat, Confluence and Bamboo.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Bitbucket", + "url": "https://bitbucket.org/", + "type": "article" + }, + { + "title": "Bitbucket for Developers", + "url": "https://www.atlassian.com/software/bitbucket", + "type": "article" + } + ] }, "Q47BtQphp59NkkZoeNXmP": { "title": "GitLab", - "description": "`Gitlab` is a web-based DevOps lifecycle tool which provides a Git-repository manager, along with continuous integration and deployment pipeline features, using an open-source license, developed by GitLab Inc. Users can manage and create their software projects and repositories, and collaborate on these projects with other members. `Gitlab` also allows users to view analytics and open issues of their project. It stands next to other version control tools like `GitHub` and `Bitbucket`, but comes with its own set of additional features and nuances. For Android development, `Gitlab` can be particularly useful owing to its continuous integration and deployment system which can automate large parts of the app testing and deployment.", - "links": [] + "description": "`Gitlab` is a web-based DevOps lifecycle tool which provides a Git-repository manager, along with continuous integration and deployment pipeline features, using an open-source license, developed by GitLab Inc. Users can manage and create their software projects and repositories, and collaborate on these projects with other members. `Gitlab` also allows users to view analytics and open issues of their project. It stands next to other version control tools like `GitHub` and `Bitbucket`, but comes with its own set of additional features and nuances. For Android development, `Gitlab` can be particularly useful owing to its continuous integration and deployment system which can automate large parts of the app testing and deployment.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Gitlab", + "url": "https://about.gitlab.com/", + "type": "article" + }, + { + "title": "Gitlab Documentation", + "url": "https://docs.gitlab.com/", + "type": "article" + } + ] }, "5Li8J5iR_ZuyIlxX0LYei": { "title": "App Components", - "description": "Android apps are primarily made up of five different types of components:\n\n1. **Activities**: These are individual screens that a user can interact with. Any UI action like touching a button or swiping a screen will usually take place within an activity.\n \n2. **Services**: Unlike activities, services run in the background and don't have a user interface. They’re used for repetitive or long running operations, like playing music or pulling in a feed of data from a server.\n \n3. **Broadcast Receivers**: These are event listeners. The Android operating system uses them to respond to system-wide events.\n \n4. **Content Providers**: They manage and share app data with other apps installed on the device. For security, data is not generally shared across apps.\n \n5. **Intents**: These serve as messages or commands to the Android system. They're used to signal to the Android system that certain events have occurred.\n \n\nEach app component is designed to serve different purposes and to have a well-defined lifecycle which defines how the component is created and destroyed.", - "links": [] + "description": "Android apps are primarily made up of five different types of components:\n\n1. **Activities**: These are individual screens that a user can interact with. Any UI action like touching a button or swiping a screen will usually take place within an activity.\n \n2. **Services**: Unlike activities, services run in the background and don't have a user interface. They’re used for repetitive or long running operations, like playing music or pulling in a feed of data from a server.\n \n3. **Broadcast Receivers**: These are event listeners. The Android operating system uses them to respond to system-wide events.\n \n4. **Content Providers**: They manage and share app data with other apps installed on the device. For security, data is not generally shared across apps.\n \n5. **Intents**: These serve as messages or commands to the Android system. They're used to signal to the Android system that certain events have occurred.\n \n\nVisit the following resources to learn more:", + "links": [ + { + "title": "App Fundamentals", + "url": "https://developer.android.com/guide/components/fundamentals", + "type": "article" + }, + { + "title": "Android App Components", + "url": "https://medium.com/android-hunger/android-app-components-activities-fragments-and-intents-ed7373455555", + "type": "article" + } + ] }, "nwuVlPmzwJ17mtVQ8Hi9w": { "title": "Activity", - "description": "`Activity` in Android is a crucial component that represents a single screen with a user interface. It is just like a window in a desktop application. Android apps are typically made up of one or more activities, each having its interface which allows user interaction. When an app is launched, an instance of `Activity` is created, starting the lifecycle of that app. Every activity has its own lifecycle (create, start, resume, pause, stop, destroy) that keeps the state of a user's progress, and Android manages these states automatically. Activities can also have `Intent`, which allows them to interact with other components, such as starting another activity or getting a result from that activity.", - "links": [] + "description": "`Activity` in Android is a crucial component that represents a single screen with a user interface. It is just like a window in a desktop application. Android apps are typically made up of one or more activities, each having its interface which allows user interaction. When an app is launched, an instance of `Activity` is created, starting the lifecycle of that app. Every activity has its own lifecycle (create, start, resume, pause, stop, destroy) that keeps the state of a user's progress, and Android manages these states automatically. Activities can also have `Intent`, which allows them to interact with other components, such as starting another activity or getting a result from that activity.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android Activity", + "url": "https://developer.android.com/reference/android/app/Activity", + "type": "article" + }, + { + "title": "Mastering Android Activities", + "url": "https://medium.com/deuk/mastering-the-android-activity-lifecycle-best-practices-1d10f15d060a", + "type": "article" + } + ] }, "PcHmU1c9hqKyzSjwlRPHk": { "title": "Services", - "description": "**Services**: A service in Android is an app component that performs operations in the background without a user interface. It can be started by an application component, like an activity, and it will continue to run in the background even if the user switches to another application. There are two types of services in Android, namely, `Started Service` and `Bound Service`. A `Started Service` is used to perform a single operation, such as downloading a large file. On the other hand, a `Bound Service` offers a client-server interface that allows components to interact with the service, send requests, receive results, and even perform interprocess communication (IPC).", - "links": [] + "description": "**Services**: A service in Android is an app component that performs operations in the background without a user interface. It can be started by an application component, like an activity, and it will continue to run in the background even if the user switches to another application. There are two types of services in Android, namely, `Started Service` and `Bound Service`. A `Started Service` is used to perform a single operation, such as downloading a large file. On the other hand, a `Bound Service` offers a client-server interface that allows components to interact with the service, send requests, receive results, and even perform interprocess communication (IPC).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Services", + "url": "https://developer.android.com/guide/components/services", + "type": "article" + } + ] }, "nkcdjrswv0WCzUs48BAt9": { "title": "Content Provider", - "description": "A **Content Provider** in Android is a key component that allows applications to securely share data with other applications. They act as a layer between databases and applications to enhance data security. Content providers manage access to a structured set of data by handling data transactions, implementing data security, and maintaining isolation between applications. They provide an abstracted interface which is used to access data, while the underlying storage method (Like SQLite database, web, or any other method) remains hidden. This mechanism aids in retrieving data from a non-relational source in a structured way. They're used primarily when data needs to be shared between multiple applications, not just within a single application.", - "links": [] + "description": "A **Content Provider** in Android is a key component that allows applications to securely share data with other applications. They act as a layer between databases and applications to enhance data security. Content providers manage access to a structured set of data by handling data transactions, implementing data security, and maintaining isolation between applications. They provide an abstracted interface which is used to access data, while the underlying storage method (Like SQLite database, web, or any other method) remains hidden. This mechanism aids in retrieving data from a non-relational source in a structured way. They're used primarily when data needs to be shared between multiple applications, not just within a single application.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Content Provider", + "url": "https://developer.android.com/guide/topics/providers/content-providers", + "type": "article" + } + ] }, "tFuAToid1Fkmu96BDtW7K": { "title": "Broadcast Receiver", - "description": "**Broadcast Receivers** in Android are components that respond to system-wide broadcast announcements. They can be registered to respond to a specific type of broadcasts or implement a user-defined broadcast. While you can initiate a broadcast from your app, they are generally used for receiving system notifications or communicating with other applications. However, keep in mind that they cannot display a user interface, but they can start activities if necessary, which do have a user interface. A `BroadcastReceiver` class must override the `onReceive()` method where each message is received as an `Intent` object parameter.", - "links": [] + "description": "**Broadcast Receivers** in Android are components that respond to system-wide broadcast announcements. They can be registered to respond to a specific type of broadcasts or implement a user-defined broadcast. While you can initiate a broadcast from your app, they are generally used for receiving system notifications or communicating with other applications. However, keep in mind that they cannot display a user interface, but they can start activities if necessary, which do have a user interface. A `BroadcastReceiver` class must override the `onReceive()` method where each message is received as an `Intent` object parameter.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Broadcast Receiver", + "url": "https://developer.android.com/reference/android/content/BroadcastReceiver", + "type": "article" + } + ] }, "hv_9imIQpthxEaMLXEUHI": { "title": "Intent", - "description": "\"Intent\" in Android is a software mechanism used for late runtime binding between components, such as activities, content providers, and services. It is essentially a passive data structure holding an abstract description of an operation that the Android system is requested to perform. The Intent can be explicit, in which you specify the component to start or implicit, where you declare a general action to perform, allowing a component from another app to handle it. Implicit intents are often used to request another app's functionality, such as showing a user a location on a map or taking a photo. \"Intent Filters\" are then used by the components to advertise their capabilities to handle different types of intents.", - "links": [] + "description": "Intent in Android is a software mechanism used for late runtime binding between components, such as activities, content providers, and services. It is essentially a passive data structure holding an abstract description of an operation that the Android system is requested to perform.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Intent", + "url": "https://developer.android.com/reference/android/content/Intent", + "type": "article" + } + ] }, "FVg438cVBBzqJFkGWVbQM": { "title": "Activity LifeCycle", - "description": "The **Activity Lifecycle** in Android represents a series of states or events that an activity can go through from its creation to its destruction. The primary states or events are `onCreate()`, `onStart()`, `onResume()`, `onPause()`, `onStop()`, `onDestroy()`, and `onRestart()`. The method `onCreate()` is called when the activity is first created, followed by `onStart()` when the activity becomes visible to the user. The `onResume()` method executes when the user starts interacting with the application. `onPause()` and `onStop()` methods are invoked when the application is no longer in the foreground or visible to the user. The `onDestroy()` method is used when the activity is being completely removed from the memory. The `onRestart()` method is called after the system stops the activity and is about to start it again. The proper handling of these states ensures the efficient use of resources and a smooth user experience.", - "links": [] + "description": "The **Activity Lifecycle** in Android represents a series of states or events that an activity can go through from its creation to its destruction. The primary states or events are `onCreate()`, `onStart()`, `onResume()`, `onPause()`, `onStop()`, `onDestroy()`, and `onRestart()`. The method `onCreate()` is called when the activity is first created, followed by `onStart()` when the activity becomes visible to the user. The `onResume()` method executes when the user starts interacting with the application. `onPause()` and `onStop()` methods are invoked when the application is no longer in the foreground or visible to the user. The `onDestroy()` method is used when the activity is being completely removed from the memory. The `onRestart()` method is called after the system stops the activity and is about to start it again. The proper handling of these states ensures the efficient use of resources and a smooth user experience.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Activity Lifecycle", + "url": "https://developer.android.com/guide/components/activities/activity-lifecycle", + "type": "article" + } + ] }, "oUjetA2eduvQIeLcQlLcu": { "title": "State Changes", - "description": "In Android, an \"Activity\" is a crucial component that represents a single screen with a user interface. One or more active activities make up an Application. These activities can go through different states in their lifecycle, often due to user interaction or system interruption. The primary states of an Activity include `Created`, `Started`, `Resumed`, `Paused`, `Stopped`, `Restarted`, and `Destroyed`. The \"Created\" state occurs when an activity instance is being created. The \"Started\" state is when the activity is visible to the user, while \"Resumed\" is when the activity is interacting with the user. An activity is \"Paused\" when it loses focus but is partly visible, \"Stopped\" when it's not visible, \"Restarted\" when the activity is about to be started, and \"Destroyed\" when the activity is finished or the system is temporarily destroying it.", - "links": [] + "description": "\"Activity\" is a crucial component that represents a single screen with a user interface. One or more active activities make up an Application. These activities can go through different states in their lifecycle, often due to user interaction or system interruption. The primary states of an Activity include `Created`, `Started`, `Resumed`, `Paused`, `Stopped`, `Restarted`, and `Destroyed`. The \"Created\" state occurs when an activity instance is being created. The \"Started\" state is when the activity is visible to the user, while \"Resumed\" is when the activity is interacting with the user. An activity is \"Paused\" when it loses focus but is partly visible, \"Stopped\" when it's not visible, \"Restarted\" when the activity is about to be started, and \"Destroyed\" when the activity is finished or the system is temporarily destroying it.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Activity Lifecycle", + "url": "https://developer.android.com/guide/components/activities/activity-lifecycle", + "type": "article" + } + ] }, "-O-G9bg36ut8NnZcdOaop": { "title": "Tasks & Backstack", - "description": "The **tasks backstack** in Android refers to the way Android manages and arranges tasks in a stack-like structure. Every task has a stack of activities, which is referred to as the task's back stack. The activities are placed in the order they are opened. When a new activity is started, it is placed at the top of the stack and becomes the running activity, while the previous activity is paused and put into the back stack. When you press the back button, the current activity is destroyed and the activity at the top of the back stack becomes active again. Android defines how to navigate between tasks and activities using this back stack concept.", - "links": [] + "description": "The **tasks backstack** in Android refers to the way Android manages and arranges tasks in a stack-like structure. Every task has a stack of activities, which is referred to as the task's back stack. The activities are placed in the order they are opened. When a new activity is started, it is placed at the top of the stack and becomes the running activity, while the previous activity is paused and put into the back stack. When you press the back button, the current activity is destroyed and the activity at the top of the back stack becomes active again. Android defines how to navigate between tasks and activities using this back stack concept.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Tasks and Backstack", + "url": "https://developer.android.com/guide/components/activities/tasks-and-back-stack", + "type": "article" + } + ] }, "gGdz3j33x0gfrFDp_rw8Z": { "title": "Implicit Intents", - "description": "In Android development, **Implicit Intents** do not specify the target component explicitly like Explicit Intents. Instead, they allow the system to find a suitable component matching the Intent description to handle the request. The system will find an activity that can handle this intent by comparing the `` section in the `AndroidManifest.xml` of all apps installed on the device against the Implicit Intent. An ideal example of an implicit intent is opening a URL. You do not need to know the specific activity that can handle this request, you just declare an intent to view a web page and Android system will select the suitable app that can open the URL.", - "links": [] + "description": "**Implicit Intents** do not specify the target component explicitly like Explicit Intents. Instead, they allow the system to find a suitable component matching the Intent description to handle the request. The system will find an activity that can handle this intent by comparing the `` section in the `AndroidManifest.xml` of all apps installed on the device against the Implicit Intent.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Implicit Intents", + "url": "https://developer.android.com/guide/components/intents-filters#implicit", + "type": "article" + } + ] }, "TmIeCF3xVCe5Sy3ITmM31": { "title": "Explicit Intents", - "description": "**Explicit Intents** are primarily used within an application's own boundaries. In explicit intents you specify the component that needs to be responded to the intent. Therefore, the target component must be specified by calling methods such as `setComponent(ComponentName)`, `setClass(Context, Class)`, or `setClassName(String, String)`. This means that explicit intents are typically used for launching activities, broadcasting messages, starting services within the app. Explicit intents are not resolved by the system but are passed to the component identified in the intent.", - "links": [] + "description": "**Explicit Intents** are primarily used within an application's own boundaries. In explicit intents you specify the component that needs to be responded to the intent. Therefore, the target component must be specified by calling methods such as `setComponent(ComponentName)`, `setClass(Context, Class)`, or `setClassName(String, String)`. This means that explicit intents are typically used for launching activities, broadcasting messages, starting services within the app. Explicit intents are not resolved by the system but are passed to the component identified in the intent.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Explicit Intents", + "url": "https://developer.android.com/guide/components/intents-filters#explicit", + "type": "article" + } + ] }, "b-sfh6NoS-APqaNKm5L5S": { "title": "Intent Filters", - "description": "`Intent Filters` in Android are essential components of the Android system where you can declare the capabilities of your activities, services, and broadcast receivers. An intent filter is an expression found in your app's manifest file, defined in the XML element. Android uses these filters to determine the appropriate components for incoming intents, which can be either explicit or implicit. Your app's ability to respond to intents depends on the filters you define. The filters are set of conditions comprised of `action`, `category`, and `data` which your activity or service is able to perform. If the incoming `Intent` matches with defined `Intent Filters`, Android system will permit that `Intent` to your Component (Activity, Service, or Broadcast Receiver).", - "links": [] + "description": "`Intent Filters` in Android are essential components of the Android system where you can declare the capabilities of your activities, services, and broadcast receivers. An intent filter is an expression found in your app's manifest file, defined in the `` XML element. Android uses these filters to determine the appropriate components for incoming intents, which can be either explicit or implicit. Your app's ability to respond to intents depends on the filters you define. The filters are set of conditions comprised of `action`, `category`, and `data` which your activity or service is able to perform. If the incoming `Intent` matches with defined `Intent Filters`, Android system will permit that `Intent` to your Component (Activity, Service, or Broadcast Receiver).\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Intent Filters", + "url": "https://developer.android.com/guide/components/intents-filters", + "type": "article" + } + ] }, "jePGzTejFe4ryA5qFFmjl": { "title": "Design & Architecture", - "description": "In Android, **Design Architecture** refers to structuring the code in a way that increases its readability, maintainability, and testability. There are several ways to design architecture like [Model-View-Controller (MVC)](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), [Model-View-Presenter (MVP)](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter), [Model-View-ViewModel (MVVM)](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel), and [Model-View-Intent (MVI)](https://www.raywenderlich.com/817602-mvi-architecture-for-android-tutorial-getting-started). Each of these define the interaction between the data, the logic, and the UI layers. Google’s recommended architectural pattern is [Android Architecture Components](https://developer.android.com/topic/libraries/architecture) which follow the principles of the MVVM pattern. Bear in mind that an architecture is not a rigid structure that fits all solutions. Rather, it serves as a guideline and can be tweaked as necessary.", - "links": [] + "description": "**Design Architecture** refers to structuring the code in a way that increases its readability, maintainability, and testability. There are several ways to design architecture like Model-View-Controller (MVC), Model-View-Intent (MVI). Each of these define the interaction between the data, the logic, and the UI layers. Google’s recommended architectural pattern is Android Architecture Components which follow the principles of the MVVM pattern. Bear in mind that an architecture is not a rigid structure that fits all solutions. Rather, it serves as a guideline and can be tweaked as necessary.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android Architecture Components", + "url": "https://developer.android.com/topic/libraries/architecture", + "type": "article" + }, + { + "title": "Model-View-Controller (MVC)", + "url": "https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller", + "type": "article" + }, + { + "title": "Model-View-Presenter (MVP)", + "url": "https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter", + "type": "article" + }, + { + "title": "Model-View-ViewModel (MVVM)", + "url": "https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93viewmodel", + "type": "article" + }, + { + "title": "Model-View-Intent (MVI)", + "url": "https://www.raywenderlich.com/817602-mvi-architecture-for-android-tutorial-getting-started", + "type": "article" + } + ] }, "Dp2DOX10u2xJUjB8Okhzh": { "title": "Frame", @@ -198,7 +463,7 @@ "description": "**LinearLayout** is a view group that aligns all children in a single directioni, vertically or horizontally. You can specify the layout direction with the `android:orientation` attribute.\n\n**LinearLayout** was commonly used in earlier Android development, but with the introduction of ConstraintLayout, it’s less frequently used in modern apps.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: Linear Layout", + "title": "Linear Layout", "url": "https://developer.android.com/develop/ui/views/layout/linear", "type": "article" } @@ -209,7 +474,7 @@ "description": "A **RelativeLayout** in Android is a type of ViewGroup that allows you to position child views relative to each other or relative to the parent layout. It's a flexible layout where you can arrange the child views in relation to one another based on certain rules, making it suitable for creating complex UI designs.\n\n**RelativeLayout** was commonly used in earlier Android development, but with the introduction of `ConstraintLayout`, it's less frequently used in modern apps.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: Relative Layout", + "title": "Relative Layout", "url": "https://developer.android.com/develop/ui/views/layout/relative", "type": "article" } @@ -220,12 +485,12 @@ "description": "Lets you create large, complex layouts with a flat view hierarchy—no nested view groups. It's similar to `RelativeLayout` in that all views are laid out according to relationships between sibling views and the parent layout, but it's more flexible than RelativeLayout and easier to use. Its available on xml and jetpack compose.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: ConstraintLayout in xml", + "title": "Android: ConstraintLayout in XML", "url": "https://developer.android.com/develop/ui/views/layout/constraint-layout", "type": "article" }, { - "title": "Android developers: ContraintLayout in compose", + "title": "Android: ConstraintLayout in Compose", "url": "https://developer.android.com/develop/ui/compose/layouts/constraintlayout", "type": "article" } @@ -236,7 +501,7 @@ "description": "RecyclerView is the most commonly used and powerful list management tool in Android development. Witch makes it easy to efficiently display large sets of data. You supply the data and define how each item looks, and the RecyclerView library dynamically creates the elements when they're needed.\n\nAs the name implies, RecyclerView recycles those individual elements. When an item scrolls off the screen, RecyclerView doesn't destroy its view. Instead, RecyclerView reuses the view for new items that have scrolled onscreen. RecyclerView improves performance and your app's responsiveness, and it reduces power consumption.\n\nLearn more from the following resources:", "links": [ { - "title": "Android Developers: Create dynamic lists with RecyclerView", + "title": "Create Dynamic Lists with RecyclerView", "url": "https://developer.android.com/develop/ui/views/layout/recyclerview", "type": "article" } @@ -247,7 +512,7 @@ "description": "TextView is a widget that is seen in every android application. This widget is used to display simple text within the android application.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: TextView", + "title": "TextView", "url": "https://developer.android.com/reference/android/widget/TextView", "type": "article" } @@ -288,12 +553,17 @@ }, "WhfzFOUpm0DFEj7Oeq21R": { "title": "Buttons", - "description": "A `button` consists of text or an icon, or both, that communicates what action occurs when the user taps it.\n\nLearn more from the following resources:", + "description": "A `button` consists of text or an icon, or both, that communicates what action occurs when the user taps it.\n\nButtons are UI widgets that allow users to interact with an application by tapping on them. A button typically consists of text, an icon, or a combination of both, and communicates what action will occur when the user taps it.\n\nLearn more from the following resources:", "links": [ { "title": "Android Developers: Button", "url": "https://developer.android.com/develop/ui/views/components/button", "type": "article" + }, + { + "title": "Create a Button - Android", + "url": "https://developer.android.com/quick-guides/content/create-button", + "type": "article" } ] }, @@ -302,7 +572,7 @@ "description": "A `toast` provides simple feedback about an operation in a small popup. It only fills the amount of space required for the message and the current activity remains visible and interactive. Toasts automatically disappear after a timeout.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: Toast", + "title": "Toast", "url": "https://developer.android.com/guide/topics/ui/notifiers/toasts", "type": "article" } @@ -313,7 +583,7 @@ "description": "Displays image resources, for example Bitmap or Drawable resources. ImageView is also commonly used to apply tints to an image and handle image scaling.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: ImageView", + "title": "Android Developers: ImageView", "url": "https://developer.android.com/reference/android/widget/ImageView", "type": "article" } @@ -321,10 +591,10 @@ }, "Z4Tbd5ClnqCXGPGG09F-G": { "title": "Bottom Sheet", - "description": "`Bottom sheets` are surfaces containing supplementary content that are anchored to the bottom of the screen.\n\nThere are several attributes that can be used to adjust the behavior of both standard and modal bottom sheets. Behavior attributes can be applied to standard bottom sheets in xml by setting them on a child View set to `app:layout_behavior` or programmatically.\n\nVisit the following resources to learn more:", + "description": "`Bottom sheets` are surfaces containing supplementary content that are anchored to the bottom of the screen.\n\nThere are several attributes that can be used to adjust the behavior of both standard and modal bottom sheets.\n\nBehavior attributes can be applied to standard bottom sheets in xml by setting them on a child View set to `app:layout_behavior` or programmatically.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: Bottom sheets", + "title": "Android developers: Bottom Sheets", "url": "https://developer.android.com/reference/com/google/android/material/bottomsheet/BottomSheetDialog", "type": "article" } @@ -332,10 +602,10 @@ }, "EzLjX4iRT7AxkAOsJYnSU": { "title": "ListView", - "description": "Displays a vertically-scrollable collection of views, where each view is positioned immediatelybelow the previous view in the list.\n\nFor a more modern, flexible, and performant approach to displaying lists, use `RecyclerView`.\n\nVisit the following resources to learn more:", + "description": "Displays a vertically-scrollable collection of views, where each view is positioned immediately below the previous view in the list.\n\nFor a more modern, flexible, and performant approach to displaying lists, use `RecyclerView`.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: ListView", + "title": "ListView", "url": "https://developer.android.com/reference/android/widget/ListView", "type": "article" } @@ -362,7 +632,7 @@ "description": "Tabs in Android Studio are a UI component used to organize content into multiple sections, allowing users to navigate between them by selecting the corresponding tab. This component is commonly used when there is a need to present different types of content in a single screen, like different categories, settings, or pages within an app.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Android developers: Material Tabs", + "title": "Material Tabs", "url": "https://developer.android.com/reference/com/google/android/material/tabs/package-summary", "type": "article" } @@ -386,11 +656,11 @@ }, "60Vm-77rseUqpMiFvp-dA": { "title": "Jetpack Compose", - "description": "`Jetpack Compose` is a modern toolkit for building native Android UI. It simplifies and accelerates UI development on Android with less code, powerful tools, and intuitive Kotlin APIs. `Jetpack Compose` offers a declarative approach to designing UI, where you can simply describe what your UI should look like at any given point of your app’s state, and `Compose` takes care of updating the view hierarchy, making UI development more efficient. It also integrates well with existing Android apps, letting you adopt its benefits at your own pace.", + "description": "`Jetpack Compose` is a modern toolkit for building native Android UI. It simplifies and accelerates UI development on Android with less code, powerful tools, and intuitive Kotlin APIs. `Jetpack Compose` offers a declarative approach to designing UI, where you can simply describe what your UI should look like at any given point of your app’s state, and `Compose` takes care of updating the view hierarchy, making UI development more efficient. It also integrates well with existing Android apps, letting you adopt its benefits at your own pace.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Explore top posts about Jetpack Compose", - "url": "https://app.daily.dev/tags/jetpack-compose?ref=roadmapsh", + "title": "Jetpack Compose", + "url": "https://developer.android.com/jetpack/compose", "type": "article" }, { @@ -402,13 +672,25 @@ }, "xV475jHTlLuHtpHZeXb7P": { "title": "App Shortcuts", - "description": "App shortcuts in Android are designed to provide quick and convenient routes to specific actions or functions within your app from the device home screen. To use them, long-press an app's icon and a pop-up menu will appear with the available shortcuts. Depending on the app, you might be able to send a message, make a booking, navigate home, or perform some other specific task without having to first open the app and navigate to the desired function. These shortcuts can also be moved and placed individually on the home screen for even faster access.", - "links": [] + "description": "App shortcuts in Android are designed to provide quick and convenient routes to specific actions or functions within your app from the device home screen. To use them, long-press an app's icon and a pop-up menu will appear with the available shortcuts. Depending on the app, you might be able to send a message, make a booking, navigate home, or perform some other specific task without having to first open the app and navigate to the desired function. These shortcuts can also be moved and placed individually on the home screen for even faster access.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "App Shortcuts", + "url": "https://developer.android.com/guide/topics/ui/shortcuts", + "type": "article" + } + ] }, "o5rzmnaQeiSh9ocvfJPpK": { "title": "Navigation Components", - "description": "The **Navigation Components** are part of Android Jetpack and are designed to simplify the implementation of navigation in your Android app. These components help you follow best practices, handle deep linking, and provide a consistent user experience across deep and conditional navigation. They also automate many common tasks, such as handling Up and Back actions correctly across many different types of devices. The Navigation component consists of three key parts which are Navigation graph, NavHost, and NavController.", - "links": [] + "description": "The **Navigation Components** are part of Android Jetpack and are designed to simplify the implementation of navigation in your Android app. These components help you follow best practices, handle deep linking, and provide a consistent user experience across deep and conditional navigation. They also automate many common tasks, such as handling Up and Back actions correctly across many different types of devices. The Navigation component consists of three key parts which are Navigation graph, NavHost, and NavController.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Navigation Components", + "url": "https://developer.android.com/guide/navigation", + "type": "article" + } + ] }, "Bz-BkfzsDHAbAw3HD7WCd": { "title": "MVI", @@ -439,12 +721,18 @@ }, "aF_xFIqTjQbENtC7pkXvJ": { "title": "MVP", - "description": "The MVP `Model View Presenter` pattern is a derivative of the well-known MVC `Model View Controller` pattern and is one of the most popular patterns for organizing the presentation layer in Android applications.\n\nMVP is divided into three components:\n\n* `Model`: Responsible for managing the data input to the app. This can often be an Interactor or UseCase, handling the business logic and data operations.\n* `View`: Takes care of updating the graphical part of the application. It acts as a passive view, only receiving data and requesting actions to be performed.\n* `Presenter`: Handles all the logic related to the graphical interface that the View requests. It provides the View with the data it needs to display on the screen.\n\nThis structure helps to create a clear separation of concerns, making your codebase more modular and easier to maintain.", - "links": [] + "description": "The MVP `Model View Presenter` pattern is a derivative of the well-known MVC `Model View Controller` pattern and is one of the most popular patterns for organizing the presentation layer in Android applications.\n\nMVP is divided into three components:\n\n* `Model`: Responsible for managing the data input to the app. This can often be an Interactor or UseCase, handling the business logic and data operations.\n* `View`: Takes care of updating the graphical part of the application. It acts as a passive view, only receiving data and requesting actions to be performed.\n* `Presenter`: Handles all the logic related to the graphical interface that the View requests. It provides the View with the data it needs to display on the screen.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Model View Presenter", + "url": "https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter", + "type": "article" + } + ] }, "w1A6wPKSd3Yh2luuHV-aE": { "title": "MVC", - "description": "MVC or `Model View Controller` is a software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected components.\n\nComponents:\n\n* `Model`: The internal representations of information. This can often be an Interactor or UseCase\n* `View`: The interface that presents information to and accepts it from the user\n* `Controller`: The controller contains logic that updates the model and/or view in response to input from the users of the app.\n\nVisit the following resources to learn more:", + "description": "MVC or `Model View Controller` is a software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected components.\n\nComponents:\n-----------\n\n* `Model`: The internal representations of information. This can often be an Interactor or UseCase\n* `View`: The interface that presents information to and accepts it from the user\n* `Controller`: The controller contains logic that updates the model and/or view in response to input from the users of the app.\n\nVisit the following resources to learn more:", "links": [ { "title": "MVC", @@ -452,7 +740,7 @@ "type": "article" }, { - "title": "Model–view–controller", + "title": "Model View Controller", "url": "https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller", "type": "article" } @@ -460,80 +748,184 @@ }, "ZF5XgO7I_J9928bD3CVXo": { "title": "Repository Pattern", - "description": "In Android design architecture, the `Repository Pattern` separates the data sources from the rest of the application. It acts as a mediator between different data sources, such as persistent models, web services, or caches. Instead of having the network and database calls spread out throughout your ViewModel, they are encapsulated within a Repository class. This separation will make the code clean, easy to read and testable. It provides a simple API for data access, the rest of the app doesn't need to know where the data is coming from it just asks the repository.", - "links": [] + "description": "The `Repository Pattern` separates the data sources from the rest of the application. It acts as a mediator between different data sources, such as persistent models, web services, or caches. Instead of having the network and database calls spread out throughout your ViewModel, they are encapsulated within a Repository class. This separation will make the code clean, easy to read and testable. It provides a simple API for data access, the rest of the app doesn't need to know where the data is coming from it just asks the repository.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Repository Pattern", + "url": "https://en.wikipedia.org/wiki/Repository_pattern", + "type": "article" + } + ] }, "784fiIdKrQDlIm3VIiJQN": { "title": "Builder Pattern", - "description": "The **Builder Pattern** in Android is used to construct complex objects step by step. It separates the construction of an object from its representation. The pattern involves a `Builder` class which is used to construct the `Product` class. The Builder class typically has a method for each part that may be used to construct a Product. It also has a method for returning the final product. The Builder pattern is useful in situations where you might have multiple ways to create an object or when an object requires a large number of parameters for its constructor.", - "links": [] + "description": "The **Builder Pattern** in Android is used to construct complex objects step by step. It separates the construction of an object from its representation. The pattern involves a `Builder` class which is used to construct the `Product` class. The Builder class typically has a method for each part that may be used to construct a Product. It also has a method for returning the final product. The Builder pattern is useful in situations where you might have multiple ways to create an object or when an object requires a large number of parameters for its constructor.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Builder Pattern", + "url": "https://developer.android.com/kotlin/style-guide#builder-pattern", + "type": "article" + }, + { + "title": "Android Builder Pattern", + "url": "https://medium.com/kayvan-kaseb/builder-design-pattern-in-android-a38dccb75485", + "type": "article" + } + ] }, "DeOxj6RzQBYfEWV-M1Ybm": { "title": "Factory Pattern", - "description": "The **Factory Pattern** is part of the Creational Design Patterns. This pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. It introduces an abstraction layer between the client code and the concrete objects. Normally, this is achieved by using a factory method to create objects instead of using constructors. The instance of the class is usually created by a method, referred to as a `factory method`, which is either specified in an interface and implemented in implementing classes or implemented in a base class which may be optionally overridden by derived classes. The Factory Method is used when we want to provide users with a way to create an instance of a class from one of several possible classes that share a common super class.\n\nHere is a basic example of the Factory Pattern:\n\n public abstract class Animal {\n public abstract String makeSound();\n }\n \n public class Dog extends Animal {\n @override\n public String makeSound() {\n return \"Woof\";\n }\n }\n \n public class Cat extends Animal {\n @override\n public String makeSound() {\n return \"Meow\";\n }\n }\n \n public class AnimalFactory {\n public Animal createAnimal(String type) {\n if (\"Dog\".equals(type)) {\n return new Dog();\n } else if (\"Cat\".equals(type)) {\n return new Cat();\n }\n return null;\n }\n }\n \n\nIn the code above, `AnimalFactory` is the factory class responsible to create and return instances of `Dog` and `Cat` classes.", - "links": [] + "description": "The **Factory Pattern** is part of the Creational Design Patterns. This pattern provides an interface for creating objects in a superclass, but allows subclasses to alter the type of objects that will be created. It introduces an abstraction layer between the client code and the concrete objects. Normally, this is achieved by using a factory method to create objects instead of using constructors. The instance of the class is usually created by a method, referred to as a `factory method`, which is either specified in an interface and implemented in implementing classes or implemented in a base class which may be optionally overridden by derived classes. The Factory Method is used when we want to provide users with a way to create an instance of a class from one of several possible classes that share a common super class.\n\nHere is a basic example of the Factory Pattern:\n\n public abstract class Animal {\n public abstract String makeSound();\n }\n \n public class Dog extends Animal {\n @override\n public String makeSound() {\n return \"Woof\";\n }\n }\n \n public class Cat extends Animal {\n @override\n public String makeSound() {\n return \"Meow\";\n }\n }\n \n public class AnimalFactory {\n public Animal createAnimal(String type) {\n if (\"Dog\".equals(type)) {\n return new Dog();\n } else if (\"Cat\".equals(type)) {\n return new Cat();\n }\n return null;\n }\n }\n \n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android: Factory Pattern", + "url": "https://developer.android.com/guide/components/intents-filters#factory", + "type": "article" + } + ] }, "N_auRfGKkeIIc-qiHLkR_": { "title": "Observer Pattern", - "description": "The **Observer Pattern** is a software design pattern in which an object, known as the subject, maintains a list of its dependants, called observers, and notifies them automatically of any state changes. This is usually done by calling one of their methods. It's mainly used for implementing distributed event handling systems and is viewed as a good practice to follow, making your design more robust, flexible, and scalable. The subject to be observed triggers events and observers react to the change or the event that they are listening to. In Android, observable libraries like `LiveData`, `RxJava`, `Flow`, and other reactive streams allow the implementation of observer pattern.", - "links": [] + "description": "The **Observer Pattern** is a software design pattern in which an object, known as the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes. This is usually done by calling one of their methods. It's mainly used for implementing distributed event handling systems and is viewed as a good practice to follow, making your design more robust, flexible, and scalable. The subject to be observed triggers events and observers react to the change or the event that they are listening to. In Android, observable libraries like `LiveData`, `RxJava`, `Flow`, and other reactive streams allow the implementation of observer pattern.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Observer Pattern", + "url": "https://en.wikipedia.org/wiki/Observer_pattern", + "type": "article" + } + ] }, "W-WTIiQml8dLK6i_V69JK": { "title": "Flow", - "description": "`Flow` in Android development is part of the Kotlin Coroutines library. It is a type that can emit multiple values sequentially, making it perfect for working with any data streams or any streams of events that aren't instantaneous. Like Observables, `Flow` is also based on the observer pattern, meaning it can emit values and these emissions can be observed and reacted to. However, `Flow` comes with built-in backpressure handling and the ability to transform, filter, or combine these flows in a sequence. Along with Coroutines, `Flow` encourages a more predictable and simplified concurrency design without callback hell problem.", - "links": [] + "description": "`Flow` in Android development is part of the Kotlin Coroutines library. It is a type that can emit multiple values sequentially, making it perfect for working with any data streams or any streams of events that aren't instantaneous. Like Observables, `Flow` is also based on the observer pattern, meaning it can emit values and these emissions can be observed and reacted to. However, `Flow` comes with built-in back pressure handling and the ability to transform, filter, or combine these flows in a sequence. Along with Coroutines, `Flow` encourages a more predictable and simplified concurrency design without callback hell problem.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Flow", + "url": "https://kotlinlang.org/docs/flow.html", + "type": "article" + }, + { + "title": "Flow: Coroutines", + "url": "https://kotlinlang.org/docs/flow-coroutines.html", + "type": "article" + } + ] }, "xk0vnWr7uESdzYRxwFjoK": { "title": "RxJava", - "description": "RxJava, standing for Reactive Extensions for the JVM, is a library in the Java and Android ecosystem that allows developers to write asynchronous, event-based programs. It is developed according to reactive programming principles and it supports multi-threading operations. One can create data streams from just about anything - variables, data structures, inputs, etc. and these streams could be used with functional programming methods to process the data.\n\nIn Android, RxJava is often used in combination with Retrofit, to handle API calls or with Room, to handle tasks involving the database. This library provides a set of operators such as `map()`, `filter()`, `concat()`, `merge()`, `flatmap()` etc. to handle tasks such as chain asynchronous operations, perform computations, or transform data.\n\nThere are three important entities in RxJava - 'Observable', 'Observer' and 'Subscription'. 'Observable' is a data stream that does some work, 'Observer' watches the 'Observable' and does something when the 'Observable’ changes, and 'Subscription' is what ties an 'Observer' to an 'Observable' - linking their lifecycles and allowing 'Observer’s to unsubscribe (to stop receiving updates) when they’re destroyed. In other words, 'Subscription' is what allows you to manage memory and prevent crashes due to leaks.", - "links": [] + "description": "RxJava, standing for Reactive Extensions for the JVM, is a library in the Java and Android ecosystem that allows developers to write asynchronous, event-based programs. It is developed according to reactive programming principles and it supports multi-threading operations. One can create data streams from just about anything - variables, data structures, inputs, etc. and these streams could be used with functional programming methods to process the data.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "RxJava on GitHub", + "url": "https://github.com/ReactiveX/RxJava", + "type": "opensource" + } + ] }, "7rbsp1o5bzIJP11BRIoeG": { "title": "RxKotlin", - "description": "`RxKotlin` is a lightweight library that adds convenient extension functions to `RxJava`. It allows developers to use RxJava with Kotlin in a more idiomatic way, thus making code more readable and understandable. While `RxJava` is a Java-based implementation of Reactive Extensions, `RxKotlin` is essentially a wrapper that includes extension functions and other constructs to take full advantage of Kotlin's features, such as its syntactic simplicity and ease of use.", - "links": [] + "description": "`RxKotlin` is a lightweight library that adds convenient extension functions to `RxJava`. It allows developers to use RxJava with Kotlin in a more idiomatic way, thus making code more readable and understandable. While `RxJava` is a Java-based implementation of Reactive Extensions, `RxKotlin` is essentially a wrapper that includes extension functions and other constructs to take full advantage of Kotlin's features, such as its syntactic simplicity and ease of use.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "RxKotlin", + "url": "https://github.com/ReactiveX/RxKotlin", + "type": "opensource" + } + ] }, "TiokceMGU9caqiR0lbFYL": { "title": "LiveData", - "description": "`LiveData` is a data holder class that can be observed within a given lifecycle. This means that an `Observer` can be added in a pair with a `LifecycleOwner`, and this observer will be notified about modifications of the `LiveData` object only if the associated `LifecycleOwner` is in active state. `LiveData` respects the lifecycle state of app components, such as activities, fragments, or services, and it only updates app-component observers that are in an active lifecycle state. Furthermore, `LiveData` automatically removes the observers when their associated `LifecycleOwner` moves to the `Destroyed` state. This combination of `LiveData` and `LifecycleOwner` helps you to manage appropriate and efficient updates because `LiveData` takes into consideration the lifecycle state of your app components.", - "links": [] + "description": "`LiveData` is a data holder class that can be observed within a given lifecycle. This means that an `Observer` can be added in a pair with a `LifecycleOwner`, and this observer will be notified about modifications of the `LiveData` object only if the associated `LifecycleOwner` is in active state. `LiveData` respects the lifecycle state of app components, such as activities, fragments, or services, and it only updates app-component observers that are in an active lifecycle state. Furthermore, `LiveData` automatically removes the observers when their associated `LifecycleOwner` moves to the `Destroyed` state. This combination of `LiveData` and `LifecycleOwner` helps you to manage appropriate and efficient updates because `LiveData` takes into consideration the lifecycle state of your app components.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "LiveData", + "url": "https://developer.android.com/topic/libraries/architecture/livedata", + "type": "article" + } + ] }, "qtXM9K7wyjOFuEMlZrB3C": { "title": "Dependency Injection", - "description": "`Dependency Injection` is a technique where an object does not need to create its own dependencies; instead, dependencies are provided (or injected) at runtime. This technique is highly beneficial in Android Development. It helps in creating loosely coupled and easily testable code. For example, the `Retrofit` instance that your application requires to make network calls can be created somewhere else and can be injected whenever required using libraries like `Dagger`, `Koin` or `Hilt`. The `ViewModel` instances can also be injected rather than being created in the required classes directly. Through dependency injection, plugins ensure the code becomes easier to change, understand, and maintain, hence, improving the quality of the code.", - "links": [] + "description": "`Dependency Injection` is a technique where an object does not need to create its own dependencies; instead, dependencies are provided (or injected) at runtime. This technique is highly beneficial in Android Development. It helps in creating loosely coupled and easily testable code. For example, the `Retrofit` instance that your application requires to make network calls can be created somewhere else and can be injected whenever required using libraries like `Dagger`, `Koin` or `Hilt`. The `ViewModel` instances can also be injected rather than being created in the required classes directly. Through dependency injection, plugins ensure the code becomes easier to change, understand, and maintain, hence, improving the quality of the code.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Dependency Injection", + "url": "https://developer.android.com/training/dependency-injection", + "type": "article" + } + ] }, "CK7Ce632fdTgxeFsRUVvd": { "title": "Dagger", - "description": "[Dagger](https://dagger.dev/) is a fully static, compile-time dependency injection framework for both Java and Android. It is an adaptation of an earlier version created by Square that's focused on simplicity and speed. Dagger's primary focus is on compile-time analysis of dependencies, code simplicity, and clarity. It uses annotations to define dependencies, thus aiding in easy readability and understanding of the code. Dagger also eliminates the use of reflection to inject dependencies, thus boosting performance. It offers custom scopes to control the lifespan of instances and ensures that dependencies are Singleton across the entire lifespan of certain scopes.", - "links": [] + "description": "Dagger is a fully static, compile-time dependency injection framework for both Java and Android. It is an adaptation of an earlier version created by Square that's focused on simplicity and speed. Dagger's primary focus is on compile-time analysis of dependencies, code simplicity, and clarity. It uses annotations to define dependencies, thus aiding in easy readability and understanding of the code. Dagger also eliminates the use of reflection to inject dependencies, thus boosting performance. It offers custom scopes to control the lifespan of instances and ensures that dependencies are Singleton across the entire lifespan of certain scopes.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Dagger", + "url": "https://dagger.dev/", + "type": "article" + } + ] }, "UMqZ-jmXKDXKuu8bzqDH_": { "title": "Koin", - "description": "[Koin](https://insert-koin.io) is a lightweight dependency injection framework developed specifically for Kotlin developers. It uses functional resolution only - no proxy, no code generation, no reflection, and offers simplicity by leveraging Kotlin's language features. While Koin is not related to the Android platform, it provides specific extensions enabling an efficient integration into your Android applications, including [Android Architecture Components](https://developer.android.com/topic/libraries/architecture/index.html) and [Kotlin Coroutines](https://kotlinlang.org/docs/reference/coroutines-overview.html), amongst others.", - "links": [] + "description": "Koin is a lightweight dependency injection framework developed specifically for Kotlin developers. It uses functional resolution only - no proxy, no code generation, no reflection, and offers simplicity by leveraging Kotlin's language features. While Koin is not related to the Android platform, it provides specific extensions enabling an efficient integration into your Android applications, including Android Architecture Components and Kotlin Coroutines amongst others.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Koin", + "url": "https://insert-koin.io", + "type": "article" + }, + { + "title": "Android Architecture Components", + "url": "https://developer.android.com/topic/libraries/architecture/index.html", + "type": "article" + }, + { + "title": "@officialKotlin Coroutines", + "url": "https://kotlinlang.org/docs/reference/coroutines-overview.html", + "type": "article" + } + ] }, "ooo_k2k_vUBR_jQ7Ke6Et": { "title": "Hilt", - "description": "Hilt is a dependency injection library for Android that reduces the boilerplate code that you would normally need to write when setting up manual dependency injection in your project. It is based on the Dagger library, but it simplifies the implementation process and streamlines the use of Dagger in Android apps. To set it up, you must annotate your Android classes and Hilt will automatically generate and provide the necessary dependencies for you. Moreover, Hilt provides predefined set of components tied to the Android lifecycle which helps to handle scoped instances.", - "links": [] + "description": "Hilt is a dependency injection library for Android that reduces the boilerplate code that you would normally need to write when setting up manual dependency injection in your project. It is based on the Dagger library, but it simplifies the implementation process and streamlines the use of Dagger in Android apps. To set it up, you must annotate your Android classes and Hilt will automatically generate and provide the necessary dependencies for you.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Hilt", + "url": "https://developer.android.com/training/dependency-injection/hilt-android", + "type": "article" + } + ] }, "dc7k50PjCYZcElHhCk66p": { "title": "Kodein", - "description": "`Kodein` is one of the recommended dependency injection frameworks suitable for Android development. This open-source Kotlin library simplifies the DI process by allowing developers to bind various types of dependencies, such as singleton, factory, or provider bindings into containers or `Kodein` modules. It promotes dependency declaration where used, instead of prior declaration. It follows a \"Define in Use\" principle that enables easy-to-use, easy-to-debug and very idiomatic Kotlin code. It's also worth noting that `Kodein` works hand in hand with Android's lifecycle and provides easy integration with popular libraries such as Android Architecture Components, leveraging their functionality.", - "links": [] + "description": "`Kodein` is one of the recommended dependency injection frameworks suitable for Android development. This open-source Kotlin library simplifies the DI process by allowing developers to bind various types of dependencies, such as singleton, factory, or provider bindings into containers or `Kodein` modules. It promotes dependency declaration where used, instead of prior declaration. It follows a \"Define in Use\" principle that enables easy-to-use, easy-to-debug and very idiomatic Kotlin code. It's also worth noting that `Kodein` works hand in hand with Android's lifecycle and provides easy integration with popular libraries such as Android Architecture Components, leveraging their functionality.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Kodein", + "url": "https://insert-kodein.io/", + "type": "article" + } + ] }, "0fNQWRxst8xRstIfPaPO6": { "title": "Storage", - "description": "On Android devices, storage refers to where your data such as apps, photos, videos, and music are saved. It can be categorized into two types: internal and external storage. Internal Storage is where data is stored that's tied directly to your app. This data is private by default and not accessible by other apps. External Storage, on the other hand, is a shared space where all apps can read and write data. It can be further subcategorized into Public and Private directories. Public directories are shared among all apps while private directories are specific to your app but can be accessed by other apps if they have the appropriate permissions. To control the access to these storage types, Android provides a file-based and a Scoped Storage framework. The latter limits apps' access to external storage and gives users more control over their data.", - "links": [] + "description": "On Android devices, storage refers to where your data such as apps, photos, videos, and music are saved. It can be categorized into two types: internal and external storage. Internal Storage is where data is stored that's tied directly to your app. This data is private by default and not accessible by other apps. External Storage, on the other hand, is a shared space where all apps can read and write data. It can be further sub-categorized into Public and Private directories. Public directories are shared among all apps while private directories are specific to your app but can be accessed by other apps if they have the appropriate permissions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Storage", + "url": "https://developer.android.com/guide/topics/data/data-storage", + "type": "article" + } + ] }, "PKql1HY0PLMfp50FRELXL": { "title": "Shared Preferences", - "description": "Shared Preferences in Android are used to store data in **key-value** pairs. It works similar to a tiny database where you can save small pieces of data such as settings or the state of an application. When data is saved to Shared Preferences, it persists across user sessions, even if your application is killed or gets deleted. Data in Shared Preferences is not typically used for large amounts of data. To perform actions such as saving, retrieving, or editing data in Shared Preferences, you use an instance of `SharedPreferences.Editor`.\n\nVisit the following resources to learn more:", + "description": "Shared Preferences in Android are used to store data in key-value pairs. It works similar to a tiny database where you can save small pieces of data such as settings or the state of an application. When data is saved to Shared Preferences, it persists across user sessions, even if your application is killed or gets deleted. Data in Shared Preferences is not typically used for large amounts of data. To perform actions such as saving, retrieving, or editing data in Shared Preferences, you use an instance of `SharedPreferences.Editor`.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Documentation", + "title": "Shared Preferences Documentation", "url": "https://developer.android.com/training/data-storage/shared-preferences", "type": "article" }, @@ -565,12 +957,12 @@ "description": "\"Room\" is a persistence library introduced by Google that provides an abstraction layer over SQLite to help with robust database access while harnessing the full power of SQLite. Room supports the creation of databases and defines queries in compile-time-checked SQL strings. These databases belong to the data classes that you create representing your app's data. Room comprises three main components: **Database**, a container that holds your app's data tables; **Entity**, representing a table within the database; and **DAO (Data Access Object)**, containing SQL query methods to interact with the database.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Save data in a local database using Room", + "title": "Room Database", "url": "https://developer.android.com/training/data-storage/room", "type": "article" }, { - "title": "The full beginner guide for Room in Android", + "title": "The Full Beginner's Guide for Room in Android", "url": "https://www.youtube.com/watch?v=bOd3wO0uFr8&t=10s", "type": "video" } @@ -578,20 +970,47 @@ }, "A4kdaj6AFueUgPI7hwKi5": { "title": "File System", - "description": "The Android operating system uses a specific File System structure to store and manage files. It’s primarily based on the Linux File system, with some specific Android features. The File System includes several key directories that are used for specific purposes. For instance, directories such as `/system` hold system apps and firmware, while `/data` contains user data, settings and installed applications, and `/sdcard` usually represents an internal or external SD card for additional storage. It's worth mentioning directories like `/proc`, `/dev`, and `/sys` which are virtual file systems and house important system files. As an Android developer, understanding these directories can help you interact with Android's file system more effectively. Note that access to some of these directories may be restricted depending on system permissions.", - "links": [] + "description": "The Android operating system uses a specific File System structure to store and manage files. It’s primarily based on the Linux File system, with some specific Android features. The File System includes several key directories that are used for specific purposes. For instance, directories such as `/system` hold system apps and firmware, while `/data` contains user data, settings and installed applications, and `/sdcard` usually represents an internal or external SD card for additional storage. It's worth mentioning directories like `/proc`, `/dev`, and `/sys` which are virtual file systems and house important system files. As an Android developer, understanding these directories can help you interact with Android's file system more effectively. Note that access to some of these directories may be restricted depending on system permissions.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android File System", + "url": "https://developer.android.com/training/data-storage/", + "type": "article" + }, + { + "title": "Android File System", + "url": "https://www.androidauthority.com/android-file-system-1010817/", + "type": "article" + } + ] }, "Yb6aKJMMCxU1QVltWg3Dr": { "title": "Network", - "description": "In Android, the `Network` component offers vital capabilities that enable communication and interaction among users, between users and remote servers, and between users and cloud services. Android provides a variety of APIs and services to interact with networks. The primary APIs are the `ConnectivityManager`, `WifiManager`, `TelephonyManager`, and `BluetoothManager` APIs, among others. ConnectivityManager, for example, can tell you about network connectivity changes. The **Network** component also involves tools for network monitoring and testing, which can be useful for optimizing app performance and dealing with connectivity issues. Be aware, some network operations are subject to system imposed restrictions and require specific permissions.", - "links": [] + "description": "In Android, the `Network` component offers vital capabilities that enable communication and interaction among users, between users and remote servers, and between users and cloud services. Android provides a variety of APIs and services to interact with networks. The primary APIs are the `ConnectivityManager`, `WifiManager`, `TelephonyManager`, and `BluetoothManager` APIs, among others. ConnectivityManager, for example, can tell you about network connectivity changes.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Network", + "url": "https://developer.android.com/guide/topics/connectivity", + "type": "article" + }, + { + "title": "ConnectivityManager", + "url": "https://developer.android.com/reference/android/net/ConnectivityManager", + "type": "article" + }, + { + "title": "WifiManager", + "url": "https://developer.android.com/reference/android/net/wifi/WifiManager", + "type": "article" + } + ] }, "dDMRYiqrKyOBnRRQc8zsp": { "title": "Retro", - "description": "**Retrofit** is a type-safe HTTP client for Android. It's designed to connect your application with an API or a back-end web service. Retrofit uses annotations to encode details about the API's operations and requests, such as the HTTP method (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`) and the query parameters. The main advantage of **Retrofit** over other similar libraries is in its simplicity and intuitiveness, and it efficiently handles all network calls.\n\nVisit the following resources to learn more:", + "description": "Retrofit is a type-safe HTTP client for Android. It's designed to connect your application with an API or a back-end web service. Retrofit uses annotations to encode details about the API's operations and requests, such as the HTTP method (`GET`, `POST`, `PUT`, `DELETE`, `HEAD`) and the query parameters. The main advantage of **Retrofit** over other similar libraries is in its simplicity and intuitiveness, and it efficiently handles all network calls.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Documentation", + "title": "Retrofit Documentation", "url": "https://square.github.io/retrofit/", "type": "article" }, @@ -607,63 +1026,142 @@ "description": "`OkHttp` is an HTTP client that's extremely efficient, enabling several advanced features in Android app or other platforms that use Java. Developed by Square, it's built for high efficiency and capacity, simplifying many networking tasks, including connection pooling, response caching, and request retries. OkHttp allows seamless recovery from network issues, minimizing the loss of data. The library ensures fewer errors and higher quality of service by using the modern TLS encryption, extensible request and response models, and a fluent API for ease of use and integration.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Documentation", + "title": "OkHttp on GitHub", "url": "https://github.com/square/okhttp", + "type": "opensource" + }, + { + "title": "OkHttp", + "url": "https://square.github.io/okhttp/", "type": "article" } ] }, "ww0fTbdXwVr-QIOClU7ng": { "title": "Apollo-Android", - "description": "**Apollo Android** is a set of tools for using GraphQL with Android, made by the Apollo community developers. It's fully written in Kotlin and it was designed to seamlessly integrate with any Android app, making fetching data across network and handling data in the client-side a breeze. Apollo Android runs your queries and mutations and returns results as generated Kotlin types. It also normalizes your data and caches your results for further speed enhancements. It operates both on Android and Kotlin/JVM backend environment. It's also coroutines-first making handling concurrency easy and effective. To use Apollo Android, you'll set up the plugin, point it at your GraphQL schema, and write GraphQL queries.", - "links": [] + "description": "**Apollo Android** is a set of tools for using GraphQL with Android, made by the Apollo community developers. It's fully written in Kotlin and it was designed to seamlessly integrate with any Android app, making fetching data across network and handling data in the client-side a breeze. Apollo Android runs your queries and mutations and returns results as generated Kotlin types. It also normalizes your data and caches your results for further speed enhancements. It operates both on Android and Kotlin/JVM backend environment. It's also coroutines-first making handling concurrency easy and effective. To use Apollo Android, you'll set up the plugin, point it at your GraphQL schema, and write GraphQL queries.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "apollographql/apollo-kotlin - GraphQL for Android", + "url": "https://github.com/apollographql/apollo-kotlin", + "type": "opensource" + }, + { + "title": "Apollo Android", + "url": "https://www.apollographql.com/docs/kotlin/v2/", + "type": "article" + }, + { + "title": "Apollo Docs", + "url": "https://www.apollographql.com/docs/kotlin/", + "type": "article" + } + ] }, "cFYZ2C7yNnY6NHKUNP2Z4": { "title": "Asynchronism", - "description": "Asynchronism in Android is a practice that defines operations, which can run independently from the main operation without following the program's linear flow. The Android system uses threads to handle asynchronous processes. These threads function independently, ensuring that complex or time-consuming operations do not interfere with the user interface or other essential parts of the application. Android provides various tools for carrying out asynchronous tasks, such as `Handler`, `ThreadPoolExecutor`, `IntentService`, `AsyncTask`, and `Loader` etc. These tools provide ways to execute tasks on different threads and communicate the results back to the main thread.", - "links": [] + "description": "Asynchronism in Android is a practice that defines operations, which can run independently from the main operation without following the program's linear flow. The Android system uses threads to handle asynchronous processes. These threads function independently, ensuring that complex or time-consuming operations do not interfere with the user interface or other essential parts of the application. Android provides various tools for carrying out asynchronous tasks, such as `Handler`, `ThreadPoolExecutor`, `IntentService`, `AsyncTask`, and `Loader` etc. These tools provide ways to execute tasks on different threads and communicate the results back to the main thread.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Asynchronous Tasks", + "url": "https://developer.android.com/guide/background", + "type": "article" + }, + { + "title": "Asynchronous Task Execution", + "url": "https://medium.com/@cpvasani48/asynchronous-task-execution-in-android-a-guide-with-example-44732744f3b8", + "type": "article" + } + ] }, "i_cKmTnGAYw8xpHwZHjAd": { "title": "Coroutines", - "description": "In Android, `coroutines` refer to a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. `Coroutines` provide a way to write asynchronous, non-blocking code in a natural, sequential manner. The fundamental building blocks of `coroutines` are `suspend` functions which are simply functions that can be paused and resumed at later times. They are the key to writing non-blocking asynchronous code and represent a single unit of asynchronous computation. This aspect of `coroutines` makes them useful for managing long-running tasks that might otherwise block the main thread and cause your application to become unresponsive.", - "links": [] + "description": "`Coroutines` refer to a concurrency design pattern that you can use on Android to simplify code that executes asynchronously. `Coroutines` provide a way to write asynchronous, non-blocking code in a natural, sequential manner. The fundamental building blocks of `coroutines` are `suspend` functions which are simply functions that can be paused and resumed at later times. They are the key to writing non-blocking asynchronous code and represent a single unit of asynchronous computation. This aspect of `coroutines` makes them useful for managing long-running tasks that might otherwise block the main thread and cause your application to become unresponsive.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Coroutines", + "url": "https://kotlinlang.org/docs/coroutines-overview.html", + "type": "article" + } + ] }, "BeGrA5BDBMZP1Jy7n-wl-": { "title": "Threads", - "description": "In Android, a `Thread` is a concurrent unit of execution. It has its own call stack, but can share its state with other threads in the same process, i.e., they can share the same memory area. They're primarily used in Android to perform operations in the background. One important aspect to note is that Android UI operations are not thread-safe, meaning they should always be done on the UI thread. Operations on `Threads` are typically managed through `Handler`, `Looper` and `MessageQueue` classes. Android also provides high-level constructs like `AsyncTask` and `Loader` for managing threads in relation to the UI.", - "links": [] + "description": "In Android, a `Thread` is a concurrent unit of execution. It has its own call stack, but can share its state with other threads in the same process, i.e., they can share the same memory area. They're primarily used in Android to perform operations in the background. One important aspect to note is that Android UI operations are not thread-safe, meaning they should always be done on the UI thread. Operations on `Threads` are typically managed through `Handler`, `Looper` and `MessageQueue` classes. Android also provides high-level constructs like `AsyncTask` and `Loader` for managing threads in relation to the UI.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Threads", + "url": "https://developer.android.com/guide/components/processes-and-threads", + "type": "article" + } + ] }, "zXsNEyRbb8UpEOAUv6FpY": { "title": "RxJava", - "description": "RxJava (Reactive Extensions for the JVM) is a powerful library for composing asynchronous and event-based programs using observable sequences in Java. If you are an Android developer, you might be familiar with callbacks and async tasks to perform long-running operations in the background. However, handling multiple async tasks and nested callbacks can produce code that's complicated to read and maintain. To alleviate such complexities, RxJava provides tools and methods to create, transform and chain Observable sequences in a clean and declarative manner. In other words, it provides a way to manage asynchronicity and concurrency in your code.", - "links": [] + "description": "RxJava (Reactive Extensions for the JVM) is a powerful library for composing asynchronous and event-based programs using observable sequences in Java. If you are an Android developer, you might be familiar with callbacks and async tasks to perform long-running operations in the background. However, handling multiple async tasks and nested callbacks can produce code that's complicated to read and maintain. To alleviate such complexities, RxJava provides tools and methods to create, transform and chain Observable sequences in a clean and declarative manner.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "RxJava on GitHub", + "url": "https://github.com/ReactiveX/RxJava", + "type": "opensource" + } + ] }, "4h37WBpYxRRyw9oH8ge7o": { "title": "RxKotlin", - "description": "`RxKotlin` is a lightweight language extension to Java for Android development, enabling Android apps to be built using Kotlin with Reactivex. It brings the power of reactive programming paradigm to Kotlin, extending its capabilities for processing asynchronous streams of data. It allows you to express static (e.g., already known) or dynamic (e.g., future unknown) data streams, and perform various operations on them easily. Key concepts of `RxKotlin` include Observables, Observers and Schedulers. Observables represent the data streams, Observers interact with the data stream, and Schedulers determine on which thread operations are performed. RxKotlin helps manage background tasks, handle asynchronous data streams, and implement complex UIs, among others. It is especially beneficial for mobile development where UI thread and background thread coordination is essential.", - "links": [] + "description": "`RxKotlin` is a lightweight language extension to Java for Android development, enabling Android apps to be built using Kotlin with Reactivex. It brings the power of reactive programming paradigm to Kotlin, extending its capabilities for processing asynchronous streams of data. It allows you to express static (e.g., already known) or dynamic (e.g., future unknown) data streams, and perform various operations on them easily. Key concepts of `RxKotlin` include Observables, Observers and Schedulers. Observables represent the data streams, Observers interact with the data stream, and Schedulers determine on which thread operations are performed. RxKotlin helps manage background tasks, handle asynchronous data streams, and implement complex UIs, among others.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "ReactiveX/RxKotlin - RxKotlin on GitHub", + "url": "https://github.com/ReactiveX/RxKotlin", + "type": "opensource" + } + ] }, "OAb_JD64uGm2tPoue7w6t": { "title": "WorkManager", - "description": "`WorkManager` is an Android library introduced by Google to execute tasks in a predictable and reliable manner. It's designed for tasks that require guaranteed execution, even if the app has been closed or the device restarts. It is backwards compatible up to API 14 and uses JobScheduler for API 23 and above, whilst using a combination of BroadcastReceiver + AlarmManager for APIs 14 and up. Regardless of the device API level, WorkManager works for all Android devices. Three types of work are supported by WorkManager - OneTimeWorkRequest, PeriodicWorkRequest, and DelayedWorkRequest. You can have constraints too for your work execution like work only when there's Internet or work only when the device is in idle state. It also supports work-chaining where you can create a chain of works to be performed in a specific order.", - "links": [] + "description": "`WorkManager` is an Android library introduced by Google to execute tasks in a predictable and reliable manner. It's designed for tasks that require guaranteed execution, even if the app has been closed or the device restarts. It is backwards compatible up to API 14 and uses JobScheduler for API 23 and above, whilst using a combination of BroadcastReceiver + AlarmManager for APIs 14 and up. Regardless of the device API level, WorkManager works for all Android devices. Three types of work are supported by WorkManager - OneTimeWorkRequest, PeriodicWorkRequest, and DelayedWorkRequest.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "WorkManager", + "url": "https://developer.android.com/topic/libraries/architecture/workmanager", + "type": "article" + } + ] }, "ZEdn2yy-IwHN3kOYr2ZbC": { "title": "Common Services", - "description": "In Android, \"Common Services\" are functional units or components provided by the Android system for use by developers. These services include things such as Location Services (used to determine the device's geographical location), Notification Services (handles the display and management of user notifications), and Sensor Services (interacts with hardware sensors). Other common services are Network and Connectivity Services, Account Manager, and Data Storage Services among others. They simplify the development process by handling complex functionalities behind the scenes, allowing developers to focus on the application's specific needs.", - "links": [] + "description": "Common Services are functional units or components provided by the Android system for use by developers. These services include things such as Location Services (used to determine the device's geographical location), Notification Services (handles the display and management of user notifications), and Sensor Services (interacts with hardware sensors). Other common services are Network and Connectivity Services, Account Manager, and Data Storage Services among others. They simplify the development process by handling complex functionalities behind the scenes, allowing developers to focus on the application's specific needs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Common Services", + "url": "https://developer.android.com/guide/components/services", + "type": "article" + } + ] }, "Xv0es_z64vh-QzivMeAT3": { "title": "Authentication", - "description": "Firebase Authentication in Android provides backend services, easy-to-use SDKs, and ready-made UI libraries to authenticate users to your app. It supports authentication using passwords, popular federated identity providers like Google, Facebook and Twitter, and more. Firebase also facilitates integration of functionality to sign in, sign up, and reset password. Moreover, it can be used to secure your database by implementing role-based access to data and to provide personalized experience according to the user's unique identity.\n\nFirebase Authentication offers two methods to authenticate. These are using an `email/password` login provided by Firebase Authentication or a `federated identity provider` like Google or Facebook. It also covers token-based authentication by creating custom tokens or verifying ID tokens. In addition to this, Firebase Authentication works with Firebase's client SDKs for practical use and works for long-running server processes for some of your users.\n\nFirebase Authentication provides a full suite of capabilities even beyond authentication to make your life easier, which includes Security Rules for Cloud Storage and Cloud Firestore, Firebase Dynamic Links, and Firebase Invites.\n\nRemember to always keep your development environment and Firebase console synced for smooth development operations. Any changes to the authentication method in the Firebase console should be reflected in your app and vice versa.", - "links": [] + "description": "Firebase Authentication in Android provides backend services, easy-to-use SDKs, and ready-made UI libraries to authenticate users to your app. It supports authentication using passwords, popular federated identity providers like Google, Facebook and Twitter, and more. Firebase also facilitates integration of functionality to sign in, sign up, and reset password. Moreover, it can be used to secure your database by implementing role-based access to data and to provide personalized experience according to the user's unique identity.\n\nFirebase Authentication offers two methods to authenticate. These are using an `email/password` login provided by Firebase Authentication or a `federated identity provider` like Google or Facebook. It also covers token-based authentication by creating custom tokens or verifying ID tokens. In addition to this, Firebase Authentication works with Firebase's client SDKs for practical use and works for long-running server processes for some of your users.\n\nFirebase Authentication provides a full suite of capabilities even beyond authentication to make your life easier, which includes Security Rules for Cloud Storage and Cloud Firestore, Firebase Dynamic Links, and Firebase Invites.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Firebase Authentication", + "url": "https://firebase.google.com/docs/auth", + "type": "article" + }, + { + "title": "Firebase Authentication: Android", + "url": "https://firebase.google.com/docs/auth/android/start", + "type": "article" + } + ] }, "xB4evbD07n1VrHOIpowV4": { "title": "Crashlytics", "description": "`Crashlytics` is a lightweight, real-time crash reporter that helps you track, prioritize, and fix stability issues that dismantle your app's quality. It delivers fast and precise information about crashes and helps you gain insights into your app's performance so you can pinpoint the exact line of code your app crashed on. Crashlytics offers a comprehensive suite of features like crash analysis, issue aggregation, and tracking user activities that led to a crash. This tool is now a part of Google's `Firebase` platform but can also be used independently.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Documentation", + "title": "Crashlytics Documentation", "url": "https://firebase.google.com/docs/crashlytics/get-started?platform=android", "type": "article" }, @@ -679,12 +1177,12 @@ "description": "Firebase Remote Config is a cloud service offered by Firebase. It lets you change the behavior and appearance of your app without requiring a new app release. By using Firebase Remote config, you can customize your app for different user segments, manage the core aspects of your app by modifying parameters externally, and conduct A/B tests to improve your app. It works efficiently by using default values that control the behavior and appearance of your app. When your app needs configuration information, it makes a request to the Firebase Remote Config server. If the server has updated values, these values replace the default ones, hence modifying the app's behavior or appearance according to your needs.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Documentation", + "title": "Remote Config", "url": "https://firebase.google.com/docs/remote-config/get-started?platform=android", "type": "article" }, { - "title": "Firebase: Remote config", + "title": "Getting Started with Remote Config", "url": "https://www.youtube.com/watch?v=pcnnbjAAIkI", "type": "video" } @@ -708,77 +1206,196 @@ }, "3EEfKAd-ppIQpdQSEhbA1": { "title": "FireStore", - "description": "Firestore, often referred to as Firebase Firestore or Cloud Firestore, is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud. Firestore comes with features like expressive querying, real-time updates, and automatic multi-region data replication. It is designed to offer seamless integration with other Firebase and Google Cloud products. It provides a cloud-based NoSQL database, which means the data is stored as collections of documents. Each document, in turn, contains a set of key-value pairs. Firestore ensures durable networking, so data syncs across client apps in real-time, even when the device is offline, making it easier for you to work with distributed data that can be kept in sync across various clients.", - "links": [] + "description": "Firestore, often referred to as Firebase Firestore or Cloud Firestore, is a flexible, scalable database for mobile, web, and server development from Firebase and Google Cloud. Firestore comes with features like expressive querying, real-time updates, and automatic multi-region data replication. It is designed to offer seamless integration with other Firebase and Google Cloud products. It provides a cloud-based NoSQL database, which means the data is stored as collections of documents. Each document, in turn, contains a set of key-value pairs. Firestore ensures durable networking, so data syncs across client apps in real-time, even when the device is offline, making it easier for you to work with distributed data that can be kept in sync across various clients.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Firestore", + "url": "https://firebase.google.com/docs/firestore", + "type": "article" + } + ] }, "D4ZXQOKJkyFYNZIy-MJ9Y": { "title": "Google Admob", - "description": "Google AdMob is a mobile advertising platform designed for app developers to monetize their apps by displaying ads from over 1 million Google advertisers. AdMob supports a wide range of ad formats, such as banner ads, interstitial ads, video ads, and more. It offers a powerful mediator that enables you to display ads from multiple sources, which includes the Google Mobile Ads SDK, third-party ad networks, and house ad campaigns. Furthermore, AdMob provides analytical tools to better understand your users and maximize ad revenue.", - "links": [] + "description": "Google AdMob is a mobile advertising platform designed for app developers to monetize their apps by displaying ads from over 1 million Google advertisers. AdMob supports a wide range of ad formats, such as banner ads, interstitial ads, video ads, and more. It offers a powerful mediator that enables you to display ads from multiple sources, which includes the Google Mobile Ads SDK, third-party ad networks, and house ad campaigns. Furthermore, AdMob provides analytical tools to better understand your users and maximize ad revenue.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Google AdMob", + "url": "https://admob.google.com/home/", + "type": "article" + }, + { + "title": "Google AdMob Documentation", + "url": "https://admob.google.com/home/get-started/", + "type": "article" + } + ] }, "m5rumeynEbS8T27pelr0-": { "title": "Google Play Services", - "description": "_Google Play Services_ is a proprietary background service and API package for Android devices from Google. Operated by Google, the service provides core functionalities like authentication for Google services, synchronized contacts, access to all the latest user privacy settings, and higher quality, lower-powered location-based services. It also speeds up offline searches, provides more immersive maps, and improves gaming experiences. Google Play Services play a crucial role in the operation of various other applications, including those not developed by Google. Moreover, it improves the overall Android experience by speeding up offline searches, providing more detailed maps, enhancing gaming experiences, and more.", - "links": [] + "description": "_Google Play Services_ is a proprietary background service and API package for Android devices from Google. Operated by Google, the service provides core functionalities like authentication for Google services, synchronized contacts, access to all the latest user privacy settings, and higher quality, lower-powered location-based services. It also speeds up offline searches, provides more immersive maps, and improves gaming experiences. Google Play Services play a crucial role in the operation of various other applications, including those not developed by Google. Moreover, it improves the overall Android experience by speeding up offline searches, providing more detailed maps, enhancing gaming experiences, and more.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Google Play Services", + "url": "https://developer.android.com/google/play-services", + "type": "article" + }, + { + "title": "Google Play Services Documentation", + "url": "https://developer.android.com/google/play-services/overview.html", + "type": "article" + } + ] }, "S5FVF9rMgVSSDKXJW2GYb": { "title": "Google Maps", - "description": "Google Maps is a crucial service on Android, offering powerful, user-friendly mapping technology and local business information. Google Maps features include street maps, satellite imagery, 360° panoramic views of streets (Street View), real-time traffic conditions (Google Traffic), and route planning for traveling by foot, car, bicycle and air, or public transportation. The service's interface includes a function to overlay various layers such as traffic density, public transit lines, and cycling paths. Google Maps for Android also provides an API, which allows developers to interface with and control certain aspects of the Google Maps service in their applications. This capability subjects to certain usage limits and requirements set by Google.", - "links": [] + "description": "Google Maps is a crucial service on Android, offering powerful, user-friendly mapping technology and local business information. Google Maps features include street maps, satellite imagery, 360° panoramic views of streets (Street View), real-time traffic conditions (Google Traffic), and route planning for traveling by foot, car, bicycle and air, or public transportation. The service's interface includes a function to overlay various layers such as traffic density, public transit lines, and cycling paths. Google Maps for Android also provides an API, which allows developers to interface with and control certain aspects of the Google Maps service in their applications. This capability subjects to certain usage limits and requirements set by Google.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Google Maps", + "url": "https://developers.google.com/maps/documentation/android-sdk/overview", + "type": "article" + }, + { + "title": "Google Maps Documentation", + "url": "https://developers.google.com/maps/documentation/android-sdk/intro", + "type": "article" + } + ] }, "77F9F3oI5CPgwgM_hxWfa": { "title": "Linting", - "description": "`Linting` in Android is a tool that analyzes the source code of your application to identify potential errors, bugs, stylistic errors, and suspicious constructs. The term Linting came from a Unix utility that examined C language source code. In Android, it not only checks for potential Java issues but also for XML layout files and provides alerts for issues it encounters regarding usability, performance, and accessibility. For instance, it may scrutinize a draft of your AndroidManifest.xml file for potential duplication of elements or other anomalies that would cause the app to crash.", - "links": [] + "description": "`Linting` in Android is a tool that analyzes the source code of your application to identify potential errors, bugs, stylistic errors, and suspicious constructs. The term Linting came from a Unix utility that examined C language source code. In Android, it not only checks for potential Java issues but also for XML layout files and provides alerts for issues it encounters regarding usability, performance, and accessibility. For instance, it may scrutinize a draft of your AndroidManifest.xml file for potential duplication of elements or other anomalies that would cause the app to crash.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Linting", + "url": "https://developer.android.com/studio/write/lint", + "type": "article" + } + ] }, "zMbXQH17Q52opdbitPzj7": { "title": "Ktlint", - "description": "`ktlint` is a static code analysis tool. It enforces a highly consistent style and adheres extensively to the official Kotlin coding conventions. `ktlint` does not have any configuration options (by design). The only exceptions are disabling specific rule(s) and specifying indentation size. `ktlint` can check, as well as automatically fix your code. Its main goal is to bring unified code style to your project. It works on the command line as well, so it can be hooked up into your continuous integration pipeline. It also has Ant, Gradle and Maven wrappers. You can use Ktlint on any Android/Kotlin project, as long as you have Gradle or Maven installed.", - "links": [] + "description": "`ktlint` is a static code analysis tool. It enforces a highly consistent style and adheres extensively to the official Kotlin coding conventions. `ktlint` does not have any configuration options (by design). The only exceptions are disabling specific rule(s) and specifying indentation size. `ktlint` can check, as well as automatically fix your code. Its main goal is to bring unified code style to your project. It works on the command line as well, so it can be hooked up into your continuous integration pipeline. It also has Ant, Gradle and Maven wrappers. You can use Ktlint on any Android/Kotlin project, as long as you have Gradle or Maven installed.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Ktlint: Static Code Analysis for Kotlin", + "url": "https://github.com/pinterest/ktlint", + "type": "opensource" + }, + { + "title": "Ktlint", + "url": "https://ktlint.github.io/", + "type": "article" + } + ] }, "RUvuCp_JK5MQQT13SSHUV": { "title": "Detekt", - "description": "`Detekt` is a static code analysis tool for the Kotlin programming language. It operates on the abstract syntax tree provided by the Kotlin compiler and can run in the command line or as a task in your Gradle build script. Detekt provides complexity reports that can be used to identify overly complex code and help simplify it. It also checks for a variety of potential bugs and code smells, including issues with formatting, naming conventions, exception handling, and more. Moreover, Detekt is highly configurable, allowing you to enable, disable, or modify the behavior of its checks to suit your project's needs.", - "links": [] + "description": "`Detekt` is a static code analysis tool for the Kotlin programming language. It operates on the abstract syntax tree provided by the Kotlin compiler and can run in the command line or as a task in your Gradle build script. Detekt provides complexity reports that can be used to identify overly complex code and help simplify it. It also checks for a variety of potential bugs and code smells, including issues with formatting, naming conventions, exception handling, and more. Moreover, Detekt is highly configurable, allowing you to enable, disable, or modify the behavior of its checks to suit your project's needs.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Detekt: Static Code Analysis for Kotlin", + "url": "https://github.com/detekt/detekt", + "type": "opensource" + }, + { + "title": "Detekt", + "url": "https://detekt.dev/", + "type": "article" + } + ] }, "6KbSUAoT_jTudFoIbwMpA": { "title": "Debugging", - "description": "\"Debugging\" is a critical step in the app development process. In Android development, it includes identifying and fixing errors, or bugs, in your code. You can debug Android apps using several tools and techniques. For example, Android Studio, the primary integrated development environment (IDE) for Android, comes with a built-in debugging tool, the Android Debug Bridge (ADB). This command-line tool allows you to communicate your device and perform various actions like installing and debugging apps. Android Studio also supports step-by-step debugging, where you can set breakpoints in your code and inspect the application state at those points. Additionally, you can use log messages to monitor the behavior of your application, which is especially useful for understanding the state of your app during runtime. Remember that before debugging, you need to build your app in debug mode.", - "links": [] + "description": "Debugging is a critical step in the app development process. In Android development, it includes identifying and fixing errors, or bugs, in your code. You can debug Android apps using several tools and techniques. For example, Android Studio, the primary integrated development environment (IDE) for Android, comes with a built-in debugging tool, the Android Debug Bridge (ADB). This command-line tool allows you to communicate your device and perform various actions like installing and debugging apps. Android Studio also supports step-by-step debugging, where you can set breakpoints in your code and inspect the application state at those points.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Debugging", + "url": "https://developer.android.com/studio/debug", + "type": "article" + } + ] }, "VFOD4JrV8kZ2583G3oT95": { "title": "Timber", - "description": "`Timber` is a logging utility tool that has been specifically extended from the `Log` class of Android. It has been built to simplify the logging process while aiming to reduce the amount of boilerplate code the developer has to write. It was designed and is maintained by Jake Wharton, a renowned contributor in the Android Developer community. In Timber, each log message is directed to the next available logger, reducing the redundancy of manually assigning log tags. The simplicity of Timber is highlighted by its ability to log without defining any tag. Most importantly, Timber only logs messages in debug builds by default, avoiding potential data leaks in your production application.", - "links": [] + "description": "`Timber` is a logging utility tool that has been specifically extended from the `Log` class of Android. It has been built to simplify the logging process while aiming to reduce the amount of boilerplate code the developer has to write. It was designed and is maintained by Jake Wharton, a renowned contributor in the Android Developer community. In Timber, each log message is directed to the next available logger, reducing the redundancy of manually assigning log tags. The simplicity of Timber is highlighted by its ability to log without defining any tag. Most importantly, Timber only logs messages in debug builds by default, avoiding potential data leaks in your production application.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Timber on GitHub", + "url": "https://github.com/JakeWharton/timber", + "type": "opensource" + } + ] }, "3i4g9ZWgLxKb2UMgRJi4Q": { "title": "Leak Canary", - "description": "LeakCanary is a powerful open-source memory leak detection library for Android and Java. It is integrated into your app, and once you run your app, LeakCanary immediately starts watching for memory leaks and captures a memory dump if it detects one. After investigation, it will present a full stack trace to help you pinpoint the exact location of the memory leak. With the LeakCanary's user-friendly interface, you can then analyze the memory leak right in your app. The most recent version of LeakCanary also includes other improvements like automatic detection of leaks in Activity, Fragment, View, ViewModel, LiveData, etc.", - "links": [] + "description": "LeakCanary is a powerful open-source memory leak detection library for Android and Java. It is integrated into your app, and once you run your app, LeakCanary immediately starts watching for memory leaks and captures a memory dump if it detects one. After investigation, it will present a full stack trace to help you pinpoint the exact location of the memory leak. With the LeakCanary's user-friendly interface, you can then analyze the memory leak right in your app. The most recent version of LeakCanary also includes other improvements like automatic detection of leaks in Activity, Fragment, View, ViewModel, LiveData, etc.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "LeakCanary on GitHub", + "url": "https://github.com/square/leakcanary", + "type": "opensource" + }, + { + "title": "Leak Canary", + "url": "https://square.github.io/leakcanary/", + "type": "article" + } + ] }, "7RKN1FNtRE_BE6QeAQrKb": { "title": "Chucker", - "description": "`Chucker` is an open-source debugging library created for Android applications. It has been designed to be easy to use and convenient for developers. This library intercepts and records all HTTP requests and responses inside your application, which helps to visualize and share this information in an understandable and easy-to-read format. Using Chucker's distinct features, you can inspect all the HTTP and HTTPS traffic going in and out of your app directly. In addition, it provides other nifty features such as a user-friendly interface to view the server's raw response. It's like having a built-in network inspector in your debugging tool, enabling you to solve network-related issues more efficiently.", - "links": [] + "description": "`Chucker` is an open-source debugging library created for Android applications. It has been designed to be easy to use and convenient for developers. This library intercepts and records all HTTP requests and responses inside your application, which helps to visualize and share this information in an understandable and easy-to-read format. Using Chucker's distinct features, you can inspect all the HTTP and HTTPS traffic going in and out of your app directly. In addition, it provides other nifty features such as a user-friendly interface to view the server's raw response. It's like having a built-in network inspector in your debugging tool, enabling you to solve network-related issues more efficiently.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "ChuckerTeam/chucker - Chucker On GitHub", + "url": "https://github.com/ChuckerTeam/chucker", + "type": "opensource" + }, + { + "title": "Network Traffic Inspection with Chucker", + "url": "https://medium.com/tech-takeaways/simple-android-network-traffic-inspection-with-chucker-and-seismic-1e6162c51f64", + "type": "article" + } + ] }, "ACUJlDDR0jqEohsFzWEoQ": { "title": "Jetpack Benchmark", - "description": "Jetpack Benchmark is a library within the Android Jetpack Suite that allows developers to quickly and accurately measure the performance of their apps. This library can help measure CPU, memory, and IO performance of code in Android apps. Developers can define some specific code paths to be benchmarked by wrapping the code in `BenchmarkRule.measureRepeated {}`. In addition, it automatically takes care of warmup, measures your code performance, and outputs benchmarking results to the Android Studio's logcat.", - "links": [] + "description": "Jetpack Benchmark is a library within the Android Jetpack Suite that allows developers to quickly and accurately measure the performance of their apps. This library can help measure CPU, memory, and IO performance of code in Android apps. Developers can define some specific code paths to be benchmarked by wrapping the code in `BenchmarkRule.measureRepeated {}`. In addition, it automatically takes care of warmup, measures your code performance, and outputs benchmarking results to the Android Studio's logcat.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Jetpack Benchmark", + "url": "https://developer.android.com/studio/profile/benchmark", + "type": "article" + } + ] }, "ZOQm5OlzCA-h_yxywwDrW": { "title": "Testing", - "description": "_**Android Testing**_ is a crucial part of the app development process. It involves validating the functionality, performance, usability, and consistency of your app before deploying it to the Play Store. There are two types of testing methods notably used: **Unit testing** and **Instrumentation testing**. Unit testing, as the name suggests, tests each unit or segment of your code separately. It doesn't require Android dependencies and hence, runs faster. Instrumentation testing, on another hand, requires Android dependencies and is slower. Instrumentation testing tests the UIs, simulates user interactions and validates the navigation between different parts of your app. Android provides built-in testing frameworks like `JUnit` for unit testing and `Espresso` for Instrumentation testing. These can effectively test different parts of your app, assuring its robustness.", - "links": [] + "description": "**Testing** is a crucial part of the app development process. It involves validating the functionality, performance, usability, and consistency of your app before deploying it to the Play Store. There are two types of testing methods notably used: **Unit testing** and **Instrumentation Testing**. Unit testing, as the name suggests, tests each unit or segment of your code separately. It doesn't require Android dependencies and hence, runs faster. Instrumentation testing, on another hand, requires Android dependencies and is slower. Instrumentation testing tests the UIs, simulates user interactions and validates the navigation between different parts of your app. Android provides built-in testing frameworks like `JUnit` for unit testing and `Espresso` for Instrumentation testing.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Testing", + "url": "https://developer.android.com/training/testing", + "type": "article" + } + ] }, "-ONSC-ImGSELbamKmjIlH": { "title": "Espresso", - "description": "Espresso is a testing framework provided by Android to create UI tests for Android applications. It automatically synchronizes your test actions with the UI of your application, ensuring that your test will only proceed when the necessary UI activities have been completed. In Espresso, you can programmatically simulate user interactions like clicking buttons, typing text, or swiping screens, and then examine the UI's state to confirm it's as expected. Espresso tests can run on devices running Android 4.3 (API level 18) or higher. It's important to note that Espresso tests are written based on what the user can see on the screen.", - "links": [] + "description": "Espresso is a testing framework provided by Android to create UI tests for Android applications. It automatically synchronizes your test actions with the UI of your application, ensuring that your test will only proceed when the necessary UI activities have been completed. In Espresso, you can programmatically simulate user interactions like clicking buttons, typing text, or swiping screens, and then examine the UI's state to confirm it's as expected. Espresso tests can run on devices running Android 4.3 (API level 18) or higher.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Espresso", + "url": "https://developer.android.com/training/testing/espresso", + "type": "article" + } + ] }, "gvGAwjk_nhEgxzZ_c3f6b": { "title": "JUnit", - "description": "**JUnit** is a popular testing framework for Java programming. It forms the basis for many other testing libraries and tools in the Android ecosystem, making it important for any Android developer to become familiar with. The basic use of JUnit involves annotations such as `@Test`, indicating methods that represent a single test case. Other useful features include `@Before` and `@After` which allow for setup and teardown processes to be defined clearly. Another powerful feature in JUnit is the ability to create parameterized tests, effectively running the same test multiple times with different inputs.\n\nVisit the following resources to learn more:", + "description": "JUnit is a popular testing framework for Java programming. It forms the basis for many other testing libraries and tools in the Android ecosystem, making it important for any Android developer to become familiar with. The basic use of JUnit involves annotations such as `@Test`, indicating methods that represent a single test case. Other useful features include `@Before` and `@After` which allow for setup and teardown processes to be defined clearly. Another powerful feature in JUnit is the ability to create parameterized tests, effectively running the same test multiple times with different inputs.\n\nVisit the following resources to learn more:", "links": [ { "title": "Documentation", @@ -794,27 +1411,67 @@ }, "kc6buUsLAeZeUb4Tk0apM": { "title": "Distribution", - "description": "Distribution in Android refers to the methods and channels you can use to get your Android application into the hands of users. You can choose to distribute your app on the Google Play Store, which is the official app store for the Android operating system. This platform makes your app available to users in various countries around the world. Additionally, you can also opt to distribute your app through other third-party app stores or even your own website. Furthermore, Google provides a range of distribution options such as country targeting, device targeting, and staged rollouts, which can be customized according to your distribution strategy. Remember, when you submit your application for distribution, you must adhere to the respective app store's policy and content guidelines.", - "links": [] + "description": "Distribution in Android refers to the methods and channels you can use to get your Android application into the hands of users. You can choose to distribute your app on the Google Play Store, which is the official app store for the Android operating system. This platform makes your app available to users in various countries around the world. Additionally, you can also opt to distribute your app through other third-party app stores or even your own website. Furthermore, Google provides a range of distribution options such as country targeting, device targeting, and staged roll-outs, which can be customized according to your distribution strategy. Remember, when you submit your application for distribution, you must adhere to the respective app store's policy and content guidelines.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Google Play Developer Distribution", + "url": "https://developer.android.com/distribute", + "type": "article" + } + ] }, "T7q_quNaIAuGi96OdnDT1": { "title": "Firebase Distribution", - "description": "Firebase Distribution is a development tool within the Google Firebase suite that allows you to share pre-release versions of your Android apps with your development team. It enables you to distribute your app binaries to multiple testers and teams to get feedback before the app's official launch. Firebase Distribution supports both Android and iOS applications and works in tandem with other features, like Firebase Crashlytics, to effectively manage the testing and debugging aspects of your application's lifecycle.", - "links": [] + "description": "Firebase Distribution is a development tool within the Google Firebase suite that allows you to share pre-release versions of your Android apps with your development team. It enables you to distribute your app binaries to multiple testers and teams to get feedback before the app's official launch. Firebase Distribution supports both Android and iOS applications and works in tandem with other features, like Firebase Crashlytics, to effectively manage the testing and debugging aspects of your application's lifecycle.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Firebase Distribution", + "url": "https://firebase.google.com/docs/app-distribution", + "type": "article" + } + ] }, "HgRdgi2Hu4C8YLG5PXfoo": { "title": "Google Playstore", - "description": "**Google Play Store** is the official distribution channel for Android apps and other digital media content. It is a global online software store developed and operated by Google. Developers submit their applications to Google Play through the Play Console where Google Play's automated systems scan for potentially malicious code and content violations, before they are published on the Play Store. Users can then browse, download, and use these applications on their Android devices or via the web. Purchases, downloads, and user feedback can be tracked via the Google Play Console. Owners of Android devices can also configure automatic updates for the applications they have installed from the store. This platform supports multiple languages and multiple forms of payment methods, making it accessible and customer-friendly.", - "links": [] + "description": "**Google Play Store** is the official distribution channel for Android apps and other digital media content. It is a global online software store developed and operated by Google. Developers submit their applications to Google Play through the Play Console where Google Play's automated systems scan for potentially malicious code and content violations, before they are published on the Play Store. Users can then browse, download, and use these applications on their Android devices or via the web. Purchases, downloads, and user feedback can be tracked via the Google Play Console. Owners of Android devices can also configure automatic updates for the applications they have installed from the store. This platform supports multiple languages and multiple forms of payment methods, making it accessible and customer-friendly.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Google Play Store", + "url": "https://play.google.com/store", + "type": "article" + }, + { + "title": "Google Play Store Documentation", + "url": "https://developer.android.com/distribute/googleplay", + "type": "article" + } + ] }, "_FSlD_qTz5Xo0x3pB6sZI": { "title": "Signed APK", - "description": "A **Signed APK** is a version of your app that you prepare for distribution in the Play Store or other Android markets. When you sign your app using a private key, you authenticate your identity as the developer of the app. It is a required step by the Android system that ensures only updates to the APK that are from the original developer will be accepted. The Android system refuses to install an app if it's not signed appropriately, thereby protecting users from potential security risks. Please make sure that you keep your private key in a safe place for future updates to your app, losing it would imply that you cannot update your app anymore.", - "links": [] + "description": "A **Signed APK** is a version of your app that you prepare for distribution in the Play Store or other Android markets. When you sign your app using a private key, you authenticate your identity as the developer of the app. It is a required step by the Android system that ensures only updates to the APK that are from the original developer will be accepted. The Android system refuses to install an app if it's not signed appropriately, thereby protecting users from potential security risks.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Signing Your App", + "url": "https://developer.android.com/studio/publish/app-signing", + "type": "article" + } + ] }, "4_e76QafrB419S2INOeKd": { "title": "Interface & Navigation", - "description": "In Android development, the concepts of \"Interface\" and \"Navigation\" are crucial. The \"Interface\" often refers to the Graphical User Interface (GUI) that users interact with. This includes buttons, text fields, image views, scroll views and other UI elements that the users can interact with to perform certain tasks. Tools like XML and Material Designs are used for interface design in Android. Meanwhile, \"Navigation\" refers to the interactions that allow users to navigate across, into, and back out from the different pieces of content within the app, following a clear path, like a map. Android uses the Navigation Component, a suite of libraries, tools, and guidance on constructing in-app navigation. Understanding both these elements, Interface and Navigation, is fundamental to creating an intuitive and user-friendly Android application.", - "links": [] + "description": "In Android development, the concepts of \"Interface\" and \"Navigation\" are crucial. The \"Interface\" often refers to the Graphical User Interface (GUI) that users interact with. This includes buttons, text fields, image views, scroll views and other UI elements that the users can interact with to perform certain tasks. Tools like XML and Material Designs are used for interface design in Android.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Android Developers: Interface", + "url": "https://developer.android.com/guide/topics/ui/declaring-layout.html", + "type": "article" + }, + { + "title": "Android Developers: Navigation", + "url": "https://developer.android.com/guide/navigation", + "type": "article" + } + ] } } \ No newline at end of file diff --git a/public/roadmap-content/backend.json b/public/roadmap-content/backend.json index 0a03b1d1b..abf458105 100644 --- a/public/roadmap-content/backend.json +++ b/public/roadmap-content/backend.json @@ -1,13 +1,30 @@ { "gKTSe9yQFVbPVlLzWB0hC": { "title": "Search Engines", - "description": "Search engines like Elasticsearch are specialized tools designed for fast, scalable, and flexible searching and analyzing of large volumes of data. Elasticsearch is an open-source, distributed search and analytics engine built on Apache Lucene, offering full-text search capabilities, real-time indexing, and advanced querying features. Key characteristics of search engines like Elasticsearch include:\n\n1. **Full-Text Search**: Support for complex search queries, including relevance scoring and text analysis.\n2. **Distributed Architecture**: Scalability through horizontal distribution across multiple nodes or servers.\n3. **Real-Time Indexing**: Ability to index and search data almost instantaneously.\n4. **Powerful Query DSL**: A domain-specific language for constructing and executing sophisticated queries.\n5. **Analytics**: Capabilities for aggregating and analyzing data, often used for log and event data analysis.\n\nElasticsearch is commonly used in applications requiring advanced search functionality, such as search engines, data analytics platforms, and real-time monitoring systems.", - "links": [] + "description": "Search engines like Elasticsearch are specialized tools designed for fast, scalable, and flexible searching and analyzing of large volumes of data. Elasticsearch is an open-source, distributed search and analytics engine built on Apache Lucene, offering full-text search capabilities, real-time indexing, and advanced querying features. Key characteristics of search engines like Elasticsearch include:\n\n1. **Full-Text Search**: Support for complex search queries, including relevance scoring and text analysis.\n2. **Distributed Architecture**: Scalability through horizontal distribution across multiple nodes or servers.\n3. **Real-Time Indexing**: Ability to index and search data almost instantaneously.\n4. **Powerful Query DSL**: A domain-specific language for constructing and executing sophisticated queries.\n5. **Analytics**: Capabilities for aggregating and analyzing data, often used for log and event data analysis.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Elasticsearch", + "url": "https://www.elastic.co/elasticsearch/", + "type": "article" + } + ] }, "9Fpoor-Os_9lvrwu5Zjh-": { "title": "Design and Development Principles", - "description": "Design and Development Principles are fundamental guidelines that inform the creation of software systems. Key principles include:\n\n1. SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)\n2. DRY (Don't Repeat Yourself)\n3. KISS (Keep It Simple, Stupid)\n4. YAGNI (You Aren't Gonna Need It)\n5. Separation of Concerns\n6. Modularity\n7. Encapsulation\n8. Composition over Inheritance\n9. Loose Coupling and High Cohesion\n10. Principle of Least Astonishment\n\nThese principles aim to create more maintainable, scalable, and robust software. They encourage clean code, promote reusability, reduce complexity, and enhance flexibility. While not rigid rules, these principles guide developers in making design decisions that lead to better software architecture and easier long-term maintenance. Applying these principles helps in creating systems that are easier to understand, modify, and extend over time.", - "links": [] + "description": "Design and Development Principles are fundamental guidelines that inform the creation of software systems. Key principles include:\n\n* SOLID (Single Responsibility, Open-Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)\n* DRY (Don't Repeat Yourself)\n* KISS (Keep It Simple, Stupid)\n* YAGNI (You Aren't Gonna Need It)\n* Separation of Concerns\n* Modularity\n* Encapsulation\n* Composition over Inheritance\n* Loose Coupling and High Cohesion\n* Principle of Least Astonishment\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Design Principles - Wikipedia", + "url": "https://en.wikipedia.org/wiki/Design_principles", + "type": "article" + }, + { + "title": "Design Principles - Microsoft", + "url": "https://docs.microsoft.com/en-us/dotnet/standard/design-guidelines/index", + "type": "article" + } + ] }, "EwvLPSI6AlZ4TnNIJTZA4": { "title": "Learn about APIs", @@ -71,7 +88,7 @@ "description": "Rust is a systems programming language known for its focus on safety, performance, and concurrency. It provides fine-grained control over system resources while ensuring memory safety without needing a garbage collector. Rust's ownership model enforces strict rules on how data is accessed and managed, preventing common issues like null pointer dereferences and data races. Its strong type system and modern features, such as pattern matching and concurrency support, make it suitable for a wide range of applications, from low-level systems programming to high-performance web servers and tools. Rust is gaining traction in both industry and open source for its reliability and efficiency.\n\nVisit the following resources to learn more:", "links": [ { - "title": "The Rust Programming Language - online book", + "title": "The Rust Programming Language - Book", "url": "https://doc.rust-lang.org/book/", "type": "article" }, @@ -334,8 +351,8 @@ "type": "article" }, { - "title": "Learn Git with Tutorials, News and Tips - Atlassian", - "url": "https://www.atlassian.com/git", + "title": "Git Documentation", + "url": "https://git-scm.com/doc", "type": "article" }, { @@ -370,8 +387,8 @@ "type": "article" }, { - "title": "Git", - "url": "https://git-scm.com/", + "title": "Git Documentation", + "url": "https://git-scm.com/doc", "type": "article" }, { @@ -396,7 +413,7 @@ "type": "article" }, { - "title": "GitHub Website", + "title": "GitHub", "url": "https://github.com", "type": "article" }, @@ -424,7 +441,7 @@ }, "Ry_5Y-BK7HrkIc6X0JG1m": { "title": "Bitbucket", - "description": "Bitbucket is a web-based version control repository hosting service owned by Atlassian. It primarily uses Git version control systems, offering both cloud-hosted and self-hosted options. Bitbucket provides features such as pull requests for code review, branch permissions, and inline commenting on code. It integrates seamlessly with other Atlassian products like Jira and Trello, making it popular among teams already using Atlassian tools. Bitbucket supports continuous integration and deployment through Bitbucket Pipelines. It offers unlimited private repositories for small teams, making it cost-effective for smaller organizations. While similar to GitHub in many aspects, Bitbucket's integration with Atlassian's ecosystem and its pricing model for private repositories are key differentiators. It's widely used for collaborative software development, particularly in enterprise environments already invested in Atlassian's suite of products.\n\nVisit the following resources to learn more:", + "description": "Bitbucket is a web-based version control repository hosting service owned by Atlassian. It primarily uses Git version control systems, offering both cloud-hosted and self-hosted options. Bitbucket provides features such as pull requests for code review, branch permissions, and inline commenting on code. It integrates seamlessly with other Atlassian products like Jira and Trello, making it popular among teams already using Atlassian tools. Bitbucket supports continuous integration and deployment through Bitbucket Pipelines. It offers unlimited private repositories for small teams, making it cost-effective for smaller organizations.\n\nVisit the following resources to learn more:", "links": [ { "title": "Bitbucket Website", @@ -453,9 +470,9 @@ "description": "GitLab is a web-based DevOps platform that provides a complete solution for the software development lifecycle. It offers source code management, continuous integration/continuous deployment (CI/CD), issue tracking, and more, all integrated into a single application. GitLab supports Git repositories and includes features like merge requests (similar to GitHub's pull requests), wiki pages, and issue boards. It emphasizes DevOps practices, providing built-in CI/CD pipelines, container registry, and Kubernetes integration. GitLab offers both cloud-hosted and self-hosted options, giving organizations flexibility in deployment. Its all-in-one approach differentiates it from competitors, as it includes features that might require multiple tools in other ecosystems. GitLab's focus on the entire DevOps lifecycle, from planning to monitoring, makes it popular among enterprises and teams seeking a unified platform for their development workflows.\n\nVisit the following resources to learn more:", "links": [ { - "title": "GitLab Website", + "title": "GitLab", "url": "https://gitlab.com/", - "type": "opensource" + "type": "article" }, { "title": "GitLab Documentation", @@ -546,7 +563,7 @@ "type": "article" }, { - "title": "MS SQL website", + "title": "MS SQL", "url": "https://www.microsoft.com/en-ca/sql-server/", "type": "article" }, @@ -567,12 +584,12 @@ "description": "MySQL is an open-source relational database management system (RDBMS) known for its speed, reliability, and ease of use. It uses SQL (Structured Query Language) for database interactions and supports a range of features for data management, including transactions, indexing, and stored procedures. MySQL is widely used for web applications, data warehousing, and various other applications due to its scalability and flexibility. It integrates well with many programming languages and platforms, and is often employed in conjunction with web servers and frameworks in popular software stacks like LAMP (Linux, Apache, MySQL, PHP/Python/Perl). MySQL is maintained by Oracle Corporation and has a large community and ecosystem supporting its development and use.\n\nVisit the following resources to learn more:", "links": [ { - "title": "MySQL website", + "title": "MySQL", "url": "https://www.mysql.com/", "type": "article" }, { - "title": "W3Schools - MySQL tutorial ", + "title": "W3Schools - MySQL Tutorial", "url": "https://www.w3schools.com/mySQl/default.asp", "type": "article" }, @@ -603,12 +620,12 @@ "description": "Oracle Database is a highly robust, enterprise-grade relational database management system (RDBMS) developed by Oracle Corporation. Known for its scalability, reliability, and comprehensive features, Oracle Database supports complex data management tasks and mission-critical applications. It provides advanced functionalities like SQL querying, transaction management, high availability through clustering, and data warehousing. Oracle's database solutions include support for various data models, such as relational, spatial, and graph, and offer tools for security, performance optimization, and data integration. It is widely used in industries requiring large-scale, secure, and high-performance data processing.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Oracle Website", "url": "https://www.oracle.com/database/", "type": "article" }, { - "title": "Official Docs", + "title": "Oracle Docs", "url": "https://docs.oracle.com/en/database/index.html", "type": "article" }, @@ -626,10 +643,10 @@ }, "tD3i-8gBpMKCHB-ITyDiU": { "title": "MariaDB", - "description": "MariaDB server is a community developed fork of MySQL server. Started by core members of the original MySQL team, MariaDB actively works with outside developers to deliver the most featureful, stable, and sanely licensed open SQL server in the industry. MariaDB was created with the intention of being a more versatile, drop-in replacement version of MySQL\n\nVisit the following resources to learn more:", + "description": "MariaDB server is a community developed fork of MySQL server. Started by core members of the original MySQL team, MariaDB actively works with outside developers to deliver the most feature rich, stable, and sanely licensed open SQL server in the industry. MariaDB was created with the intention of being a more versatile, drop-in replacement version of MySQL\n\nVisit the following resources to learn more:", "links": [ { - "title": "MariaDB website", + "title": "MariaDB", "url": "https://mariadb.org/", "type": "article" }, @@ -782,8 +799,14 @@ }, "GwApfL4Yx-b5Y8dB9Vy__": { "title": "Failure Modes", - "description": "Database failure modes refer to the various ways in which a database system can malfunction or cease to operate correctly. These include hardware failures (like disk crashes or network outages), software bugs, data corruption, performance degradation due to overload, and inconsistencies in distributed systems. Common failure modes involve data loss, system unavailability, replication lag in distributed databases, and deadlocks. To mitigate these, databases employ strategies such as redundancy, regular backups, transaction logging, and failover mechanisms. Understanding potential failure modes is crucial for designing robust database systems with high availability and data integrity. It informs the implementation of fault tolerance measures, recovery procedures, and monitoring systems to ensure database reliability and minimize downtime in critical applications.", - "links": [] + "description": "Database failure modes refer to the various ways in which a database system can malfunction or cease to operate correctly. These include hardware failures (like disk crashes or network outages), software bugs, data corruption, performance degradation due to overload, and inconsistencies in distributed systems. Common failure modes involve data loss, system unavailability, replication lag in distributed databases, and deadlocks. To mitigate these, databases employ strategies such as redundancy, regular backups, transaction logging, and failover mechanisms. Understanding potential failure modes is crucial for designing robust database systems with high availability and data integrity. It informs the implementation of fault tolerance measures, recovery procedures, and monitoring systems to ensure database reliability and minimize downtime in critical applications.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "Database Failure Modes", + "url": "https://ieeexplore.ieee.org/document/7107294/", + "type": "article" + } + ] }, "rq_y_OBMD9AH_4aoecvAi": { "title": "Transactions", @@ -921,7 +944,7 @@ "description": "Data replication is the process of creating and maintaining multiple copies of the same data across different locations or nodes in a distributed system. It enhances data availability, reliability, and performance by ensuring that data remains accessible even if one or more nodes fail. Replication can be synchronous (changes are applied to all copies simultaneously) or asynchronous (changes are propagated after being applied to the primary copy). It's widely used in database systems, content delivery networks, and distributed file systems. Replication strategies include master-slave, multi-master, and peer-to-peer models. While improving fault tolerance and read performance, replication introduces challenges in maintaining data consistency across copies and managing potential conflicts. Effective replication strategies must balance consistency, availability, and partition tolerance, often in line with the principles of the CAP theorem.\n\nVisit the following resources to learn more:", "links": [ { - "title": "What is data replication?", + "title": "Data Replication? - IBM", "url": "https://www.ibm.com/topics/data-replication", "type": "article" }, @@ -984,7 +1007,7 @@ "description": "JSON or JavaScript Object Notation is an encoding scheme that is designed to eliminate the need for an ad-hoc code for each application to communicate with servers that communicate in a defined way. JSON API module exposes an implementation for data stores and data structures, such as entity types, bundles, and fields.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "JSON API", "url": "https://jsonapi.org/", "type": "article" }, @@ -1014,15 +1037,15 @@ "url": "https://swagger.io/tools/swagger-editor/", "type": "article" }, - { - "title": " REST API and OpenAPI: It’s Not an Either/Or Question ", - "url": "https://www.youtube.com/watch?v=pRS9LRBgjYg", - "type": "article" - }, { "title": "OpenAPI 3.0: How to Design and Document APIs with the Latest OpenAPI Specification 3.0", "url": "https://www.youtube.com/watch?v=6kwmW_p_Tig", "type": "video" + }, + { + "title": " REST API and OpenAPI: It’s Not an Either/Or Question", + "url": "https://www.youtube.com/watch?v=pRS9LRBgjYg", + "type": "video" } ] }, @@ -1109,7 +1132,7 @@ "type": "article" }, { - "title": "GraphQL Official Website", + "title": "GraphQL", "url": "https://graphql.org/", "type": "article" }, @@ -1130,7 +1153,7 @@ "description": "Client-side caching is a technique where web browsers or applications store data locally on the user's device to improve performance and reduce server load. It involves saving copies of web pages, images, scripts, and other resources on the client's system for faster access on subsequent visits. Modern browsers implement various caching mechanisms, including HTTP caching (using headers like Cache-Control and ETag), service workers for offline functionality, and local storage APIs. Client-side caching significantly reduces network traffic and load times, enhancing user experience, especially on slower connections. However, it requires careful management to balance improved performance with the need for up-to-date content. Developers must implement appropriate cache invalidation strategies and consider cache-busting techniques for critical updates. Effective client-side caching is crucial for creating responsive, efficient web applications while minimizing server resource usage.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Client-side Caching", + "title": "Client Side Caching", "url": "https://redis.io/docs/latest/develop/use/client-side-caching/", "type": "article" }, @@ -1143,13 +1166,18 @@ }, "Nq2BO53bHJdFT1rGZPjYx": { "title": "CDN", - "description": "A Content Delivery Network (CDN) service aims to provide high availability and performance improvements of websites. This is achieved with fast delivery of website assets and content typically via geographically closer endpoints to the client requests. Traditional commercial CDNs (Amazon CloudFront, Akamai, CloudFlare and Fastly) provide servers across the globe which can be used for this purpose. Serving assets and contents via a CDN reduces bandwidth on website hosting, provides an extra layer of caching to reduce potential outages and can improve website security as well\n\nVisit the following resources to learn more:", + "description": "A Content Delivery Network (CDN) service aims to provide high availability and performance improvements of websites. This is achieved with fast delivery of website assets and content typically via geographically closer endpoints to the client requests.\n\nTraditional commercial CDNs (Amazon CloudFront, Akamai, CloudFlare and Fastly) provide servers across the globe which can be used for this purpose. Serving assets and contents via a CDN reduces bandwidth on website hosting, provides an extra layer of caching to reduce potential outages and can improve website security as well\n\nVisit the following resources to learn more:", "links": [ { "title": "CloudFlare - What is a CDN? | How do CDNs work?", "url": "https://www.cloudflare.com/en-ca/learning/cdn/what-is-a-cdn/", "type": "article" }, + { + "title": "AWS - CDN", + "url": "https://aws.amazon.com/what-is/cdn/", + "type": "article" + }, { "title": "What is Cloud CDN?", "url": "https://www.youtube.com/watch?v=841kyd_mfH0", @@ -1190,8 +1218,19 @@ }, "ELj8af7Mi38kUbaPJfCUR": { "title": "Caching", - "description": "Caching is a technique used in computing to store and retrieve frequently accessed data quickly, reducing the need to fetch it from the original, slower source repeatedly. It involves keeping a copy of data in a location that's faster to access than its primary storage. Caching can occur at various levels, including browser caching, application-level caching, and database caching. It significantly improves performance by reducing latency, decreasing network traffic, and lowering the load on servers or databases. Common caching strategies include time-based expiration, least recently used (LRU) algorithms, and write-through or write-back policies. While caching enhances speed and efficiency, it also introduces challenges in maintaining data consistency and freshness. Effective cache management is crucial in balancing performance gains with the need for up-to-date information in dynamic systems.", - "links": [] + "description": "Caching is a technique used in computing to store and retrieve frequently accessed data quickly, reducing the need to fetch it from the original, slower source repeatedly. It involves keeping a copy of data in a location that's faster to access than its primary storage. Caching can occur at various levels, including browser caching, application-level caching, and database caching. It significantly improves performance by reducing latency, decreasing network traffic, and lowering the load on servers or databases. Common caching strategies include time-based expiration, least recently used (LRU) algorithms, and write-through or write-back policies. While caching enhances speed and efficiency, it also introduces challenges in maintaining data consistency and freshness. Effective cache management is crucial in balancing performance gains with the need for up-to-date information in dynamic systems.\n\nVisit the following resources to learn more:", + "links": [ + { + "title": "What is Caching - AWS", + "url": "https://aws.amazon.com/caching/", + "type": "article" + }, + { + "title": "Caching - Cloudflare", + "url": "https://www.cloudflare.com/learning/cdn/what-is-caching/", + "type": "article" + } + ] }, "RBrIP5KbVQ2F0ly7kMfTo": { "title": "Web Security", @@ -1333,7 +1372,7 @@ "type": "article" }, { - "title": "DevOps CI/CD Explained in 100 Seconds by Fireship", + "title": "DevOps CI/CD Explained in 100 Seconds", "url": "https://www.youtube.com/watch?v=scEDHsr3APg", "type": "video" }, @@ -1581,7 +1620,7 @@ }, "8DmabQJXlrT__COZrDVTV": { "title": "Twelve Factor Apps", - "description": "The Twelve-Factor App methodology is a set of principles for building modern, scalable, and maintainable web applications, particularly suited for cloud environments. It emphasizes best practices for developing applications in a way that facilitates portability, scalability, and ease of deployment. Key principles include:\n\n1. **Codebase**: One codebase tracked in version control, with many deploys.\n2. **Dependencies**: Explicitly declare and isolate dependencies.\n3. **Config**: Store configuration in the environment.\n4. **Backing Services**: Treat backing services as attached resources.\n5. **Build, Release, Run**: Separate build and run stages.\n6. **Processes**: Execute the app as one or more stateless processes.\n7. **Port Binding**: Export services via port binding.\n8. **Concurrency**: Scale out via the process model.\n9. **Disposability**: Maximize robustness with fast startup and graceful shutdown.\n10. **Dev/Prod Parity**: Keep development, staging, and production environments as similar as possible.\n11. **Logs**: Treat logs as streams of events.\n12. **Admin Processes**: Run administrative or management tasks as one-off processes.\n\nThese principles help create applications that are easy to deploy, manage, and scale in cloud environments, promoting operational simplicity and consistency.\n\nVisit the following resources to learn more:", + "description": "The Twelve-Factor App methodology is a set of principles for building modern, scalable, and maintainable web applications, particularly suited for cloud environments. It emphasizes best practices for developing applications in a way that facilitates portability, scalability, and ease of deployment. Key principles include:\n\n1. **Codebase**: One codebase tracked in version control, with many deploys.\n2. **Dependencies**: Explicitly declare and isolate dependencies.\n3. **Config**: Store configuration in the environment.\n4. **Backing Services**: Treat backing services as attached resources.\n5. **Build, Release, Run**: Separate build and run stages.\n6. **Processes**: Execute the app as one or more stateless processes.\n7. **Port Binding**: Export services via port binding.\n8. **Concurrency**: Scale out via the process model.\n9. **Disposability**: Maximize robustness with fast startup and graceful shutdown.\n10. **Dev/Prod Parity**: Keep development, staging, and production environments as similar as possible.\n11. **Logs**: Treat logs as streams of events.\n12. **Admin Processes**: Run administrative or management tasks as one-off processes.\n\nVisit the following resources to learn more:", "links": [ { "title": "The Twelve-Factor App", @@ -1647,7 +1686,7 @@ "description": "Apache Kafka is a distributed event streaming platform designed for high-throughput, fault-tolerant data processing. It acts as a message broker, allowing systems to publish and subscribe to streams of records, similar to a distributed commit log. Kafka is highly scalable and can handle large volumes of data with low latency, making it ideal for real-time analytics, log aggregation, and data integration. It features topics for organizing data streams, partitions for parallel processing, and replication for fault tolerance, enabling reliable and efficient handling of large-scale data flows across distributed systems.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Apache Kafka quickstart", + "title": "Apache Kafka", "url": "https://kafka.apache.org/quickstart", "type": "article" }, @@ -1704,12 +1743,12 @@ "type": "article" }, { - "title": "Getting started with LXD Containerization", + "title": "Getting Started with LXD Containerization", "url": "https://www.youtube.com/watch?v=aIwgPKkVj8s", "type": "video" }, { - "title": "Getting started with LXC containers", + "title": "Getting Started with LXC containers", "url": "https://youtu.be/CWmkSj_B-wo", "type": "video" } @@ -1767,7 +1806,7 @@ "description": "Server-Sent Events (SSE) is a technology for sending real-time updates from a server to a web client over a single, persistent HTTP connection. It enables servers to push updates to clients efficiently and automatically reconnects if the connection is lost. SSE is ideal for applications needing one-way communication, such as live notifications or real-time data feeds, and uses a simple text-based format for transmitting event data, which can be easily handled by clients using the `EventSource` API in JavaScript.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Server-Sent Events - MDN", + "title": "Server Sent Events - MDN", "url": "https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events", "type": "article" }, @@ -1783,7 +1822,7 @@ "description": "Nginx is a high-performance, open-source web server and reverse proxy server known for its efficiency, scalability, and low resource consumption. Originally developed as a web server, Nginx is also commonly used as a load balancer, HTTP cache, and mail proxy. It excels at handling a large number of concurrent connections due to its asynchronous, event-driven architecture. Nginx's features include support for serving static content, handling dynamic content through proxying to application servers, and providing SSL/TLS termination. Its modular design allows for extensive customization and integration with various applications and services, making it a popular choice for modern web infrastructures.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Nginx Website", "url": "https://nginx.org/", "type": "article" }, @@ -1809,7 +1848,7 @@ "description": "Caddy is a modern, open-source web server written in Go. It's known for its simplicity, automatic HTTPS encryption, and HTTP/2 support out of the box. Caddy stands out for its ease of use, with a simple configuration syntax and the ability to serve static files with zero configuration. It automatically obtains and renews SSL/TLS certificates from Let's Encrypt, making secure deployments straightforward. Caddy supports various plugins and modules for extended functionality, including reverse proxying, load balancing, and dynamic virtual hosting. It's designed with security in mind, implementing modern web standards by default. While it may not match the raw performance of servers like Nginx in extremely high-load scenarios, Caddy's simplicity, built-in security features, and low resource usage make it an attractive choice for many web hosting needs, particularly for smaller to medium-sized projects or developers seeking a hassle-free server setup.\n\nVisit the following resources to learn more:", "links": [ { - "title": "caddyserver/caddy", + "title": "caddyserver/caddy - Caddy on GitHub", "url": "https://github.com/caddyserver/caddy", "type": "opensource" }, @@ -1856,7 +1895,7 @@ "description": "Microsoft Internet Information Services (IIS) is a flexible, secure, and high-performance web server developed by Microsoft for hosting and managing web applications and services on Windows Server. IIS supports a variety of web technologies, including [ASP.NET](http://ASP.NET), PHP, and static content. It provides features such as request handling, authentication, SSL/TLS encryption, and URL rewriting. IIS also offers robust management tools, including a graphical user interface and command-line options, for configuring and monitoring web sites and applications. It is commonly used for deploying enterprise web applications and services in a Windows-based environment, offering integration with other Microsoft technologies and services.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "Microsoft -IIS", "url": "https://www.iis.net/", "type": "article" }, @@ -1942,7 +1981,7 @@ }, "xPvVwGQw28uMeLYIWn8yn": { "title": "Memcached", - "description": "Memcached (pronounced variously mem-cash-dee or mem-cashed) is a general-purpose distributed memory-caching system. It is often used to speed up dynamic database-driven websites by caching data and objects in RAM to reduce the number of times an external data source (such as a database or API) must be read. Memcached is free and open-source software, licensed under the Revised BSD license. Memcached runs on Unix-like operating systems (Linux and macOS) and on Microsoft Windows. It depends on the `libevent` library. Memcached's APIs provide a very large hash table distributed across multiple machines. When the table is full, subsequent inserts cause older data to be purged in the least recently used (LRU) order. Applications using Memcached typically layer requests and additions into RAM before falling back on a slower backing store, such as a database.\n\nMemcached has no internal mechanism to track misses which may happen. However, some third-party utilities provide this functionality.\n\nVisit the following resources to learn more:", + "description": "Memcached (pronounced variously mem-cash-dee or mem-cashed) is a general-purpose distributed memory-caching system. It is often used to speed up dynamic database-driven websites by caching data and objects in RAM to reduce the number of times an external data source (such as a database or API) must be read. Memcached is free and open-source software, licensed under the Revised BSD license. Memcached runs on Unix-like operating systems (Linux and macOS) and on Microsoft Windows. It depends on the `libevent` library. Memcached's APIs provide a very large hash table distributed across multiple machines. When the table is full, subsequent inserts cause older data to be purged in the least recently used (LRU) order. Applications using Memcached typically layer requests and additions into RAM before falling back on a slower backing store, such as a database.\n\nVisit the following resources to learn more:", "links": [ { "title": "memcached/memcached", @@ -2091,7 +2130,7 @@ "type": "article" }, { - "title": "Backpressure explained — the resisted flow of data through software", + "title": "Backpressure explained — The Resisted Flow of Data through Software", "url": "https://medium.com/@jayphelps/backpressure-explained-the-flow-of-data-through-software-2350b3e77ce7", "type": "article" }, @@ -2136,7 +2175,7 @@ }, "f7iWBkC0X7yyCoP_YubVd": { "title": "Migration Strategies", - "description": "Migration strategies involve planning and executing the transition of applications, data, or infrastructure from one environment to another, such as from on-premises systems to the cloud or between different cloud providers. Key strategies include:\n\n1. **Rehost (Lift and Shift)**: Moving applications as-is to the new environment with minimal changes, which is often the quickest but may not fully leverage new platform benefits.\n2. **Replatform**: Making some optimizations or changes to adapt applications for the new environment, enhancing performance or scalability while retaining most of the existing architecture.\n3. **Refactor**: Redesigning and modifying applications to optimize for the new environment, often taking advantage of new features and improving functionality or performance.\n4. **Repurchase**: Replacing existing applications with new, often cloud-based, solutions that better meet current needs.\n5. **Retain**: Keeping certain applications or systems in their current environment due to specific constraints or requirements.\n6. **Retire**: Decommissioning applications that are no longer needed or are redundant.\n\nEach strategy has its own trade-offs in terms of cost, complexity, and benefits, and the choice depends on factors like the application’s architecture, business needs, and resource availability.\n\nVisit the following resources to learn more:", + "description": "Migration strategies involve planning and executing the transition of applications, data, or infrastructure from one environment to another, such as from on-premises systems to the cloud or between different cloud providers. Key strategies include:\n\n1. **Rehost (Lift and Shift)**: Moving applications as-is to the new environment with minimal changes, which is often the quickest but may not fully leverage new platform benefits.\n2. **Replatform**: Making some optimizations or changes to adapt applications for the new environment, enhancing performance or scalability while retaining most of the existing architecture.\n3. **Refactor**: Redesigning and modifying applications to optimize for the new environment, often taking advantage of new features and improving functionality or performance.\n4. **Repurchase**: Replacing existing applications with new, often cloud-based, solutions that better meet current needs.\n5. **Retain**: Keeping certain applications or systems in their current environment due to specific constraints or requirements.\n6. **Retire**: Decommissioning applications that are no longer needed or are redundant.\n\nVisit the following resources to learn more:", "links": [ { "title": "Databases as a Challenge for Continuous Delivery", @@ -2152,7 +2191,7 @@ }, "osQlGGy38xMcKLtgZtWaZ": { "title": "Types of Scaling", - "description": "Horizontal scaling (scaling out/in) involves adding or removing instances of resources, such as servers or containers, to handle increased or decreased loads. It distributes the workload across multiple instances to improve performance and redundancy. This method enhances the system's capacity by expanding the number of nodes in a distributed system.\n\nVertical scaling (scaling up/down) involves increasing or decreasing the resources (CPU, memory, storage) of a single instance or server to handle more load or reduce capacity. This method improves performance by upgrading the existing hardware or virtual machine but has limits based on the maximum capacity of the individual resource.\n\nBoth approaches have their advantages: horizontal scaling offers better fault tolerance and flexibility, while vertical scaling is often simpler to implement but can be limited by the hardware constraints of a single machine.\n\nVisit the following resources to learn more:", + "description": "Horizontal scaling (scaling out/in) involves adding or removing instances of resources, such as servers or containers, to handle increased or decreased loads. It distributes the workload across multiple instances to improve performance and redundancy. This method enhances the system's capacity by expanding the number of nodes in a distributed system.\n\nVertical scaling (scaling up/down) involves increasing or decreasing the resources (CPU, memory, storage) of a single instance or server to handle more load or reduce capacity. This method improves performance by upgrading the existing hardware or virtual machine but has limits based on the maximum capacity of the individual resource.\n\nVisit the following resources to learn more:", "links": [ { "title": "Horizontal vs Vertical Scaling", @@ -2207,7 +2246,7 @@ "description": "Monitoring involves continuously observing and tracking the performance, availability, and health of systems, applications, and infrastructure. It typically includes collecting and analyzing metrics, logs, and events to ensure systems are operating within desired parameters. Monitoring helps detect anomalies, identify potential issues before they escalate, and provides insights into system behavior. It often involves tools and platforms that offer dashboards, alerts, and reporting features to facilitate real-time visibility and proactive management. Effective monitoring is crucial for maintaining system reliability, performance, and for supporting incident response and troubleshooting.\n\nA few popular tools are Grafana, Sentry, Mixpanel, NewRelic.", "links": [ { - "title": "Top monitoring tools 2024", + "title": "Top Monitoring Tools", "url": "https://thectoclub.com/tools/best-application-monitoring-software/", "type": "article" }, @@ -2307,9 +2346,9 @@ "description": "Bcrypt is a password-hashing function designed to securely hash passwords for storage in databases. Created by Niels Provos and David Mazières, it's based on the Blowfish cipher and incorporates a salt to protect against rainbow table attacks. Bcrypt's key feature is its adaptive nature, allowing for the adjustment of its cost factor to make it slower as computational power increases, thus maintaining resistance against brute-force attacks over time. It produces a fixed-size hash output, typically 60 characters long, which includes the salt and cost factor. Bcrypt is widely used in many programming languages and frameworks due to its security strength and relative ease of implementation. Its deliberate slowness in processing makes it particularly effective for password storage, where speed is not a priority but security is paramount.\n\nVisit the following resources to learn more:", "links": [ { - "title": "bcrypts npm package", + "title": "bcrypt", "url": "https://www.npmjs.com/package/bcrypt", - "type": "article" + "type": "opensource" }, { "title": "Understanding bcrypt", @@ -2429,7 +2468,7 @@ }, "TZ0BWOENPv6pQm8qYB8Ow": { "title": "Server Security", - "description": "Server security involves protecting servers from threats and vulnerabilities to ensure the confidentiality, integrity, and availability of the data and services they manage. Key practices include:\n\n1. **Patch Management**: Regularly updating software and operating systems to fix vulnerabilities.\n2. **Access Control**: Implementing strong authentication mechanisms and restricting access to authorized users only.\n3. **Firewalls and Intrusion Detection**: Using firewalls to block unauthorized access and intrusion detection systems to monitor and respond to suspicious activities.\n4. **Encryption**: Encrypting data both in transit and at rest to protect sensitive information from unauthorized access.\n5. **Security Hardening**: Configuring servers with minimal services and features, applying security best practices to reduce the attack surface.\n6. **Regular Backups**: Performing regular backups to ensure data can be restored in case of loss or corruption.\n7. **Monitoring and Logging**: Continuously monitoring server activity and maintaining logs for auditing and detecting potential security incidents.\n\nEffective server security is crucial for safeguarding against attacks, maintaining system stability, and protecting sensitive data.\n\nLearn more from the following resources:", + "description": "Server security involves protecting servers from threats and vulnerabilities to ensure the confidentiality, integrity, and availability of the data and services they manage. Key practices include:\n\n1. **Patch Management**: Regularly updating software and operating systems to fix vulnerabilities.\n2. **Access Control**: Implementing strong authentication mechanisms and restricting access to authorized users only.\n3. **Firewalls and Intrusion Detection**: Using firewalls to block unauthorized access and intrusion detection systems to monitor and respond to suspicious activities.\n4. **Encryption**: Encrypting data both in transit and at rest to protect sensitive information from unauthorized access.\n5. **Security Hardening**: Configuring servers with minimal services and features, applying security best practices to reduce the attack surface.\n6. **Regular Backups**: Performing regular backups to ensure data can be restored in case of loss or corruption.\n7. **Monitoring and Logging**: Continuously monitoring server activity and maintaining logs for auditing and detecting potential security incidents.\n\nLearn more from the following resources:", "links": [ { "title": "What is a hardened server?", @@ -2600,7 +2639,7 @@ }, "hkxw9jPGYphmjhTjw8766": { "title": "DNS and how it works?", - "description": "DNS (Domain Name System) is a hierarchical, decentralized naming system for computers, services, or other resources connected to the Internet or a private network. It translates human-readable domain names (like [www.example.com](http://www.example.com)) into IP addresses (like 192.0.2.1) that computers use to identify each other. DNS servers distributed worldwide work together to resolve these queries, forming a global directory service. The system uses a tree-like structure with root servers at the top, followed by top-level domain servers (.com, .org, etc.), authoritative name servers for specific domains, and local DNS servers. DNS is crucial for the functioning of the Internet, enabling users to access websites and services using memorable names instead of numerical IP addresses. It also supports email routing, service discovery, and other network protocols.\n\nVisit the following resources to learn more:", + "description": "DNS (Domain Name System) is a hierarchical, decentralized naming system for computers, services, or other resources connected to the Internet or a private network. It translates human-readable domain names (like `www.example.com`) into IP addresses (like 192.0.2.1) that computers use to identify each other. DNS servers distributed worldwide work together to resolve these queries, forming a global directory service. The system uses a tree-like structure with root servers at the top, followed by top-level domain servers (.com, .org, etc.), authoritative name servers for specific domains, and local DNS servers. DNS is crucial for the functioning of the Internet, enabling users to access websites and services using memorable names instead of numerical IP addresses. It also supports email routing, service discovery, and other network protocols.\n\nVisit the following resources to learn more:", "links": [ { "title": "What is DNS?", @@ -2811,7 +2850,7 @@ "description": "OpenID is an open standard for decentralized authentication that allows users to log in to multiple websites and applications using a single set of credentials, managed by an identity provider (IdP). It enables users to authenticate their identity through an external service, simplifying the login process and reducing the need for multiple usernames and passwords. OpenID typically works in conjunction with OAuth 2.0 for authorization, allowing users to grant access to their data while maintaining security. This approach enhances user convenience and streamlines identity management across various platforms.\n\nVisit the following resources to learn more:", "links": [ { - "title": "Official Website", + "title": "OpenID Website", "url": "https://openid.net/", "type": "article" }, @@ -2839,7 +2878,7 @@ }, "UCHtaePVxS-0kpqlYxbfC": { "title": "SAML", - "description": "Security Assertion Markup Language (SAML)\n-----------------------------------------\n\nSecurity Assertion Markup Language (SAML) is an XML-based framework used for single sign-on (SSO) and identity federation, enabling users to authenticate once and gain access to multiple applications or services. It allows for the exchange of authentication and authorization data between an identity provider (IdP) and a service provider (SP). SAML assertions are XML documents that contain user identity information and attributes, and are used to convey authentication credentials and permissions. By implementing SAML, organizations can streamline user management, enhance security through centralized authentication, and simplify the user experience by reducing the need for multiple logins across different systems.\n\nLearn more from the following resources:", + "description": "Security Assertion Markup Language (SAML) is an XML-based framework used for single sign-on (SSO) and identity federation, enabling users to authenticate once and gain access to multiple applications or services. It allows for the exchange of authentication and authorization data between an identity provider (IdP) and a service provider (SP). SAML assertions are XML documents that contain user identity information and attributes, and are used to convey authentication credentials and permissions. By implementing SAML, organizations can streamline user management, enhance security through centralized authentication, and simplify the user experience by reducing the need for multiple logins across different systems.\n\nLearn more from the following resources:", "links": [ { "title": "SAML Explained in Plain English", @@ -2884,17 +2923,17 @@ "description": "Solr is an open-source, highly scalable search platform built on Apache Lucene, designed for full-text search, faceted search, and real-time indexing. It provides powerful features for indexing and querying large volumes of data with high performance and relevance. Solr supports complex queries, distributed searching, and advanced text analysis, including tokenization and stemming. It offers features such as faceted search, highlighting, and geographic search, and is commonly used for building search engines and data retrieval systems in various applications, from e-commerce to content management.\n\nVisit the following resources to learn more:", "links": [ { - "title": "apache/solr", + "title": "Solr on Github", "url": "https://github.com/apache/solr", "type": "opensource" }, { - "title": "Official Website", + "title": "Solr Website", "url": "https://solr.apache.org/", "type": "article" }, { - "title": "Official Documentation", + "title": "Solr Documentation", "url": "https://solr.apache.org/resources.html#documentation", "type": "article" }, @@ -2910,7 +2949,7 @@ "description": "Real-time data refers to information that is processed and made available immediately or with minimal delay, allowing users or systems to react promptly to current conditions. This type of data is essential in applications requiring immediate updates and responses, such as financial trading platforms, online gaming, real-time analytics, and monitoring systems. Real-time data processing involves capturing, analyzing, and delivering information as it is generated, often using technologies like stream processing frameworks (e.g., Apache Kafka, Apache Flink) and low-latency databases. Effective real-time data systems can handle high-speed data flows, ensuring timely and accurate decision-making.\n\nLearn more from the following resources:", "links": [ { - "title": "Real-time data - Wiki", + "title": "Real-time Data - Wiki", "url": "https://en.wikipedia.org/wiki/Real-time_data", "type": "article" }, @@ -2942,7 +2981,7 @@ "description": "Short polling is a technique where a client periodically sends requests to a server at regular intervals to check for updates or new data. The server responds with the current state or any changes since the last request. While simple to implement and compatible with most HTTP infrastructures, short polling can be inefficient due to the frequent network requests and potential for increased latency in delivering updates. It contrasts with long polling and WebSockets, which offer more efficient mechanisms for real-time communication. Short polling is often used when real-time requirements are less stringent and ease of implementation is a priority.\n\nLearn more from the following resources:", "links": [ { - "title": "Amazon SQS short and long polling", + "title": "Amazon SQS Short and Long Polling", "url": "https://docs.aws.amazon.com/AWSSimpleQueueService/latest/SQSDeveloperGuide/sqs-short-and-long-polling.html", "type": "article" }, @@ -2984,7 +3023,7 @@ "description": "Amazon DynamoDB is a fully managed, serverless NoSQL database service provided by Amazon Web Services (AWS). It offers high-performance, scalable, and flexible data storage for applications of any scale. DynamoDB supports both key-value and document data models, providing fast and predictable performance with seamless scalability. It features automatic scaling, built-in security, backup and restore options, and global tables for multi-region deployment. DynamoDB excels in handling high-traffic web applications, gaming backends, mobile apps, and IoT solutions. It offers consistent single-digit millisecond latency at any scale and supports both strongly consistent and eventually consistent read models. With its integration into the AWS ecosystem, on-demand capacity mode, and support for transactions, DynamoDB is widely used for building highly responsive and scalable applications, particularly those with unpredictable workloads or requiring low-latency data access.\n\nLearn more from the following resources:", "links": [ { - "title": "AWS DynamoDB Website", + "title": "AWS DynamoDB", "url": "https://aws.amazon.com/dynamodb/", "type": "article" }, @@ -3002,10 +3041,10 @@ }, "RyJFLLGieJ8Xjt-DlIayM": { "title": "Firebase", - "description": "Firebase is a comprehensive mobile and web application development platform owned by Google. It provides a suite of cloud-based services that simplify app development, hosting, and scaling. Key features include real-time database, cloud storage, authentication, hosting, cloud functions, and analytics. Firebase offers real-time synchronization, allowing data to be updated across clients instantly. Its authentication service supports multiple providers, including email/password, social media logins, and phone authentication. The platform's serverless architecture enables developers to focus on front-end development without managing backend infrastructure. Firebase also provides tools for app testing, crash reporting, and performance monitoring. While it excels in rapid prototyping and building real-time applications, its proprietary nature and potential for vendor lock-in are considerations for large-scale or complex applications. Firebase's ease of use and integration with Google Cloud Platform make it popular for startups and projects requiring quick deployment.\n\nLearn more from the following resources:", + "description": "Firebase is a comprehensive mobile and web application development platform owned by Google. It provides a suite of cloud-based services that simplify app development, hosting, and scaling. Key features include real-time database, cloud storage, authentication, hosting, cloud functions, and analytics. Firebase offers real-time synchronization, allowing data to be updated across clients instantly. Its authentication service supports multiple providers, including email/password, social media logins, and phone authentication. The platform's serverless architecture enables developers to focus on front-end development without managing backend infrastructure. Firebase also provides tools for app testing, crash reporting, and performance monitoring.\n\nLearn more from the following resources:", "links": [ { - "title": "The ultimate guide to Firebase", + "title": "The Ultimate Guide to Firebase", "url": "https://fireship.io/lessons/the-ultimate-beginners-guide-to-firebase/", "type": "course" }, @@ -3042,7 +3081,7 @@ "description": "SQLite is a lightweight, serverless, self-contained SQL database engine that is designed for simplicity and efficiency. It is widely used in embedded systems and applications where a full-featured database server is not required, such as mobile apps, desktop applications, and small to medium-sized websites. SQLite stores data in a single file, which makes it easy to deploy and manage. It supports standard SQL queries and provides ACID (Atomicity, Consistency, Isolation, Durability) compliance to ensure data integrity. SQLite’s small footprint, minimal configuration, and ease of use make it a popular choice for applications needing a compact, high-performance database solution.\n\nVisit the following resources to learn more:", "links": [ { - "title": "SQLite website", + "title": "SQLite", "url": "https://www.sqlite.org/index.html", "type": "article" }, @@ -3104,7 +3143,7 @@ "type": "video" }, { - "title": "What is time series data?", + "title": "What is Time Series Data?", "url": "https://www.youtube.com/watch?v=Se5ipte9DMY", "type": "video" } @@ -3209,7 +3248,7 @@ "description": "Database migrations are a version-controlled way to manage and apply incremental changes to a database schema over time, allowing developers to modify the database structure (e.g., adding tables, altering columns) without affecting existing data. They ensure that the database evolves alongside application code in a consistent, repeatable manner across environments (e.g., development, testing, production), while maintaining compatibility with older versions of the schema. Migrations are typically written in SQL or a database-agnostic language, and are executed using migration tools like Liquibase, Flyway, or built-in ORM features such as Django or Rails migrations.\n\nLearn more from the following resources:", "links": [ { - "title": "What are database migrations?", + "title": "What are Database Migrations?", "url": "https://www.prisma.io/dataguide/types/relational/what-are-database-migrations", "type": "article" }, diff --git a/public/roadmap-content/computer-science.json b/public/roadmap-content/computer-science.json index 9feb7b55c..853fd0649 100644 --- a/public/roadmap-content/computer-science.json +++ b/public/roadmap-content/computer-science.json @@ -372,16 +372,6 @@ "url": "https://www.coursera.org/lecture/data-structures/doubly-linked-lists-jpGKD", "type": "course" }, - { - "title": "CS 61B Lecture 7: Linked Lists I", - "url": "https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0", - "type": "article" - }, - { - "title": "CS 61B Lecture 7: Linked Lists II", - "url": "https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w", - "type": "article" - }, { "title": "Linked List Data Structure | Illustrated Data Structures", "url": "https://www.youtube.com/watch?v=odW9FU8jPRQ", @@ -392,6 +382,16 @@ "url": "https://www.youtube.com/watch?v=F8AbOfQwl1c", "type": "video" }, + { + "title": "CS 61B Lecture 7: Linked Lists I", + "url": "https://archive.org/details/ucberkeley_webcast_htzJdKoEmO0", + "type": "video" + }, + { + "title": "CS 61B Lecture 7: Linked Lists II", + "url": "https://archive.org/details/ucberkeley_webcast_-c4I3gFYe3w", + "type": "video" + }, { "title": "Why you should avoid Linked Lists?", "url": "https://www.youtube.com/watch?v=YQs6IC-vgmo", @@ -511,16 +511,16 @@ "url": "https://www.coursera.org/lecture/data-structures/dynamic-arrays-EwbnV", "type": "course" }, - { - "title": "UC Berkeley CS61B - Linear and Multi-Dim Arrays (Start watching from 15m 32s)", - "url": "https://archive.org/details/ucberkeley_webcast_Wp8oiO_CZZE", - "type": "article" - }, { "title": "Array Data Structure | Illustrated Data Structures", "url": "https://www.youtube.com/watch?v=QJNwK2uJyGs", "type": "video" }, + { + "title": "UC Berkeley CS61B - Linear and Multi-Dim Arrays (Start watching from 15m 32s)", + "url": "https://archive.org/details/ucberkeley_webcast_Wp8oiO_CZZE", + "type": "video" + }, { "title": "Dynamic and Static Arrays", "url": "https://www.youtube.com/watch?v=PEnFFiQe1pM&list=PLDV1Zeh2NRsB6SWUrDFW2RmDotAfPbeHu&index=6", diff --git a/public/roadmap-content/ios.json b/public/roadmap-content/ios.json index 5740a70d7..013b936fe 100644 --- a/public/roadmap-content/ios.json +++ b/public/roadmap-content/ios.json @@ -112,8 +112,29 @@ }, "IduGSdUa2Fi7VFMLKgmsS": { "title": "iOS Architecture", - "description": "", - "links": [] + "description": "iOS architecture refers to the design principles and patterns used to build iOS applications. It focuses on how to structure code, manage data, and ensure a smooth user experience. These architectural patterns help developers create maintainable, scalable, and testable applications while following best practices specific to iOS development. Use cases of these architectures may vary according to the requirements of the application. For example, MVC is used for simple apps, while MVVM is considered when the app is large and complex.\n\nLearn more from the following resources:", + "links": [ + { + "title": "Model-View-Controller Pattern in swift (MVC) for Beginners", + "url": "https://ahmedaminhassanismail.medium.com/model-view-controller-pattern-in-swift-mvc-for-beginners-35db8d479832", + "type": "article" + }, + { + "title": "MVVM in iOS Swift", + "url": "https://medium.com/@zebayasmeen76/mvvm-in-ios-swift-6afb150458fd", + "type": "article" + }, + { + "title": "MVC Design Pattern Explained with Example", + "url": "https://youtu.be/sbYaWJEAYIY?t=2", + "type": "video" + }, + { + "title": "MVVM Design Pattern Explained with Example", + "url": "https://www.youtube.com/watch?v=sLHVxnRS75w", + "type": "video" + } + ] }, "IdGdLNgJI3WmONEFsMq-d": { "title": "Core OS", diff --git a/public/roadmap-content/software-architect.json b/public/roadmap-content/software-architect.json index f69ddf409..dbd6a246f 100644 --- a/public/roadmap-content/software-architect.json +++ b/public/roadmap-content/software-architect.json @@ -10,7 +10,7 @@ "links": [ { "title": "What is Software Architecture in Software Engineering?", - "url": "https://webcache.googleusercontent.com/search?q=cache:ya4xvYaEckQJ:https://www.future-processing.com/blog/what-is-software-architecture-in-software-engineering/&cd=1&hl=es-419&ct=clnk&gl=ar", + "url": "https://www.future-processing.com/blog/what-is-software-architecture-in-software-engineering/", "type": "article" }, { diff --git a/public/roadmap-content/typescript.json b/public/roadmap-content/typescript.json index ab7959af0..3c270773c 100644 --- a/public/roadmap-content/typescript.json +++ b/public/roadmap-content/typescript.json @@ -401,7 +401,7 @@ }, "HD1UGOidp7JGKdW6CEdQ_": { "title": "satisfies keyword", - "description": "TypeScript developers are often faced with a dilemma: we want to ensure that some expression matches some type, but also want to keep the most specific type of that expression for inference purposes.\n\nFor example:\n\n // Each property can be a string or an RGB tuple.\n const palette = {\n red: [255, 0, 0],\n green: '#00ff00',\n bleu: [0, 0, 255],\n // ^^^^ sacrebleu - we've made a typo!\n };\n \n // We want to be able to use array methods on 'red'...\n const redComponent = palette.red.at(0);\n \n // or string methods on 'green'...\n const greenNormalized = palette.green.toUpperCase();\n \n\nNotice that we’ve written `bleu`, whereas we probably should have written `blue`. We could try to catch that `bleu` typo by using a type annotation on palette, but we’d lose the information about each property.\n\n type Colors = 'red' | 'green' | 'blue';\n type RGB = [red: number, green: number, blue: number];\n \n const palette: Record = {\n red: [255, 0, 0],\n green: '#00ff00',\n bleu: [0, 0, 255],\n // ~~~~ The typo is now correctly detected\n };\n // But we now have an undesirable error here - 'palette.red' \"could\" be a string.\n const redComponent = palette.red.at(0);\n \n\nThe `satisfies` operator lets us validate that the type of an expression matches some type, without changing the resulting type of that expression. As an example, we could use `satisfies` to validate that all the properties of palette are compatible with `string | number[]`:\n\n type Colors = 'red' | 'green' | 'blue';\n type RGB = [red: number, green: number, blue: number];\n \n const palette = {\n red: [255, 0, 0],\n green: '#00ff00',\n bleu: [0, 0, 255],\n // ~~~~ The typo is now caught!\n } satisfies Record;\n \n // Both of these methods are still accessible!\n const redComponent = palette.red.at(0);\n const greenNormalized = palette.green.toUpperCase();\n \n\nLearn more from the following resources:", + "description": "The `satisfies` operator lets us validate that the type of an expression matches some type, without changing the resulting type of that expression.\n\nLearn more from the following resources:", "links": [ { "title": "satisfies Keyword",