Fimple

fimple

Implementing the Blocked Floyd-Warshall Algorithm for Solving All-pairs Shortest Path Problem in C#

Heap Sort Algorithm: Your Complete Implementation Guide

Digital Transformations Methodology - When Agile Can Fall Short in Cloud Procurement While agile methodology has revolutionized product/technology development and project management, it’s not always the perfect fit for cloud or SaaS solution implementations. Agile offers flexibility, quick iterations, and adaptability, which are critical in many IT projects. However, the nature of cloud migrations or implementations can sometimes conflict with Agile's principles, posing challenges that require careful consideration. Complexities of Cloud Solutions Cloud solutions in procurement, especially large-scale implementations, involve careful process design and integration with existing legacy systems. These projects require careful planning and alignment with long-term organizational goals. Agile’s emphasis on iterative sprints can sometimes lead to fragmented or misaligned outcomes in these complex environments. For instance, procurement transformations require upfront technical architectural decisions, including integration landscape and compliance standards, which can’t be easily changed in small iterative cycles. Without the appropriate planning phase, organizations may find themselves dealing with significant rework, leading to delays and increased costs. Catering to Business and Industry Requirements Cloud procurement implementations often involve multiple stakeholders from different areas of the organization such as finance, accounting, and IT, in addition to supply chain teams -, each with distinct needs and expectations. The problem arises when these requirements aren’t fully defined at the outset. While agile champions flexibility and responsiveness, cloud solutions typically demand a deeper understanding of the end-to-end requirements before configuration starts. Without a comprehensive design of the functional and technical requirements and how they align with the business, agile teams may struggle to make informed decisions during sprints. This lack of clarity can result in missed objectives, scope creep, or misalignment with business goals. Integration with Legacy Systems One of the major challenges in cloud procurement implementations is integrating with boundary systems such as planning solutions, ERPs, or HR systems. The technical architecture needs to be well established prior to beginning the design and development of integrations. Legacy systems can also present roadblocks that Agile’s short-cycle approach isn’t well-equipped to handle. While agile works well in environments where all components are relatively new and flexible, legacy systems require careful mapping, data migration strategies, and detailed data mapping, which might not fit well within agile's fast-paced, iterative process. The Case for a Hybrid Approach Given these challenges, many organizations are opting for a hybrid approach that combines agile principles with a more traditional, structured project management methodology. This approach allows teams to maintain agile's flexibility in execution while ensuring that the foundational elements of the cloud solution—such as architecture, compliance, and system integration—are fully planned and mapped out before implementation begins. For instance, a hybrid approach may involve initial phases of waterfall-style planning for architecture, compliance, and other critical decisions, followed by agile sprints for more granular tasks like development, testing, and deployment. This enables teams to strike a balance between the adaptability of agile and the structured requirements of a complex cloud solution. Conclusion While agile methodology offers a powerful framework for many types of IT projects, it may not always be the best approach for cloud procurement implementations. The complexity, integration requirements, and regulatory considerations of cloud migrations often require more upfront planning and structured project management. By adopting a hybrid methodology, organizations can leverage the strengths of agile while mitigating the risks that come with applying it too rigidly to cloud solutions. Feel free to reach out for any questions on digital transformations of enterprise operations. Disclaimer: The views in this article are my own and do not represent my current or prior employers. Digital Transformations Methodology - When Agile Can Fall Short in Cloud Procurement Digital Transformations Methodology - When Agile Can Fall Short in Cloud Procurement While agile methodology has revolutionized product/technology development and project management, it’s not always the perfect fit for cloud or SaaS solution implementations. Agile offers flexibility, quick iterations, and adaptability, which are critical in many IT projects. However, the nature of cloud migrations or implementations can sometimes conflict with Agile's principles, posing challenges that require careful consideration. Complexities of Cloud Solutions Cloud solutions in procurement, especially large-scale implementations, involve careful process design and integration with existing legacy systems. These projects require careful planning and alignment with long-term organizational goals. Agile’s emphasis on iterative sprints can sometimes lead to fragmented or misaligned outcomes in these complex environments. For instance, procurement transformations require upfront technical architectural decisions, including integration landscape and compliance standards, which can’t be easily changed in small iterative cycles. Without the appropriate planning phase, organizations may find themselves dealing with significant rework, leading to delays and increased costs. Catering to Business and Industry Requirements Cloud procurement implementations often involve multiple stakeholders from different areas of the organization such as finance, accounting, and IT, in addition to supply chain teams -, each with distinct needs and expectations. The problem arises when these requirements aren’t fully defined at the outset. While agile champions flexibility and responsiveness, cloud solutions typically demand a deeper understanding of the end-to-end requirements before configuration starts. Without a comprehensive design of the functional and technical requirements and how they align with the business, agile teams may struggle to make informed decisions during sprints. This lack of clarity can result in missed objectives, scope creep, or misalignment with business goals. Integration with Legacy Systems One of the major challenges in cloud procurement implementations is integrating with boundary systems such as planning solutions, ERPs, or HR systems. The technical architecture needs to be well established prior to beginning the design and development of integrations. Legacy systems can also present roadblocks that Agile’s short-cycle approach isn’t well-equipped to handle. While agile works well in environments where all components are relatively new and flexible, legacy systems require careful mapping, data migration strategies, and detailed data mapping, which might not fit well within agile's fast-paced, iterative process. The Case for a Hybrid Approach Given these challenges, many organizations are opting for a hybrid approach that combines agile principles with a more traditional, structured project management methodology. This approach allows teams to maintain agile's flexibility in execution while ensuring that the foundational elements of the cloud solution—such as architecture, compliance, and system integration—are fully planned and mapped out before implementation begins. For instance, a hybrid approach may involve initial phases of waterfall-style planning for architecture, compliance, and other critical decisions, followed by agile sprints for more granular tasks like development, testing, and deployment. This enables teams to strike a balance between the adaptability of agile and the structured requirements of a complex cloud solution. Conclusion While agile methodology offers a powerful framework for many types of IT projects, it may not always be the best approach for cloud procurement implementations. The complexity, integration requirements, and regulatory considerations of cloud migrations often require more upfront planning and structured project management. By adopting a hybrid methodology, organizations can leverage the strengths of agile while mitigating the risks that come with applying it too rigidly to cloud solutions. Feel free to reach out for any questions on digital transformations of enterprise operations. Disclaimer: The views in this article are my own and do not represent my current or prior employers. Disclaimer: The views in this article are my own and do not represent my current or prior employers.

Challenges in Implementing Agile Methodology for Cloud Solutions

Traditional RAG systems work by indexing raw data. This data is simply chunked and stored in vector DBs. Whenever a query comes from the user, it queries the stored chunks and retrieves relevant chunks. If you wish to learn the fundamentals of RAG I have written a comprehensive intro about it here. As the retrieval step happens for every single query from the user, it is the most crucial bottleneck to speed up naive RAG systems. Would it not be logical to make the retrieval process super efficient? This is the promise of LightRAG. Why Not GraphRAG? Before we look at them, you may ask, “Wait. Do we not have GraphRAG from Microsoft?”. Yes, but GraphRAG seems to have a couple of drawbacks. Incremental knowledge update. (sec 3.1) GraphRAG first creates a reference to entities and relationships in the entire private dataset. It then does bottom-up clustering that organizes the data hierarchically into semantic clusters. An update to the dataset with new knowledge means that we have to go through the entire process of building the graph! LightRAG on the other hand addresses this by simply appending new knowledge to the existing one. More specifically, it combines new graph nodes and edges with existing ones through a simple union operation. Computational intensity. As seen from their study, LightRAG significantly reduces the cost of the retrieval phase. What takes 610,000 tokens for GraphRAG takes less than 100 tokens for LightRAG. So, without further adieu, let's dive into LightRAG. Visual Learning If you are a visual learner like me, why not check this YouTube video explaining the idea of LightRAG: https://youtu.be/5EmRZcJIfnw?si=UPhwRtxUUcZbTfRU&embedable=true LightRAG The two main selling points of LightRAG are Graph-based indexing and a dual-level retrieval framework. So, let's look into each of them. Graph-based Indexing Below are the steps LightRAG follows to incorporate graph-based indexing. Entity and Relationship (ER) extraction. ER extraction is shown by R(.) in the above figure. This step ensures that simple entities are first extracted from a given document. For example, in the above example, “bees” and “beekeeper” are two entities. And they are related by “observe” relation. As in, a beekeeper observes bees. Key-value (KV) pair generation using LLM. KV pairs are then generated using a simple LLM. The LLM profiling step gives a small note or explanation of what the entity or relation is all about. For example, the LLM explains who a “beekeeper” is in our chosen example. This step is denoted by the P(.) in the above figure. Note that this LLM is different from the general-purpose LLM used in the main RAG pipeline. Deduplication. Given that the documents have to do with bees, it is quite possible that the entity “beekeeper” could have been retrieved from several documents or chunks. So, we need a deduplication step that just keeps one and discards the rest with the same meaning. This is shown by the D(.) in the above figure. Dual-level Retrieval A query to a RAG system can be one of two types — specific or abstract. In the same bee example, a specific query could be “How many queen bees can be there in the hive?” An abstract query could be, “What are the implications of climate change on honey bees?” To address this diversity, LightRAG employs two retrieval types: Low-level retrieval. It simply extracts precise entities and their relationships like bees, observe, and beekeepers. High-level retrieval. Employing an LLM, LightRAG aggregates information and summarizes multiple sources of information. Why Bother Doing All This? Doing all this exercise and switching to LightRAG improves execution time indeed. During indexing, the LLM needs to be called just once per chunk to extract entities and their relationships. Likewise, during user query, we only retrieve entities and relationships from chunks using the same LLM we used for indexing. This is a huge saving on the retrieval overhead and hence computation. So, we have a “light” RAG at last! Integrating new knowledge into existing graphs seems to be a seamless exercise. Instead of re-indexing the whole data whenever we have new information, we can simply append new knowledge to the existing graph. Evaluation In their evaluations, they have compared against Naive RAG, RQ-RAG, HyDE, and GraphRAG. To keep the comparison fair, they have used GPT-4o-mini as the LLM across the board with a fixed chunk size of 1200 for all datasets. The answers were evaluated for comprehensiveness, diversity, and effectiveness in answering the user(a.k.a. empowerment in the paper). As we can see from the underlined results, LightRAG beats all of the state-of-the-art methods currently available. In general, they draw the following conclusions: Using graph-based methods (GraphRAG or LightRAG) improves significantly over the baseline Naive RAG. LightRAG produces quite diverse answers powered by the dual-level retrieval paradigm. LightRAG can deal with complex queries better Conclusion Though RAG is a fairly recent technique, we are seeing rapid progress in the area. Techniques like LightRAG which can take RAG pipelines to cheap commodity hardware are the most welcome. While the hardware landscape is ever-growing, there is always an increasing need to run LLMs and RAG pipelines in compute-constrained hardware in real time. Would you like to see some hands-on study of LightRAG? Please stay tuned… Traditional RAG systems work by indexing raw data. This data is simply chunked and stored in vector DBs. Whenever a query comes from the user, it queries the stored chunks and retrieves relevant chunks. If you wish to learn the fundamentals of RAG I have written a comprehensive intro about it here . retrieves here here As the retrieval step happens for every single query from the user, it is the most crucial bottleneck to speed up naive RAG systems. Would it not be logical to make the retrieval process super efficient? This is the promise of LightRAG . LightRAG Why Not GraphRAG? Before we look at them, you may ask, “Wait. Do we not have GraphRAG from Microsoft?”. Yes, but GraphRAG seems to have a couple of drawbacks. Incremental knowledge update. (sec 3.1) GraphRAG first creates a reference to entities and relationships in the entire private dataset. It then does bottom-up clustering that organizes the data hierarchically into semantic clusters. An update to the dataset with new knowledge means that we have to go through the entire process of building the graph! LightRAG on the other hand addresses this by simply appending new knowledge to the existing one. More specifically, it combines new graph nodes and edges with existing ones through a simple union operation. Incremental knowledge update. (sec 3.1) GraphRAG first creates a reference to entities and relationships in the entire private dataset. It then does bottom-up clustering that organizes the data hierarchically into semantic clusters. An update to the dataset with new knowledge means that we have to go through the entire process of building the graph! LightRAG on the other hand addresses this by simply appending new knowledge to the existing one. More specifically, it combines new graph nodes and edges with existing ones through a simple union operation. Incremental knowledge update. Computational intensity. As seen from their study, LightRAG significantly reduces the cost of the retrieval phase. What takes 610,000 tokens for GraphRAG takes less than 100 tokens for LightRAG. Computational intensity. As seen from their study, LightRAG significantly reduces the cost of the retrieval phase. What takes 610,000 tokens for GraphRAG takes less than 100 tokens for LightRAG. Computational intensity. So, without further adieu, let's dive into LightRAG. Visual Learning If you are a visual learner like me, why not check this YouTube video explaining the idea of LightRAG: https://youtu.be/5EmRZcJIfnw?si=UPhwRtxUUcZbTfRU&embedable=true https://youtu.be/5EmRZcJIfnw?si=UPhwRtxUUcZbTfRU&embedable=true LightRAG The two main selling points of LightRAG are Graph-based indexing and a dual-level retrieval framework. So, let's look into each of them. Graph-based Indexing Below are the steps LightRAG follows to incorporate graph-based indexing. Entity and Relationship (ER) extraction. ER extraction is shown by R(.) in the above figure. This step ensures that simple entities are first extracted from a given document. For example, in the above example, “bees” and “beekeeper” are two entities. And they are related by “observe” relation. As in, a beekeeper observes bees. Entity and Relationship (ER) extraction. ER extraction is shown by R(.) in the above figure. This step ensures that simple entities are first extracted from a given document. For example, in the above example, “bees” and “beekeeper” are two entities. And they are related by “observe” relation. As in, a beekeeper observes bees. Entity and Relationship (ER) extraction. Key-value (KV) pair generation using LLM. KV pairs are then generated using a simple LLM. The LLM profiling step gives a small note or explanation of what the entity or relation is all about. For example, the LLM explains who a “beekeeper” is in our chosen example. This step is denoted by the P(.) in the above figure. Note that this LLM is different from the general-purpose LLM used in the main RAG pipeline. Key-value (KV) pair generation using LLM. KV pairs are then generated using a simple LLM. The LLM profiling step gives a small note or explanation of what the entity or relation is all about. For example, the LLM explains who a “beekeeper” is in our chosen example. This step is denoted by the P(.) in the above figure. Note that this LLM is different from the general-purpose LLM used in the main RAG pipeline. Key-value (KV) pair generation using LLM. Deduplication. Given that the documents have to do with bees, it is quite possible that the entity “beekeeper” could have been retrieved from several documents or chunks. So, we need a deduplication step that just keeps one and discards the rest with the same meaning. This is shown by the D(.) in the above figure. Deduplication. Given that the documents have to do with bees, it is quite possible that the entity “beekeeper” could have been retrieved from several documents or chunks. So, we need a deduplication step that just keeps one and discards the rest with the same meaning. This is shown by the D(.) in the above figure. Deduplication. Dual-level Retrieval A query to a RAG system can be one of two types — specific or abstract. In the same bee example, a specific query could be “How many queen bees can be there in the hive?” An abstract query could be, “What are the implications of climate change on honey bees?” To address this diversity, LightRAG employs two retrieval types: Low-level retrieval. It simply extracts precise entities and their relationships like bees, observe, and beekeepers. Low-level retrieval. It simply extracts precise entities and their relationships like bees, observe, and beekeepers. Low-level retrieval. High-level retrieval. Employing an LLM, LightRAG aggregates information and summarizes multiple sources of information. High-level retrieval. Employing an LLM, LightRAG aggregates information and summarizes multiple sources of information. High-level retrieval. Why Bother Doing All This? Doing all this exercise and switching to LightRAG improves execution time indeed. During indexing, the LLM needs to be called just once per chunk to extract entities and their relationships. Likewise, during user query, we only retrieve entities and relationships from chunks using the same LLM we used for indexing. This is a huge saving on the retrieval overhead and hence computation. So, we have a “light” RAG at last! Integrating new knowledge into existing graphs seems to be a seamless exercise. Instead of re-indexing the whole data whenever we have new information, we can simply append new knowledge to the existing graph. Evaluation In their evaluations, they have compared against Naive RAG, RQ-RAG, HyDE, and GraphRAG. To keep the comparison fair, they have used GPT-4o-mini as the LLM across the board with a fixed chunk size of 1200 for all datasets. The answers were evaluated for comprehensiveness, diversity, and effectiveness in answering the user(a.k.a. empowerment in the paper). empowerment As we can see from the underlined results, LightRAG beats all of the state-of-the-art methods currently available. In general, they draw the following conclusions: Using graph-based methods (GraphRAG or LightRAG) improves significantly over the baseline Naive RAG. Using graph-based methods (GraphRAG or LightRAG) improves significantly over the baseline Naive RAG. LightRAG produces quite diverse answers powered by the dual-level retrieval paradigm. LightRAG produces quite diverse answers powered by the dual-level retrieval paradigm. LightRAG can deal with complex queries better LightRAG can deal with complex queries better Conclusion Though RAG is a fairly recent technique, we are seeing rapid progress in the area. Techniques like LightRAG which can take RAG pipelines to cheap commodity hardware are the most welcome. While the hardware landscape is ever-growing, there is always an increasing need to run LLMs and RAG pipelines in compute-constrained hardware in real time. Would you like to see some hands-on study of LightRAG? Please stay tuned…

LightRAG - Is It a Simple and Efficient Rival to GraphRAG?

Authors:
(1) Nora Schneider, Computer Science Department, ETH Zurich, Zurich, Switzerland (nschneide@student.ethz.ch);
(2) Shirin Goshtasbpour, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (shirin.goshtasbpour@inf.ethz.ch);
(3) Fernando Perez-Cruz, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (fernando.perezcruz@sdsc.ethz.ch). Table of Links Abstract and 1 Introduction 2 Background 2.1 Data Augmentation 2.2 Anchor Regression 3 Anchor Data Augmentation 3.1 Comparison to C-Mixup and 3.2 Preserving nonlinear data structure 3.3 Algorithm 4 Experiments and 4.1 Linear synthetic data 4.2 Housing nonlinear regression 4.3 In-distribution Generalization 4.4 Out-of-distribution Robustness 5 Conclusion, Broader Impact, and References A Additional information for Anchor Data Augmentation B Experiments 3.3 Algorithm Finally, in this section, we present the ADA algorithm step by step (Algorithm 1) to generate minibatches of data that can be used to train neural networks (or any other nonlinear regressor) by any stochastic gradient descent method. As discussed previously, we propose to repeat the augmentation with different parameter combinations for each minibatch. This paper is available on arxiv under CC0 1.0 DEED license. Authors: (1) Nora Schneider, Computer Science Department, ETH Zurich, Zurich, Switzerland (nschneide@student.ethz.ch); (2) Shirin Goshtasbpour, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (shirin.goshtasbpour@inf.ethz.ch); (3) Fernando Perez-Cruz, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (fernando.perezcruz@sdsc.ethz.ch). Authors: Authors: (1) Nora Schneider, Computer Science Department, ETH Zurich, Zurich, Switzerland (nschneide@student.ethz.ch); (2) Shirin Goshtasbpour, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (shirin.goshtasbpour@inf.ethz.ch); (3) Fernando Perez-Cruz, Computer Science Department, ETH Zurich, Zurich, Switzerland and Swiss Data Science Center, Zurich, Switzerland (fernando.perezcruz@sdsc.ethz.ch). Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Background 2.1 Data Augmentation 2.1 Data Augmentation 2.2 Anchor Regression 2.2 Anchor Regression 3 Anchor Data Augmentation 3 Anchor Data Augmentation 3.1 Comparison to C-Mixup and 3.2 Preserving nonlinear data structure 3.1 Comparison to C-Mixup and 3.2 Preserving nonlinear data structure 3.3 Algorithm 3.3 Algorithm 4 Experiments and 4.1 Linear synthetic data 4 Experiments and 4.1 Linear synthetic data 4.2 Housing nonlinear regression 4.2 Housing nonlinear regression 4.3 In-distribution Generalization 4.3 In-distribution Generalization 4.4 Out-of-distribution Robustness 4.4 Out-of-distribution Robustness 5 Conclusion, Broader Impact, and References 5 Conclusion, Broader Impact, and References A Additional information for Anchor Data Augmentation A Additional information for Anchor Data Augmentation B Experiments B Experiments 3.3 Algorithm Finally, in this section, we present the ADA algorithm step by step (Algorithm 1) to generate minibatches of data that can be used to train neural networks (or any other nonlinear regressor) by any stochastic gradient descent method. As discussed previously, we propose to repeat the augmentation with different parameter combinations for each minibatch. This paper is available on arxiv under CC0 1.0 DEED license. This paper is available on arxiv under CC0 1.0 DEED license. available on arxiv

How to Implement ADA for Data Augmentation in Nonlinear Regression Models

How to Manage Tasks (With Your Assistant) Using Notion: A Simple Guide

How to Implement Multi-Tenant Authentication with Keycloak in an Angular Spring Boot Stack

Have you ever wondered how social media apps like Instagram manage to keep us scrolling, almost as if the content is endless? I know I have! It goes beyond just great content — it taps into a continuous flow that keeps us hooked, waiting for what’s next. Unlike traditional pagination, where users have to click "Next" to load more, infinite scrolling creates a seamless experience. Just as we reach the end of the visible content, new items load in, sparking curiosity and anticipation. This is the magic of infinite scroll: keeping the journey going without any interruptions. Let’s dive right into it In this guide, we’ll create a simple React app that uses infinite scroll to display GitHub users information. We'll be using: React: For creating and managing the component-based structure of our app.
react-infinite-scroll-component: A popular package to manage the infinite scroll behavior.
Tailwind CSS: For quick and clean styling.
Axios: For making HTTP requests to the GitHub API. 1.) Set Up the Project npx create-react-app infinite-scroll-app
cd infinite-scroll-app
npm start Install axios, react-infinite-scroll-component and tailwindcss npm install axios react-infinite-scroll-component tailwindcss 2.) Generate a Github Personal Token Since we’ll be using the Github Apis,  it’s important to get Access Token from GitHub To avoid rate limitations, Here’s how to create a GitHub Personal Access Token and use it in your project: Go to your GitHub Settings.
Click on "Generate new token".
Select the scopes you need (for read-only public data, you typically just need the public_repo scope).
Generate and copy the token somewhere secure; you’ll need it in your app
Create an .env file in the root directory, include the github API url and the Access Token you just copied REACT_APP_API_URL=https://api.github.com
REACT_APP_API_KEY=your_access_token 3.) Fetch the data from the Github Api const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  }; It’s important to note that Github uses since and not page just as is in the code above 4.) Setting Up The Infinite Scroll <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll> 5. )Putting it all together import axios from "axios";
import React, { useEffect, useState } from "react";
import InfiniteScroll from "react-infinite-scroll-component";

function App() {
  const [users, setUsers] = useState([]);
  const [lastUserId, setLastUserId] = useState(null);
  const [hasMore, setHasMore] = useState(true);

  const apiKey = process.env.REACT_APP_API_KEY;
  const apiUrl = process.env.REACT_APP_API_URL;

  const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  };

  useEffect(() => {
    fetchUsers();
  }, []);

  return (
    <div className="container py-8">
      <div className="mx-auto">
        <h1 className="text-4xl font-bold text-center mb-8">
          React Infinite Scroll Demo
        </h1>
        <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll>
      </div>
    </div>
  );
}

export default App; Conclusion Infinite scrolling is a way to keep users engaged by continuously loading new content without interruption, and by now, you’ve experienced how easy it is to add to a React app. Using react-infinite-scroll-component, axios for API calls, and tailwindcss for styling, we’ve created a user-friendly experience that mimics popular social platforms. Find the source code on github. Check the app here. Have you ever wondered how social media apps like Instagram manage to keep us scrolling, almost as if the content is endless? I know I have! It goes beyond just great content — it taps into a continuous flow that keeps us hooked, waiting for what’s next. Unlike traditional pagination, where users have to click "Next" to load more, infinite scrolling creates a seamless experience. Just as we reach the end of the visible content, new items load in, sparking curiosity and anticipation. This is the magic of infinite scroll : keeping the journey going without any interruptions. infinite scroll Let’s dive right into it In this guide, we’ll create a simple React app that uses infinite scroll to display GitHub users information. We'll be using: React: For creating and managing the component-based structure of our app. react-infinite-scroll-component: A popular package to manage the infinite scroll behavior. Tailwind CSS: For quick and clean styling. Axios: For making HTTP requests to the GitHub API. React : For creating and managing the component-based structure of our app. React react-infinite-scroll-component : A popular package to manage the infinite scroll behavior. react-infinite-scroll-component Tailwind CSS : For quick and clean styling. Tailwind CSS Axios : For making HTTP requests to the GitHub API. Axios 1.) Set Up the Project npx create-react-app infinite-scroll-app
cd infinite-scroll-app
npm start npx create-react-app infinite-scroll-app
cd infinite-scroll-app
npm start Install axios , react-infinite-scroll-component and tailwindcss axios react-infinite-scroll-component tailwindcss npm install axios react-infinite-scroll-component tailwindcss npm install axios react-infinite-scroll-component tailwindcss 2.) Generate a Github Personal Token Since we’ll be using the Github Apis,  it’s important to get Access Token from GitHub To avoid rate limitations, Here’s how to create a GitHub Personal Access Token and use it in your project: Go to your GitHub Settings. Click on "Generate new token". Select the scopes you need (for read-only public data, you typically just need the public_repo scope). Generate and copy the token somewhere secure; you’ll need it in your app Create an .env file in the root directory, include the github API url and the Access Token you just copied Go to your GitHub Settings . GitHub Settings Click on "Generate new token" . "Generate new token" Select the scopes you need (for read-only public data, you typically just need the public_repo scope). public_repo Generate and copy the token somewhere secure; you’ll need it in your app Create an .env file in the root directory, include the github API url and the Access Token you just copied REACT_APP_API_URL=https://api.github.com
REACT_APP_API_KEY=your_access_token REACT_APP_API_URL=https://api.github.com
REACT_APP_API_KEY=your_access_token 3.) Fetch the data from the Github Api const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  }; const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  }; It’s important to note that Github uses since and not page just as is in the code above since page 4.) Setting Up The Infinite Scroll <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll> <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll> 5. )Putting it all together import axios from "axios";
import React, { useEffect, useState } from "react";
import InfiniteScroll from "react-infinite-scroll-component";

function App() {
  const [users, setUsers] = useState([]);
  const [lastUserId, setLastUserId] = useState(null);
  const [hasMore, setHasMore] = useState(true);

  const apiKey = process.env.REACT_APP_API_KEY;
  const apiUrl = process.env.REACT_APP_API_URL;

  const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  };

  useEffect(() => {
    fetchUsers();
  }, []);

  return (
    <div className="container py-8">
      <div className="mx-auto">
        <h1 className="text-4xl font-bold text-center mb-8">
          React Infinite Scroll Demo
        </h1>
        <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll>
      </div>
    </div>
  );
}

export default App; import axios from "axios";
import React, { useEffect, useState } from "react";
import InfiniteScroll from "react-infinite-scroll-component";

function App() {
  const [users, setUsers] = useState([]);
  const [lastUserId, setLastUserId] = useState(null);
  const [hasMore, setHasMore] = useState(true);

  const apiKey = process.env.REACT_APP_API_KEY;
  const apiUrl = process.env.REACT_APP_API_URL;

  const fetchUsers = async () => {
    try {
      const response = await axios.get(`${apiUrl}/users`, {
        headers: {
          Authorization: `Bearer ${apiKey}`,
        },
        params: {
          per_page: 20, // Adjust the number of users per page
          since: lastUserId, //The user id it should begin listing
        },
      });
      const newUsers = response.data;
      setUsers((prevUsers) => [...prevUsers, ...newUsers]);
      setLastUserId(newUsers[newUsers.length - 1]?.id); // update the last user ID
      setHasMore(newUsers.length > 0);
    } catch (error) {
      console.error("Error fetching users from GitHub API:", error);
      return [];
    }
  };

  useEffect(() => {
    fetchUsers();
  }, []);

  return (
    <div className="container py-8">
      <div className="mx-auto">
        <h1 className="text-4xl font-bold text-center mb-8">
          React Infinite Scroll Demo
        </h1>
        <InfiniteScroll
          dataLength={users.length}
          next={fetchUsers}
          hasMore={hasMore}
          loader={
            <h4 className="font-semibold mt-4 text-center">Loading...</h4>
          }
          endMessage={<p>No more users to display</p>}
        >
          <div className="flex flex-wrap gap-4 justify-between items-center">
            {users.map((user, key) => (
              <div
                key={key}
                className="border h-[8rem] w-[45%] sm:w-[30%] md:w-[20%] flex flex-col gap-2 items-center p-2"
              >
                <img
                  src={user.avatar_url}
                  alt={`Avatar image of ${user.login}`}
                  width="80px"
                  height="80px"
                  className="rounded-full"
                />
                <p>{user.login}</p>
              </div>
            ))}
          </div>
        </InfiniteScroll>
      </div>
    </div>
  );
}

export default App; Conclusion Infinite scrolling is a way to keep users engaged by continuously loading new content without interruption, and by now, you’ve experienced how easy it is to add to a React app. Using react-infinite-scroll-component , axios for API calls, and tailwindcss for styling, we’ve created a user-friendly experience that mimics popular social platforms. react-infinite-scroll-component axios tailwindcss Find the source code on github . github Check the app here . here

How to Build a Simple and User-Friendly Infinite Scroll in React

100x Simpler -  The Ultimate Open-Source Guide

If you typically need AI writers like ChatGPT to streamline your content workflow, then it also pays to make use of AI humanizers. After all, AI content can often fail to keep readers engaged and it can lead to all sorts of consequences if it ends up being flagged by AI detectors like GPTZero, Turnitin, ZeroGPT, and others. For this reason, we decided to explore Humanize.io to see what this tool is all about. As an AI humanizer, it can help rewrite your AI content to sound more natural and human-like. But how does it work? What features does it offer? In this review, we will give you some deeper insight into one of the easiest ways of making AI content undetectable. How Does Humanize.io Work? Humanize.io is an AI humanization tool developed on a substantial volume of human-written text data such as articles, essays, papers, reports, and more. All of this information enables it to understand and replicate the varied patterns, syntax, and vocabulary that most real authors typically use in their content. As a result, it is able to enhance the overall uniqueness and naturalness of any AI-generated content to ensure it can evade AI detection and achieve high human scores. Best of all, the platform is fairly simple and intuitive enough to use that you don’t need any technical expertise or experience to get started. All it takes is four simple steps to humanize your AI text. Check them out below. Step 1: Head to Humanize.io, and paste the AI content in the input box. Step 2: Choose an AI bypass mode, which lets you rewrite the content in different ways. Step 3: Click ‘Humanize,’ and wait for the AI content to be rewritten. Step 4: Review the output and use it, or repeat the process to get different results. Since the platform works with any type of AI content, you can rely on it to humanize text from ChatGPT, Jasper, Gemini, Claude, or any other LLM. Plus, it has a powerful AI humanization model that can rewrite content in seconds, no matter the length. This makes it a versatile AI humanizer that can help you tackle any bulk AI content tasks. Why Should You Use Humanize.io? Now that we’ve established what Humanize.io can do, several aspects make it such a stand-out tool even amongst other popular AI humanizers in the market. So, let’s quickly break down some of the platform’s key highlights in detail below. Broad Anti-AI Detection Coverage: Humanize.io doesn’t just rework AI text to bypass a select few AI detectors. Using sophisticated AI humanization technologies, it implements real human nuances in the text that guarantee the output will bypass any advanced AI detection model without fail. 100% Error-Free Content: Humanize.io does well to consistently rewrite AI text and produce output that is entirely free of any grammatical, punctuation, or syntax errors. This ensures you won’t have to make constant revisions every time you humanize AI content. Duplicate-Free Output: Any humanized content generated by Humanize.io is guaranteed to be unique and not copied from anywhere. In other words, it will pass any originality scan, be it by Turnitin, Quetext, Copyscape, or any other plagiarism scan. Maintains Contextual Accuracy: With Humanize.io, there is no risk of your intended message being distorted. The platform will humanize your AI content while also retaining the original context, which also lets you create multiple versions of the same content easily. Multilingual AI Humanization: Humanize.io supports 50+ different languages, which enables you to humanize AI text to accommodate global audiences. This includes popular languages like English, Spanish, French, Portuguese, Hindi, Mandarin, and many others. Fast & Efficient Processing: When rewriting AI text, Humanize.io can be relied on to process your content in a matter of seconds rather than minutes. This makes it an ideal tool to humanize AI content in bulk without having to deal with any delays. How Can You Use Humanize.io? Humanize.io is a versatile tool that can help you humanize AI content to accommodate a wide range of use cases across a variety of fields, industries, and niches. Some of the most popular ones typically include: Content Marketing: AI-generated content often comes off as bland and robotic. Instead, you can use Humanize.io to add a human touch to your articles, newsletters, emails, and other marketing materials. This can help make them more relatable and interesting for higher reader engagement. Social Media Posting: AI tools can be a quick way to generate social media captions and posts. However, you can rely on Humanize.io to give the content some more personality by making it sound more authentic and conversational. This makes it far easier to boost audience engagement online across multiple channels. Academic Writing: Most educational institutions are still against using AI writing tools. Humanize.io can be an effective workaround that lets you humanize AI-generated essays, reports, and papers. This can be a quick and efficient way of ensuring your submitted content remains in line with academic policies. E-commerce Marketing: AI writing tools can speed up the process of writing product descriptions. However, AI-generated text can’t be counted on to incentivize customers to purchase. With Humanize.io, you can turn that content into a compelling marketing copy that effectively converts potential buyers. Conclusion Overall, Humanize.io is a powerful tool that can make your AI content writing a much less frustrating experience. With its advanced AI bypass capabilities, you can outsmart any AI detector and make any AI-generated text sound less artificial and more authentically human in just a few clicks. Best of all, it caters well to any AI content writing task, personal or professional. So, head over to Humanize.io now and try it out for free! This story was distributed by Margrowth under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author If you typically need AI writers like ChatGPT to streamline your content workflow, then it also pays to make use of AI humanizers. After all, AI content can often fail to keep readers engaged and it can lead to all sorts of consequences if it ends up being flagged by AI detectors like GPTZero, Turnitin, ZeroGPT, and others. For this reason, we decided to explore Humanize.io to see what this tool is all about. As an AI humanizer, it can help rewrite your AI content to sound more natural and human-like. But how does it work? What features does it offer? In this review, we will give you some deeper insight into one of the easiest ways of making AI content undetectable. How Does Humanize.io Work? Humanize.io is an AI humanization tool developed on a substantial volume of human-written text data such as articles, essays, papers, reports, and more. All of this information enables it to understand and replicate the varied patterns, syntax, and vocabulary that most real authors typically use in their content. Humanize.io Humanize.io As a result, it is able to enhance the overall uniqueness and naturalness of any AI-generated content to ensure it can evade AI detection and achieve high human scores. Best of all, the platform is fairly simple and intuitive enough to use that you don’t need any technical expertise or experience to get started. All it takes is four simple steps to humanize your AI text. Check them out below. Step 1: Head to Humanize.io, and paste the AI content in the input box. Step 2: Choose an AI bypass mode, which lets you rewrite the content in different ways. Step 3: Click ‘Humanize,’ and wait for the AI content to be rewritten. Step 4: Review the output and use it, or repeat the process to get different results. Since the platform works with any type of AI content, you can rely on it to humanize text from ChatGPT, Jasper, Gemini, Claude, or any other LLM. Plus, it has a powerful AI humanization model that can rewrite content in seconds, no matter the length. This makes it a versatile AI humanizer that can help you tackle any bulk AI content tasks. Why Should You Use Humanize.io? Now that we’ve established what Humanize.io can do, several aspects make it such a stand-out tool even amongst other popular AI humanizers in the market. So, let’s quickly break down some of the platform’s key highlights in detail below. Broad Anti-AI Detection Coverage: Humanize.io doesn’t just rework AI text to bypass a select few AI detectors. Using sophisticated AI humanization technologies, it implements real human nuances in the text that guarantee the output will bypass any advanced AI detection model without fail. Broad Anti-AI Detection Coverage: Humanize.io doesn’t just rework AI text to bypass a select few AI detectors. Using sophisticated AI humanization technologies, it implements real human nuances in the text that guarantee the output will bypass any advanced AI detection model without fail. 100% Error-Free Content: Humanize.io does well to consistently rewrite AI text and produce output that is entirely free of any grammatical, punctuation, or syntax errors. This ensures you won’t have to make constant revisions every time you humanize AI content. 100% Error-Free Content: Humanize.io does well to consistently rewrite AI text and produce output that is entirely free of any grammatical, punctuation, or syntax errors. This ensures you won’t have to make constant revisions every time you humanize AI content. Duplicate-Free Output: Any humanized content generated by Humanize.io is guaranteed to be unique and not copied from anywhere. In other words, it will pass any originality scan, be it by Turnitin, Quetext, Copyscape, or any other plagiarism scan. Duplicate-Free Output: Any humanized content generated by Humanize.io is guaranteed to be unique and not copied from anywhere. In other words, it will pass any originality scan, be it by Turnitin, Quetext, Copyscape, or any other plagiarism scan. Maintains Contextual Accuracy: With Humanize.io, there is no risk of your intended message being distorted. The platform will humanize your AI content while also retaining the original context, which also lets you create multiple versions of the same content easily. Maintains Contextual Accuracy: With Humanize.io, there is no risk of your intended message being distorted. The platform will humanize your AI content while also retaining the original context, which also lets you create multiple versions of the same content easily. Multilingual AI Humanization: Humanize.io supports 50+ different languages, which enables you to humanize AI text to accommodate global audiences. This includes popular languages like English, Spanish, French, Portuguese, Hindi, Mandarin, and many others. Multilingual AI Humanization: Humanize.io supports 50+ different languages, which enables you to humanize AI text to accommodate global audiences. This includes popular languages like English, Spanish, French, Portuguese, Hindi, Mandarin, and many others. Fast & Efficient Processing: When rewriting AI text, Humanize.io can be relied on to process your content in a matter of seconds rather than minutes. This makes it an ideal tool to humanize AI content in bulk without having to deal with any delays. Fast & Efficient Processing: When rewriting AI text, Humanize.io can be relied on to process your content in a matter of seconds rather than minutes. This makes it an ideal tool to humanize AI content in bulk without having to deal with any delays. How Can You Use Humanize.io? Humanize.io is a versatile tool that can help you humanize AI content to accommodate a wide range of use cases across a variety of fields, industries, and niches. Some of the most popular ones typically include: Content Marketing: AI-generated content often comes off as bland and robotic. Instead, you can use Humanize.io to add a human touch to your articles, newsletters, emails, and other marketing materials. This can help make them more relatable and interesting for higher reader engagement. Content Marketing: AI-generated content often comes off as bland and robotic. Instead, you can use Humanize.io to add a human touch to your articles, newsletters, emails, and other marketing materials. This can help make them more relatable and interesting for higher reader engagement. Social Media Posting: AI tools can be a quick way to generate social media captions and posts. However, you can rely on Humanize.io to give the content some more personality by making it sound more authentic and conversational. This makes it far easier to boost audience engagement online across multiple channels. Social Media Posting: AI tools can be a quick way to generate social media captions and posts. However, you can rely on Humanize.io to give the content some more personality by making it sound more authentic and conversational. This makes it far easier to boost audience engagement online across multiple channels. Academic Writing: Most educational institutions are still against using AI writing tools. Humanize.io can be an effective workaround that lets you humanize AI-generated essays, reports, and papers. This can be a quick and efficient way of ensuring your submitted content remains in line with academic policies. Academic Writing: Most educational institutions are still against using AI writing tools. Humanize.io can be an effective workaround that lets you humanize AI-generated essays, reports, and papers. This can be a quick and efficient way of ensuring your submitted content remains in line with academic policies. E-commerce Marketing: AI writing tools can speed up the process of writing product descriptions. However, AI-generated text can’t be counted on to incentivize customers to purchase. With Humanize.io, you can turn that content into a compelling marketing copy that effectively converts potential buyers. E-commerce Marketing: AI writing tools can speed up the process of writing product descriptions. However, AI-generated text can’t be counted on to incentivize customers to purchase. With Humanize.io, you can turn that content into a compelling marketing copy that effectively converts potential buyers. Conclusion Overall, Humanize.io is a powerful tool that can make your AI content writing a much less frustrating experience. With its advanced AI bypass capabilities, you can outsmart any AI detector and make any AI-generated text sound less artificial and more authentically human in just a few clicks. Best of all, it caters well to any AI content writing task, personal or professional. So, head over to Humanize.io now and try it out for free! head over to Humanize.io head over to Humanize.io This story was distributed by Margrowth under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author This story was distributed by Margrowth under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author This story was distributed by Margrowth under HackerNoon’s Brand As An Author Program. Learn more about the program here: https://business.hackernoon.com/brand-as-author https://business.hackernoon.com/brand-as-author

Humanize.io Review: Is This A Simple Way Of Making AI Content Undetectable?

Humanize.io recenzija: Da li je ovo jednostavan način da se AI sadržaj učini neprimetnim?

Humanize.io anmeldelse: Er dette en enkel måde at gøre AI-indhold uopdageligt?

Humanize.io-Test: Ist dies eine einfache Möglichkeit, KI-Inhalte unsichtbar zu machen?

Revisión de Humanize.io: ¿Es esta una forma sencilla de hacer que el contenido de IA sea indetectable?

Humanize.io Iritzia: Hau AI edukia hautemanezin bihurtzeko modu sinplea al da?

Humanize.io समीक्षा: क्या यह AI सामग्री को अप्राप्य बनाने का एक सरल तरीका है?

Revizyon Humanize.io: Èske sa se yon fason senp pou fè kontni AI endeslabl?

Humanize.io Review. Արդյո՞ք սա AI բովանդակությունը աննկատելի դարձնելու պարզ միջոց է:

Humanize.io レビュー: これは AI コンテンツを検出不能にする簡単な方法でしょうか?

Humanize.io მიმოხილვა: არის თუ არა ეს მარტივი გზა ხელოვნური ინტელექტის კონტენტის აღმოჩენის გარეშე?

Humanize.io apžvalga: ar tai paprastas būdas AI turinį padaryti neaptinkamą?

Humanize.io Review: እዚ ትሕዝቶ AI ዘይፍለጥ ንምግባር ቀሊል መንገዲ ድዩ?

Stories, News & Mentions about FIMPLE

Fimple’s Stories on HackerNoon