FetchGoat is <strong>an intelligence layer that continuously analyzes billions of data points from across your logistics network to help you resolve issues quickly</strong>. With FetchGoat, you can be notified of challenges before they impact your end users. Proactive notifications alert you BEFORE critical ...

FetchGoat | LinkedIn

Real-time last-mile delivery monitoring &amp; management. The ability to see every delivery provider, and scheduled route.

Home - Fetchgoat

<strong>FetchGoat</strong> is a logistics SaaS <strong>company</strong> that provides affordable visibility solutions for shippers that manage multiple delivery partners.

FetchGoat - Crunchbase Company Profile & Funding

Information on valuation, funding, acquisitions, investors, and executives for <strong>FetchGoat</strong>. Use the PitchBook Platform to explore the full profile.

FetchGoat Company Profile: Funding & Investors | PitchBook

<strong>FetchGoat</strong> is a delivery management platform. Its platform allows users to see delivery providers, scheduled routes, performance, and actionable analytics in a dashboard. It serves <strong>companies</strong> operating in the logistics industry. The <strong>company</strong> was founded in 2021 and is based in Fort Worth, Texas.

FetchGoat - Products, Competitors, Financials, Employees, ...

At <strong>FetchGoat</strong>, our support for veterans extends beyond employment. We are actively involved in community outreach programs, fundraisers, and events that honor and support veterans and their families. Our unwavering commitment to the veteran community reflects our core values as a <strong>company</strong> and as ...

FetchGoat Veterans

Protect your pets with the most comprehensive pet insurance that fits your budget. Experience hassle-free claims and the freedom to choose any vet in the U.S. or Canada.

Best Pet Insurance in the U.S. and Canada | Fetch Pet Insurance

Fort Worth, Texas-based startup <strong>FetchGoat</strong> announced Thursday it has established a partnership with an industry veteran to enable the last-mile software-as-a-service <strong>company</strong> to “ram the pedal to the floor when everyone else is tapping the brakes,” said co-founder and CEO Bill Hale.

Strategic investor helping steer FetchGoat’s expansion drive ...

<strong>FetchGoat</strong> has solved the biggest issue for third party providers and shippers that use multiple delivery <strong>companies</strong>: “How do I manage and monitor all deliveries in real-time through a single dashboard.” · <strong>FetchGoat</strong> technology is designed to function as a Delivery Management System (DMS) ...

Third Party Providers - FetchGoat

Episode 26- We speak with Bill Hale CEO/Co-Founder of <strong>FetchGoat</strong>. A platform for Enterprise Shippers and Delivery <strong>Companies</strong>. <strong>FetchGoat</strong> solves the biggest issue for <strong>companies</strong> using multiple last-mile providers: How to manage and monitor all delivery <strong>companies</strong> in real time through a single dashboard…

‎Play the King & Win the Day!: Episode 26- Bill Hale CEO & ...

<strong>FetchGoat</strong> serves delivery agents by providing performance dashboard, sales, marketing, and business support for each.

Delivery Agents - FetchGoat

Search <strong>company</strong>, investor... ... Analyst Briefing Submitters are 7x more likely to receive a qualified connection. Learn more. Highlight why customers choose <strong>FetchGoat</strong>&#x27;s products and services with an Analyst Briefing

FetchGoat Customers

<strong>FetchGoat</strong> is a Logistics SaaS <strong>company</strong>, and has been voted #20 on FreightWaves&#x27; FreightTech 25 - 2024. If you&#x27;d like to learn more, please visit www.<strong>fetchgoat</strong>.com or reach out directly to u/<strong>fetchgoat</strong>_official

r/fetchgoat on Reddit: What is FetchGoat?

Get Swift - Melbourne based, 2013 founded, Public <strong>company</strong> · View details and comparison of Fetch Goat&#x27;s Competitors ... <strong>FetchGoat</strong> Announces Strategic Partnership with Industry Titan Mark TuchmannPR Newswire•Jan 04, 2023•Fetch Goat

Fetch Goat | Tracxn

<strong>FetchGoat</strong> technology is designed to function as a Delivery Management System (DMS) to facilitate final mile delivery services for Shippers.

Solutions - FetchGoat

If you&#x27;re looking for loving and convenient pet care, look no further than Fetch! We provide everything from pet sitting to transportation.

The Nation's Leading In-home Pet Care Provider - Fetch! Pet Care

You need to enable JavaScript to run this app

Fetchgoat

Perfect timing as we scale and work on <strong>FetchGoat</strong> Systems&#x27; next exciting release. Keep in mind, that we&#x27;re still bootstrapping which makes any kind of support valuable for the <strong>company</strong>. In addition to the cloud credits and licenses provided to us, we also started our partnership with MSFT4Startups ...

Bill Hale on LinkedIn: BIG NEWS! - As you know, FetchGoat Systems ...

We are solving a problem in one of the largest markets in the world, by providing a neutral platform for shippers and carriers that allows both parties to monitor and analyze their shipments down to the stop level

FetchGoat

Build a Real-Time Crypto Tracker with CoinGecko API and React.js

React ⚛️is the most famous UI library in front-end development today. For developers looking to stay ahead of the React race, understanding new React 19 features is essential. Overview of the Features ⚛️React compiler
🗄️ Server components 🖥
🔄Automatic Batching📦
🗒️SEO Metadata
📈Improved Data Fetching with Suspense
💼 Assets Loading
🪝 Enhanced hooks The Revolution of React 19 is exciting and interesting. Let’s read now! ⚛️ React Compiler ⚛️ React19 is getting a new helper called the React Compiler 💡. It's like a smart code-compiling friend that makes your code work faster without you having to do extra work. This means people who make websites can write simpler code, and the compiler will make sure it runs really well. It's like having a super-smart assistant that cleans up and organizes your room for you, so you can focus on playing and having fun with React! 🗄️ Server Components 🖥 React19 comes with the superpower “🖥Server Components.” It's like having a smart render tool that does some of the work before you even ask for it! React19  renders UI components on the server, separate from your client-side app or traditional server-side rendering (SSR) setup. By pre-rendering components on the server, RSCs can automatically improve page speed times. This means when you open a website, the pictures and words show up much faster. It's especially helpful for websites with lots of cool stuff on them. The best part is that these server components can work in different ways depending on what the website needs. Code Example: Server Components // ServerComponent.server.js export default function ServerComponent() { return <div>Hello from the server!</div>; } // App.client.js import React from 'react'; import { createRoot } from 'react-dom/client'; import ServerComponent from './ServerComponent.server'; function App() { return ( <div> <ServerComponent /> </div> ); } const root = createRoot(document.getElementById('root')); root.render(<App />); So, server components make websites load super quick which means less waiting and more speed for you! Don't Waste Time Building React UIs: Check out Monster React Dashboard Template Now! 🔄Automatic Batching📦 React 19 introduces automatic batching for all updates inside event handlers. This means that multiple state updates inside a single event handler will now be batched automatically, leading to fewer re-renders and improved performance. Code Example: Automatic Batching import React, { useState } from 'react'; import { createRoot } from 'react-dom/client'; function App() { const [count, setCount] = useState(0); const [text, setText] = useState(''); const handleClick = () => { setCount(count + 1); setText('Updated text'); }; return ( <div> <button onClick={handleClick}>Update</button> <div>Count: {count}</div> <div>Text: {text}</div> </div> ); } 🗒️SEO Metadata 📝 React 19 is now an AutoSEO Feature that helps websites be found on the internet! Now, React simplifies SEO-sensitive elements and you can easily control titles, descriptions, and other SEO-relevant elements directly within your React application. This way, when someone looks for something on the internet, they can find the right websites faster. 📈Improved Data Fetching With Suspense React 19 builds on the Suspense feature to make data fetching easier and more intuitive. With the new data fetching capabilities, you can now handle asynchronous operations more gracefully within your components. Code Example: Data Fetching with Suspense import React, { Suspense } from 'react'; import { createRoot } from 'react-dom/client'; const fetchData = () => { return new Promise(resolve => { setTimeout(() => { resolve('Data fetched from server'); }, 2000); }); }; const DataComponent = React.lazy(async () => { const data = await fetchData(); return { default: () => <div>{data}</div> }; }); function App() { return ( <div> <Suspense fallback={<div>Loading...</div>}> <DataComponent /> </Suspense> </div> ); } const root = createRoot(document.getElementById('root')); root.render(<App />); 💼 Assets Loading React 19 has a feature where Assets Loads Auto in the background so websites work faster and look better! It starts loading pictures and other stuff for the next page while you're still looking at the current one. This means when you click to go to a new page, it shows up super fast! Have you ever seen a website that looks weird for a split second when it first loads? Like the words are in the wrong place or the colors are all mixed up? React 19 fixes this too. It makes sure everything looks just right before showing it to you.
Code Example: Concurrent Rendering import React, { useState, Suspense } from 'react'; import { createRoot } from 'react-dom/client'; const SlowComponent = React.lazy(() => import('./SlowComponent')); function App() { const [show, setShow] = useState(false); return ( <div> <button onClick={() => setShow(true)}>Show Slow Component</button> <Suspense fallback={<div>Loading...</div>}> {show && <SlowComponent />} </Suspense> </div> ); } const root = createRoot(document.getElementById('root')); root.render(<App />); This way, the website can work on loading stuff in the background without bothering you while you're using it. Focus on what matters. Build Feature-Rich React Apps with MaterialPRO Hooks React 19 introduces new hooks to help manage events and optimistic UI updates more effectively. The useEvent hook provides a simpler way to handle event listeners, while the useOptimistic hook helps manage optimistic UI states. Code Example: useEvent Hook import React, { useEvent } from 'react'; import { createRoot } from 'react-dom/client'; function App() { const handleClick = useEvent(() => { console.log('Button clicked!'); }); return ( <div> <button onClick={handleClick}>Click Me</button> </div> ); } const root = createRoot(document.getElementById('root')); root.render(<App />); Code Example: useOptimistic Hook import React, { useOptimistic } from 'react'; import { createRoot } from 'react-dom/client'; function App() { const [optimisticState, setOptimisticState] = useOptimistic(0); const handleClick = () => { setOptimisticState((prevState) => prevState + 1); }; return ( <div> <button onClick={handleClick}>Increment</button> <div>Optimistic Count: {optimisticState}</div> </div> ); } const root = createRoot(document.getElementById('root')); root.render(<App />); 🌟 Summary “ Don't Miss Out! “ We talked about many things in this article. Let's quickly go over the cool new stuff coming in the next version of React 19. React 19 brings a host of new features and improvements that make building responsive, efficient, and scalable applications easier than ever. From concurrent rendering enhancements to new hooks like useEvent and useOptimistic, these updates provide powerful tools for React developers. Experiment with these new features in your projects, and take advantage of the latest advancements in the React ecosystem. Build Modern React Apps Faster with Modernize. Stay tuned for more updates, and happy </> coding! Previously published at https://blog.wrappixel.com/react-19-whats-new-features/ React ⚛️is the most famous UI library in front-end development today. most famous UI library in front-end development For developers looking to stay ahead of the React race, understanding new React 19 features is essential. Overview of the Features ⚛️React compiler 🗄️ Server components 🖥 🔄Automatic Batching📦 🗒️SEO Metadata 📈Improved Data Fetching with Suspense 💼 Assets Loading 🪝 Enhanced hooks ⚛️React compiler ⚛️React compiler 🗄️ Server components 🖥 🗄️ Server components 🖥 🔄Automatic Batching📦 🔄Automatic Batching📦 🗒️SEO Metadata 🗒️SEO Metadata 📈Improved Data Fetching with Suspense 📈Improved Data Fetching with Suspense 💼 Assets Loading 💼 Assets Loading 🪝 Enhanced hooks 🪝 Enhanced hooks The Revolution of React 19 is exciting and interesting. Let’s read now! ⚛️ React Compiler ⚛️ ⚛️ React Compiler ⚛️ React19 is getting a new helper called the React Compiler 💡. It's like a smart code-compiling friend that makes your code work faster without you having to do extra work. This means people who make websites can write simpler code, and the compiler will make sure it runs really well. It's like having a super-smart assistant that cleans up and organizes your room for you, so you can focus on playing and having fun with React! React19 is getting a new helper called the React Compiler 💡. It's like a smart code-compiling friend that makes your code work faster without you having to do extra work. This means people who make websites can write simpler code, and the compiler will make sure it runs really well. It's like having a super-smart assistant that cleans up and organizes your room for you, so you can focus on playing and having fun with React ! React 🗄️ Server Components 🖥 🗄️ Server Components 🖥 React19 comes with the superpower “🖥Server Components.” React19 comes with the superpower “🖥Server Components.” It's like having a smart render tool that does some of the work before you even ask for it! It's like having a smart render tool that does some of the work before you even ask for it! React19  renders UI components on the server, separate from your client-side app or traditional server-side rendering (SSR) setup. By pre-rendering components on the server, RSCs can automatically improve page speed times. React19  renders UI components on the server, separate from your client-side app or traditional server-side rendering (SSR) setup. By pre-rendering components on the server, RSCs can automatically improve page speed times. This means when you open a website, the pictures and words show up much faster. It's especially helpful for websites with lots of cool stuff on them. The best part is that these server components can work in different ways depending on what the website needs. This means when you open a website, the pictures and words show up much faster. It's especially helpful for websites with lots of cool stuff on them. The best part is that these server components can work in different ways depending on what the website needs. Code Example: Server Components Code Example: Server Components // ServerComponent.server.js // ServerComponent.server.js export default function ServerComponent() { export default function ServerComponent() { return <div>Hello from the server!</div>; return <div>Hello from the server!</div>; } } // App.client.js // App.client.js import React from 'react'; import React from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; import ServerComponent from './ServerComponent.server'; import ServerComponent from './ServerComponent.server'; function App() { function App() { return ( return ( <div> <div> <ServerComponent /> <ServerComponent /> </div> </div> ); ); } } const root = createRoot(document.getElementById('root')); const root = createRoot(document.getElementById('root')); root.render(<App />); root.render(<App />); So, server components make websites load super quick which means less waiting and more speed for you! Don't Waste Time Building React UIs: Check out Monster React Dashboard Template Now! Monster React Dashboard Template 🔄Automatic Batching📦 🔄Automatic Batching📦 React 19 introduces automatic batching for all updates inside event handlers. This means that multiple state updates inside a single event handler will now be batched automatically, leading to fewer re-renders and improved performance. React 19 introduces automatic batching for all updates inside event handlers. This means that multiple state updates inside a single event handler will now be batched automatically, leading to fewer re-renders and improved performance. Code Example: Automatic Batching Code Example: Automatic Batching import React, { useState } from 'react'; import React, { useState } from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; function App() { function App() { const [count, setCount] = useState(0); const [count, setCount] = useState(0); const [text, setText] = useState(''); const [text, setText] = useState(''); const handleClick = () => { const handleClick = () => { setCount(count + 1); setCount(count + 1); setText('Updated text'); setText('Updated text'); }; }; return ( return ( <div> <div> <button onClick={handleClick}>Update</button> <button onClick={handleClick}>Update</button> <div>Count: {count}</div> <div>Count: {count}</div> <div>Text: {text}</div> <div>Text: {text}</div> </div> </div> ); ); } } 🗒️SEO Metadata 📝 🗒️SEO Metadata 📝 React 19 is now an AutoSEO Feature that helps websites be found on the internet! Now, React simplifies SEO-sensitive elements and you can easily control titles, descriptions, and other SEO-relevant elements directly within your React application. This way, when someone looks for something on the internet, they can find the right websites faster. 📈Improved Data Fetching With Suspense React 19 builds on the Suspense feature to make data fetching easier and more intuitive. With the new data fetching capabilities, you can now handle asynchronous operations more gracefully within your components. Code Example: Data Fetching with Suspense Code Example: Data Fetching with Suspense import React, { Suspense } from 'react'; import React, { Suspense } from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; const fetchData = () => { const fetchData = () => { return new Promise(resolve => { return new Promise(resolve => { setTimeout(() => { setTimeout(() => { resolve('Data fetched from server'); resolve('Data fetched from server'); }, 2000); }, 2000); }); }); }; }; const DataComponent = React.lazy(async () => { const DataComponent = React.lazy(async () => { const data = await fetchData(); const data = await fetchData(); return { return { default: () => <div>{data}</div> default: () => <div>{data}</div> }; }; }); }); function App() { function App() { return ( return ( <div> <div> <Suspense fallback={<div>Loading...</div>}> <Suspense fallback={<div>Loading...</div>}> <DataComponent /> <DataComponent /> </Suspense> </Suspense> </div> </div> ); ); } } const root = createRoot(document.getElementById('root')); const root = createRoot(document.getElementById('root')); root.render(<App />); root.render(<App />); 💼 Assets Loading React 19 has a feature where Assets Loads Auto in the background so websites work faster and look better! It starts loading pictures and other stuff for the next page while you're still looking at the current one. This means when you click to go to a new page, it shows up super fast! Have you ever seen a website that looks weird for a split second when it first loads? Like the words are in the wrong place or the colors are all mixed up? React 19 fixes this too. It makes sure everything looks just right before showing it to you. Code Example: Concurrent Rendering Code Example: Concurrent Rendering import React, { useState, Suspense } from 'react'; import React, { useState, Suspense } from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; const SlowComponent = React.lazy(() => import('./SlowComponent')); const SlowComponent = React.lazy(() => import('./SlowComponent')); function App() { function App() { const [show, setShow] = useState(false); const [show, setShow] = useState(false); return ( return ( <div> <div> <button onClick={() => setShow(true)}>Show Slow Component</button> <button onClick={() => setShow(true)}>Show Slow Component</button> <Suspense fallback={<div>Loading...</div>}> <Suspense fallback={<div>Loading...</div>}> {show && <SlowComponent />} {show && <SlowComponent />} </Suspense> </Suspense> </div> </div> ); ); } } const root = createRoot(document.getElementById('root')); const root = createRoot(document.getElementById('root')); root.render(<App />); root.render(<App />); This way, the website can work on loading stuff in the background without bothering you while you're using it. Focus on what matters. Build Feature-Rich React Apps with MaterialPRO Build Feature-Rich React Apps with MaterialPRO MaterialPRO MaterialPRO Hooks React 19 introduces new hooks to help manage events and optimistic UI updates more effectively. The useEvent hook provides a simpler way to handle event listeners, while the useOptimistic hook helps manage optimistic UI states. Code Example: useEvent Hook Code Example: useEvent Hook import React, { useEvent } from 'react'; import React, { useEvent } from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; function App() { function App() { const handleClick = useEvent(() => { const handleClick = useEvent(() => { console.log('Button clicked!'); console.log('Button clicked!'); }); }); return ( return ( <div> <div> <button onClick={handleClick}>Click Me</button> <button onClick={handleClick}>Click Me</button> </div> </div> ); ); } } const root = createRoot(document.getElementById('root')); const root = createRoot(document.getElementById('root')); root.render(<App />); root.render(<App />); Code Example: useOptimistic Hook Code Example: useOptimistic Hook import React, { useOptimistic } from 'react'; import React, { useOptimistic } from 'react'; import { createRoot } from 'react-dom/client'; import { createRoot } from 'react-dom/client'; function App() { function App() { const [optimisticState, setOptimisticState] = useOptimistic(0); const [optimisticState, setOptimisticState] = useOptimistic(0); const handleClick = () => { const handleClick = () => { setOptimisticState((prevState) => prevState + 1); setOptimisticState((prevState) => prevState + 1); }; }; return ( return ( <div> <div> <button onClick={handleClick}>Increment</button> <button onClick={handleClick}>Increment</button> <div>Optimistic Count: {optimisticState}</div> <div>Optimistic Count: {optimisticState}</div> </div> </div> ); ); } } const root = createRoot(document.getElementById('root')); const root = createRoot(document.getElementById('root')); root.render(<App />); root.render(<App />); 🌟 Summary “ Don't Miss Out! “ 🌟 Summary “ Don't Miss Out! “ We talked about many things in this article. Let's quickly go over the cool new stuff coming in the next version of React 19. React 19 brings a host of new features and improvements that make building responsive, efficient, and scalable applications easier than ever. From concurrent rendering enhancements to new hooks like useEvent and useOptimistic, these updates provide powerful tools for React developers . Experiment with these new features in your projects, and take advantage of the latest advancements in the React ecosystem. powerful tools for React developers Build Modern React Apps Faster with Modernize . Modernize Stay tuned for more updates, and happy </> coding! Previously published at https://blog.wrappixel.com/react-19-whats-new-features/ Previously published at https://blog.wrappixel.com/react-19-whats-new-features/ Previously published at https://blog.wrappixel.com/react-19-whats-new-features/ https://blog.wrappixel.com/react-19-whats-new-features/

The New Features of React 19: What You Need to Know

প্রতিক্রিয়া 19 এর নতুন বৈশিষ্ট্য: আপনার যা জানা দরকার

Die neuen Funktionen von React 19: Was Sie wissen müssen

Las nuevas funciones de React 19: lo que necesita saber

Les nouvelles fonctionnalités de React 19 : ce que vous devez savoir

रिएक्ट 19 की नई विशेषताएं: आपको क्या जानना चाहिए

React 19 の新機能: 知っておくべきこと

React 19의 새로운 기능: 알아야 할 사항

Os novos recursos do React 19: o que você precisa saber

Новые возможности React 19: что вам нужно знать

React 19'un Yeni Özellikleri: Bilmeniz Gerekenler

Các tính năng mới của React 19: Những điều bạn cần biết

React 19 的新功能：你需要了解的内容

How to Build a Chatbot with Langchain, Next.js, OpenAI, and Supabase

React is a popular JavaScript library for building user interfaces. It’s known for its efficiency and focus on creating reusable UI components. One of the key features in React is the introduction of hooks which are function that hooks into the React state. One of those hooks is the useTransition hook. This hook allows the state change to happen without blocking the interface which results in a smooth experience. Understanding useTransition hook Let’s look at the following example to understand the useTransition hook better: import {useState} from "react"

const App = () => {
  const [post, setPost] = useState(undefined)

  const fetchData = async () => {
    await fetch("https://jsonplaceholder.org/posts/1")
      .then((result) => result.json())
      .then((result) => setPost(result))
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post?.title}</h2>
        <image src={post?.image} />
        <p>{post?.content}</p>
      </div>
      )}
      <button onClick={fetchData}>
        Get post
      </button>
    </div>
  )
}

export default App; When the user clicks the button, the UI may freeze during the fetch task depending on the internet speed or the complexity of the task executed inside the fetchData function. This can result in a poor user experience. Additionally, there's a risk of users spamming the button, potentially causing abuse of your application. These issues can easily be fixed using the useTransition hook. We can update the previous code to something like this: import {useState, useTransition} from "react"
import {ImSpinner2} from "react-icons/im"

const App = () => {
  const [pending, startTransition] = useTransition()
  const [post, setPost] = useState({})

  const fetchData = () => {
    startTransition( async () => {
      await fetch("https://jsonplaceholder.org/posts/1")
        .then((result) => result.json())
        .then((result) => setPost(result))
    })
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post.title}</h2>
        <image src={post.image} />
        <p>{post.content}</p>
      </div>
      )}
      <button
        disabled={pending} 
        onClick={fetchData}>
        {pending ? <ImSpinner2 className="animate-spin" /> : "Get post" }
      </button>
    </div>
  )
}

export default App; The invoked useTransition hook returns two values:  pending, which is true if the task is being executed, and a startTransition function, which contains the task that may be interrupted by more urgent tasks. In the example above, we wrap the fetch request inside an asynchronous arrow function within the startTransition function. We then modify the button to include a disabled attribute linked to pending, and change the label to show a spinner when the task is pending and "Get Post" when the task is not pending. This results in a smooth user experience, better performance, and protects your application from user misbehavior. Conclusion The useTransition hook is a game-changer for building high-performing React applications with smooth user experience. It ensures that the UI remains responsive during potentially slow operations and prevents UI freeze which enhances the overall user experience. React is a popular JavaScript library for building user interfaces. It’s known for its efficiency and focus on creating reusable UI components. One of the key features in React is the introduction of hooks which are function that hooks into the React state. One of those hooks is the useTransition hook. This hook allows the state change to happen without blocking the interface which results in a smooth experience. React useTransition Understanding useTransition hook Let’s look at the following example to understand the useTransition hook better: useTransition import {useState} from "react"

const App = () => {
  const [post, setPost] = useState(undefined)

  const fetchData = async () => {
    await fetch("https://jsonplaceholder.org/posts/1")
      .then((result) => result.json())
      .then((result) => setPost(result))
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post?.title}</h2>
        <image src={post?.image} />
        <p>{post?.content}</p>
      </div>
      )}
      <button onClick={fetchData}>
        Get post
      </button>
    </div>
  )
}

export default App; import {useState} from "react"

const App = () => {
  const [post, setPost] = useState(undefined)

  const fetchData = async () => {
    await fetch("https://jsonplaceholder.org/posts/1")
      .then((result) => result.json())
      .then((result) => setPost(result))
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post?.title}</h2>
        <image src={post?.image} />
        <p>{post?.content}</p>
      </div>
      )}
      <button onClick={fetchData}>
        Get post
      </button>
    </div>
  )
}

export default App; When the user clicks the button, the UI may freeze during the fetch task depending on the internet speed or the complexity of the task executed inside the fetchData function. This can result in a poor user experience. Additionally, there's a risk of users spamming the button, potentially causing abuse of your application. These issues can easily be fixed using the useTransition hook. useTransition We can update the previous code to something like this: We can update the previous code to something like this: import {useState, useTransition} from "react"
import {ImSpinner2} from "react-icons/im"

const App = () => {
  const [pending, startTransition] = useTransition()
  const [post, setPost] = useState({})

  const fetchData = () => {
    startTransition( async () => {
      await fetch("https://jsonplaceholder.org/posts/1")
        .then((result) => result.json())
        .then((result) => setPost(result))
    })
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post.title}</h2>
        <image src={post.image} />
        <p>{post.content}</p>
      </div>
      )}
      <button
        disabled={pending} 
        onClick={fetchData}>
        {pending ? <ImSpinner2 className="animate-spin" /> : "Get post" }
      </button>
    </div>
  )
}

export default App; import {useState, useTransition} from "react"
import {ImSpinner2} from "react-icons/im"

const App = () => {
  const [pending, startTransition] = useTransition()
  const [post, setPost] = useState({})

  const fetchData = () => {
    startTransition( async () => {
      await fetch("https://jsonplaceholder.org/posts/1")
        .then((result) => result.json())
        .then((result) => setPost(result))
    })
  }

  return(
    <div>
      {post !== undefined && (
      <div className="post-card">
        <h2>{post.title}</h2>
        <image src={post.image} />
        <p>{post.content}</p>
      </div>
      )}
      <button
        disabled={pending} 
        onClick={fetchData}>
        {pending ? <ImSpinner2 className="animate-spin" /> : "Get post" }
      </button>
    </div>
  )
}

export default App; The invoked useTransition hook returns two values: pending , which is true if the task is being executed, and a startTransition function, which contains the task that may be interrupted by more urgent tasks. pending startTransition In the example above, we wrap the fetch request inside an asynchronous arrow function within the startTransition function. startTransition We then modify the button to include a disabled attribute linked to pending , and change the label to show a spinner when the task is pending and "Get Post" when the task is not pending. disabled pending This results in a smooth user experience, better performance, and protects your application from user misbehavior. Conclusion The useTransition hook is a game-changer for building high-performing React applications with smooth user experience. It ensures that the UI remains responsive during potentially slow operations and prevents UI freeze which enhances the overall user experience. useTransition

How to Enhance React Apps with useTransition Hook

Infinite Scrolling vs Pagination: Making the Right Choice for React Apps

Everything You Need To Know About TypeScript

Heap allocations aren’t entirely bad, but when an object is allocated on a heap, it contributes to the garbage collection cycles, which in turn reduces overall application performance. Introduction One approach  to optimizing resource usage in async code is by using ValueTask<TResult> syntax to minimize heap allocations, which in turn reduces pressure on garbage collection and enhances overall performance. Learning Objectives The Problem with Heap Allocations Optimizing with ValueTask<TResult> When to Use ValueTask<TResult> Prerequisites for Developers Basic understanding of C# programming language. Getting Started Heap allocations aren’t entirely bad, but when an object is allocated on a heap, it contributes to the garbage collection cycles, which in turn reduces overall application performance. In the case of excessive heap allocation, the garbage collector can cause GC pauses. Bad Practice: Excessive Use of Task<TResult> Let’s consider a common asynchronous pattern that developers commonly use: public async Task<string> ReadDataAsync()
    {
        var data = await ReadFromStreamAsync(_stream);
        return ProcessData(data);
    } If the above-mentioned method is called more frequently, each request results in a new Task instance being allocated on heap memory. Over time, it leads to increased garbage collection overhead. Optimizing with ValueTask<TResult> By changing the return type from Task<TResult> to ValueTask<TResult>, we can reduce heap allocations public async ValueTask<string> ReadDataAsync()
    {
        var data = await ReadFromStreamAsync(_stream);
        return ProcessData(data);
    } The aforementioned optimization is beneficial for high-frequency async operations or methods that are expected to complete synchronously in a significant portion of time. When to Use ValueTask<TResult> High-frequency methods Performance-sensitive code Methods that often complete synchronously Create another class named TaskVsValueTask and add the following code snippet public static class TaskVsValueTask
    {
        public static async Task<string> FetchDataAsync()
        {
            // Simulate a delay to mimic fetching data
            await Task.Delay(1000);
            return "Data fetched using Task";
        }
    
        public static async ValueTask<string> FetchDataValueTaskAsync()
        {
            // Simulate a delay to mimic fetching data
            await Task.Delay(1000); // Note: Use Task.Delay for the sake of example.
            return "Data fetched using ValueTask";
        }
    } Execute from the main method as follows #region Day 20: Task vs. Value Task
    static async Task<string> ExecuteDay20()
    {
        Console.WriteLine("Fetching data with Task...");
        string result = await TaskVsValueTask.FetchDataAsync();
        Console.WriteLine(result);
    
        Console.WriteLine("Fetching data with ValueTask...");
        string resultValueTask = await TaskVsValueTask.FetchDataValueTaskAsync();
        Console.WriteLine(resultValueTask);
    
        return "Executed Day 20 successfully..!!";
    }
    #endregion Console Output Fetching data with Task...
    Data fetched using Task
    Fetching data with ValueTask...
    Data fetched using ValueTask Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: | | | Visit our other platforms: . Youtube X LinkedIn Dev.to GitHub More content at C# Programming

The 30-Day .NET Challenge - Day 20: Task vs. ValueTask

Finding the right AI model to build a workflow around is hard. With so many models available across different platforms, it’s impossible to know where to start or how to find the one that best fits your specific needs. That’s the problem I set out to solve with AIModels.fyi, the only search engine for discovering and comparing AI models from across the web. The site has a simple premise: describe your problem in natural language, and get back a list of AI models that can potentially solve it. For example, you might search for “I need a model that can help upscale my images without losing clarity” or “make my cat look like it’s singing”. The goal is to , not just ML engineers, to find useful AI tools for their projects. make it easy for anyone Under the hood, the search works by taking the user’s query and comparing it to a database of over 240,000 AI models from 7,500+ creators across major platforms like Hugging Face, Replicate, Cerebrium, and DeepInfra. When a user types in a search, the query gets embedded into a vector using OpenAI’s text-embedding-ada-002 model. This query vector is then compared to pre-computed vector representations of the model names, descriptions, and use cases in the database. The most similar models by cosine distance are returned as the search results. Here’s a simplified version of the core search logic I’ve been using for about six months: const fetchData = async (query) => {
  // Embed the search query
  const embeddingResponse = await openAi.createEmbedding({
    model: "text-embedding-ada-002",
    input: query,
  });
  
  const embedding = embeddingResponse.data.data[0].embedding;

// Find the most similar models in the vector database 
  const { data: modelsData, error } = await supabase.rpc("search_models", {
    query_embedding: embedding,
    similarity_threshold: 0.75,
    match_count: 10,
  });
  return modelsData;
}; This vector search approach works reasonably well for surfacing relevant models when there’s a direct overlap between the query terms and the model descriptions. However, it struggles with more abstract, complex, or niche queries where the user’s language doesn’t exactly match the technical terminology in the database. For example, I recently wanted to find a model that could animate a portrait image using an audio voice clip to create a talking head effect. I knew there were some good models out there for this, but my searches for things like “talking portrait from image and audio” weren’t turning up the results I expected. The problem was that my query terms didn’t have enough literal matches with the specific words used in the model descriptions, even though the semantic intent was similar. This got me thinking about ways to improve the search experience to better handle those kinds of abstract or complex queries. How could I make the system smarter at understanding the user’s true intent and mapping it to relevant models in the database? That’s when I came across the idea of Hypothetical Document Embeddings (HyDE) from after reading about it in . this research paper this Medium post Meet Mr. HyDE — The query expander! The key insight behind HyDE is to use a large language model (LLM) to expand the user’s short query into a more detailed hypothetical “ideal” document before embedding it for search. So, instead of directly matching the query embedding to the database embeddings, it first translates the query into a richer representation in the same semantic space as the real documents. Here’s how the process works: The user enters a natural language query expressing their needs, like “I want to convert an image into a 3D model.” This generated pseudo-document is then embedded into a dense vector using a model like OpenAI’s text-embedding-ada-002. The resulting embedding is used to query the vector database and find the most similar real model documents. The query is fed into an instruction-tuned LLM like GPT-3 to generate a hypothetical document. The prompt asks the model to imagine an ideal document for answering the query. For example: Query: I want to convert an image into a 3D model Hypothetical Document: There are several AI models available that can convert a 2D image into a 3D model. The process is known as single-view reconstruction or 3D estimation. It typically involves using deep learning to predict the depth map and 3D shape from the 2D input image. Some popular models for this task include Pix2Vox, Pixel2Mesh, AtlasNet, and OccNet. These models are trained on large datasets of 3D objects and can handle complex shapes. To use them, you provide an input image and the model will output a 3D mesh or voxel representation that you can render or edit further in 3D modeling tools… The LLM step helps bridge the gap between the user’s simple query and the more technical language used in the model descriptions. It expands on the initial query to infer additional relevant terms, concepts, and context that can help retrieve better matches. At the same time, using real document embeddings as the final search index keeps the results grounded and prevents hallucination. I implemented a basic version of HyDE on top of the existing AIModels search, and the initial results are promising. In some sample queries I tested, HyDE surfaced relevant models that the original keyword-matching approach missed. For the talking head portrait query, it was able to generate a hypothetical document with key terms like “lip sync”, “facial animation”, and “audio-driven animation”, which helped retrieve some strong model matches that the plain search had overlooked. two to three times more How to implement HyDE in your own search system Let me show you how HyDE can be added in on top of an existing semantic search system to dramatically improve its quality. Let’s start with a simplified code sketch based on my current search flow. Here’s the full file — you can glance through it in totality before we look at the individual parts: const fetchData = async (query) => {
  // Generate a hypothetical document embedding for the query 
  const hypotheticalDocument = await generateHypotheticalDocument(query);
  
  const embeddingResponse = await openAi.createEmbedding({
    model: "text-embedding-ada-002",
    input: hypotheticalDocument,
  });
  
  const embedding = embeddingResponse.data.data[0].embedding;

// Search the real model embeddings using the hypothetical document embedding
  const { data: modelsData, error } = await supabase.rpc("search_models", {
    query_embedding: embedding,
    similarity_threshold: 0.75,
    match_count: 10,
  });
  return modelsData;
};
const generateHypotheticalDocument = async (query) => {
  // Use GPT-3 to expand the query into a hypothetical ideal document
  const prompt = `The user entered the following search query: 
  "${query}"
  
  Please generate a detailed hypothetical document that would be highly relevant to answering this query. The document should use more technical language and expand on the key aspects of the query.
  Hypothetical Document:`;
  const response = await openAi.createCompletion({
    model: "text-davinci-002",
    prompt: prompt,
    max_tokens: 200,
    n: 1,
    stop: null,
    temperature: 0.5,
  });
  const hypotheticalDocument = response.data.choices[0].text.trim();
  return hypotheticalDocument;
} Let’s see how it works. We’ll start with the function, which is the main entry point for the search process. First up: fetchData const hypotheticalDocument = await generateHypotheticalDocument(query); This line calls the function (which we'll explain in more detail later) to generate a hypothetical ideal document based on the user's search query. generateHypotheticalDocument The hypothetical document is a key part of the HyDE approach, as it aims to capture the user’s search intent in a more detailed and technical way than the original query. const embeddingResponse = await openAi.createEmbedding({
  model: "text-embedding-ada-002",
  input: hypotheticalDocument,
});
const embedding = embeddingResponse.data.data[0].embedding; These lines use OpenAI’s model to generate an embedding vector for the hypothetical document. I think it's the best embedding option out there so far. text-embedding-ada-002 Embeddings are a way to represent text as a dense vector of numbers, where similar texts have similar vectors. This allows us to perform semantic similarity searches. By embedding the hypothetical document instead of the original query, we aim to get a vector representation that better captures the expanded search intent. Next up: const { data: modelsData, error } = await supabase.rpc("search_models", {
  query_embedding: embedding,
  similarity_threshold: 0.75,
  match_count: 10,
}); This part performs the actual similarity search in the model database. It is called a remote procedure ( ) on the Supabase database, passing in the embedding of the hypothetical document as the . search_models query_embedding The and parameters control how closely the results need to match and how many to return. similarity_threshold match_count The search looks for model embeddings that are most similar to the query embedding based on cosine similarity. Now let’s look at the function: generateHypotheticalDocument const prompt = `The user entered the following search query: 
"${query}"

Please generate a detailed hypothetical document that would be highly relevant to answering this query. The document should use more technical language and expand on the key aspects of the query.
Hypothetical Document:`; This part constructs the prompt that will be sent to the language model to generate the hypothetical document. The prompt includes the user’s original query and instructions for the model to generate a detailed, technical document that expands on the query’s key aspects. Crafting an effective prompt is crucial for guiding the language model to generate useful hypothetical documents. Now for the next part: const response = await openAi.createCompletion({
  model: "text-davinci-002",
  prompt: prompt,
  max_tokens: 200,
  n: 1,
  stop: null,
  temperature: 0.5,
}); These lines use OpenAI’s model to generate the hypothetical document based on the prompt. text-davinci-002 The parameter limits the length of the generated document while controls the randomness (higher values make the output more diverse but potentially less focused). Adjusting these parameters can help tune the quality and variety of the generated documents. max_tokens temperature Next, we have: const hypotheticalDocument = response.data.choices[0].text.trim(); This line extracts the generated hypothetical document text from the GPT-3 API response. The generated text is then returned to be used in the embedding step. Then we can just retreive the data as before, this time using the hypothetical document as the query, but getting a lot more relevant results due to the expanded search term and all it’s extra, juicy context! Recap — what did we just build? I hope the code and my explanation demonstrate how the HyDE approach can be implemented on top of an existing semantic search system. It’s not that hard! The key idea is this: By inserting the hypothetical document generation and embedding steps into the search pipeline, we aim to improve the search results by better capturing the user’s intent. To recap, the key parts were: Using a language model to expand the user’s query into a more detailed, technical hypothetical document Embedding the hypothetical document to get a vector representation that aligns with the model database Performing a similarity search between the hypothetical document embedding and the model embeddings to find the most relevant results Of course, this is just a simplified implementation (simplementation?), and there are many details and optimizations to consider in a real implementation. But it illustrates the core flow and components of the HyDE approach. Taking it further Since this is just an initial prototype there’s still a lot of room for experimentation and refinement. Some of the key open questions I’m thinking about: What’s the optimal prompt structure and output length for generating useful hypothetical documents? I’d like to try different prompt templates and output sizes to see how they impact result quality. How can the hypothetical documents be made more interpretable and transparent to users? It could be confusing if users don’t understand why certain terms are being added. I’m considering showing parts of the generated text as a “query interpretation” to provide more insight into the process. To what extent does the result quality depend on the specific LLM and embedding models used? I’m curious to benchmark different model combinations (e.g. GPT-4 vs GPT-3, vs OpenAI embeddings, etc.) to find the best recipe. Contriever How can this approach be efficiently scaled to work over millions of database entries? Inference on large LLMs like GPT-3 is expensive and slow. I’ll need to look into caching, optimizing, or distilling the models to make this viable at scale. I’m excited about the potential for language models to help make search interfaces like AIModels more intuitive and powerful for a wider audience. Bridging the semantic gap between how users naturally express their needs and how AI models are technically described feels like an important piece of the puzzle. Techniques like HyDE point a way toward search experiences that deeply understand the intent and meet users where they are. My long-term goal is to keep refining this interface until anyone can easily find relevant AI models for their needs, no matter their level of technical expertise. I’ll be sharing more details as I continue experimenting with HyDE and other approaches. If you’re curious to learn more about the technical side, I recommend checking out the original paper. And if you have ideas or feedback on the AIModels search experience, I’d love to hear from you! Let me know what you think in the comments. Also published . here

FETCHGOAT

fetchgoat.com

-- employees

Since n.d.

COMPANY RANKING

FETCHGOAT

EVERGREEN INDEX #4278

Representing this company? Click here to claim and customize this page!

FetchGoat WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

FETCHGOAT

fetchgoat.com

-- employees

Since n.d.

COMPANY RANKING

FETCHGOAT

EVERGREEN INDEX #4278

RELATED COMPANIESRANK

STORIES ABOUT FETCHGOAT

Representing this company? Click here to claim and customize this page!

FetchGoat WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!