The new Disney+ documentary 'Elton John: Never Too Late' details the pop star's career from his meteoric rise to fame to his farewell tour — and he says that lyrics written by Brandi Carlile heavily inspired the movie.

Brandi Carlile on Writing Elton John's 'Never Too Late' Doc Theme: 'He Doesn't Like to Say Nice Stuff About Himself'

This story is available exclusively to Business Insider subscribers. Become an Insider and start reading now. Have an account?

Disney Isn't Talking Politics, but Live Sports Is a New Battleground - Business Insider

A hacktivist group called NullBulge leaked data from almost 10,000 of Disney’s Slack channels in July.

Disney says most of its business will stop using Slack by the end of the year

Financial details of Disney's new deal with DirecTV weren't disclosed as part of Saturday's announcement.

ESPN and other channels return to DirecTV with a new Disney deal after a nearly 2-week blackout

The dispute lasted 13 days, impacting two weekends of programming.

Disney, ESPN networks restored for DirecTV customers ahead of college football weekend

After digitally recreating the late actor Peter Cushing's likeness for 2016's "Star Wars: Rogue One," Disney is being sued for doing so.

Disney Sued for Bringing Actor Back From the Dead for "Star Wars" Movie

Alexandra Canal is a Senior Reporter at Yahoo Finance.

Disney 'is playing hardball' with DirecTV over 'skinnier' bundles. Here's what's at stake.

Disneyland park announcer Bill Rogers and Disney California Adventure park announcer Camille Dixon will no longer be recording new park announcements.

Voices of Disneyland and Disney California Adventure replaced after decades of service

The most recent significant change was an emotional moment for one Walt Disney Imagineer, not because of what was being taken away, but what was being added. When I was going through the process of us, adding Pirate Redd, which is the first female pirate ...

Changing Pirates Of The Caribbean At Disneyland Was An ‘Emotional Moment’ For One Imagineer

Disney

Devcon 2024: The Historic Event for Ethereum Community and The Future of Web3

Devcon 2024: Istorijski događaj za Ethereum zajednicu i budućnost Web3

Devcon 2024: el evento histórico para la comunidad Ethereum y el futuro de la Web3

Devcon 2024: Ethereum komunitatearen gertaera historikoa eta Web3-ren etorkizuna

Devcon 2024: رویداد تاریخی برای انجمن اتریوم و آینده Web3

Devcon 2024: l'evento storico per la comunità Ethereum e il futuro di Web3

Devcon 2024: Ethereum コミュニティと Web3 の未来にとっての歴史的なイベント

„Devcon 2024“: istorinis „Ethereum“ bendruomenės įvykis ir „Web3“ ateitis

Devcon 2024: Peristiwa Bersejarah untuk Komuniti Ethereum dan Masa Depan Web3

Devcon 2024: د ایتیریم ټولنې لپاره تاریخي پیښه او د ویب 3 راتلونکی

Devcon 2024: Ҳодисаи таърихӣ барои ҷомеаи Ethereum ва ояндаи Web3

Devcon 2024: ታሪኻዊ ፍጻመ ንማሕበረሰብ ኤትሪዩምን መጻኢ ዌብ3ን።

I-Devcon 2024: Isiganeko seMbali ye-Ethereum Community kunye nekamva leWeb3

Table of Links Abstract and 1. Introduction Preliminaries


Proposed Approach
3.1 Notation
3.2 Nueral Networks on SPD Manifolds
3.3 MLR in Structure Spaces
3.4 Neural Networks on Grassmann Manifolds


Experiments


Conclusion and References A. Notations B. MLR in Structure Spaces C. Formulation of MLR from the Perspective of Distances to Hyperplanes D. Human Action Recognition E. Node Classification F. Limitations of our work G. Some Related Definitions H. Computation of Canonical Representation I. Proof of Proposition 3.2 J. Proof of Proposition 3.4 K. Proof of Proposition 3.5 L. Proof of Proposition 3.6 M. Proof of Proposition 3.11 N. Proof of Proposition 3.12 A NOTATIONS Tab. 3 presents the main notations used in our paper. B MLR IN STRUCTURE SPACES Algorithm 1 summarizes all steps for the computation of pseudo-gyrodistances in Theorem 3.11. Details of some steps are given below: Authors:
(1) Xuan Son Nguyen, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (xuan-son.nguyen@ensea.fr);
(2) Shuo Yang, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (son.nguyen@ensea.fr);
(3) Aymeric Histace, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (aymeric.histace@ensea.fr). This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. Table of Links Abstract and 1. Introduction Abstract and 1. Introduction Preliminaries Proposed Approach
3.1 Notation
3.2 Nueral Networks on SPD Manifolds
3.3 MLR in Structure Spaces
3.4 Neural Networks on Grassmann Manifolds Experiments Conclusion and References Preliminaries Preliminaries Preliminaries Proposed Approach 3.1 Notation 3.2 Nueral Networks on SPD Manifolds 3.3 MLR in Structure Spaces 3.4 Neural Networks on Grassmann Manifolds Proposed Approach 3.1 Notation 3.1 Notation 3.2 Nueral Networks on SPD Manifolds 3.2 Nueral Networks on SPD Manifolds 3.3 MLR in Structure Spaces 3.3 MLR in Structure Spaces 3.4 Neural Networks on Grassmann Manifolds 3.4 Neural Networks on Grassmann Manifolds Experiments Experiments Experiments Conclusion and References Conclusion and References Conclusion and References A. Notations A. Notations B. MLR in Structure Spaces B. MLR in Structure Spaces C. Formulation of MLR from the Perspective of Distances to Hyperplanes C. Formulation of MLR from the Perspective of Distances to Hyperplanes D. Human Action Recognition D. Human Action Recognition E. Node Classification E. Node Classification F. Limitations of our work F. Limitations of our work G. Some Related Definitions G. Some Related Definitions H. Computation of Canonical Representation H. Computation of Canonical Representation I. Proof of Proposition 3.2 I. Proof of Proposition 3.2 J. Proof of Proposition 3.4 J. Proof of Proposition 3.4 K. Proof of Proposition 3.5 K. Proof of Proposition 3.5 L. Proof of Proposition 3.6 L. Proof of Proposition 3.6 M. Proof of Proposition 3.11 M. Proof of Proposition 3.11 N. Proof of Proposition 3.12 N. Proof of Proposition 3.12 A NOTATIONS Tab. 3 presents the main notations used in our paper. B MLR IN STRUCTURE SPACES Algorithm 1 summarizes all steps for the computation of pseudo-gyrodistances in Theorem 3.11. Details of some steps are given below: Authors: (1) Xuan Son Nguyen, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (xuan-son.nguyen@ensea.fr); (2) Shuo Yang, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (son.nguyen@ensea.fr); (3) Aymeric Histace, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (aymeric.histace@ensea.fr). Authors: Authors: (1) Xuan Son Nguyen, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (xuan-son.nguyen@ensea.fr); (2) Shuo Yang, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (son.nguyen@ensea.fr); (3) Aymeric Histace, ETIS, UMR 8051, CY Cergy Paris University, ENSEA, CNRS, France (aymeric.histace@ensea.fr). This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. This paper is available on arxiv under CC by 4.0 Deed (Attribution 4.0 International) license. available on arxiv available on arxiv

Key Notations and Algorithm for Computing Pseudo-Gyrodistances in Structure Spaces

The HackerNoon Newsletter: Meet DeGate: HackerNoon Company of the Week (12/2/2024)

We are back with another Company of the Week feature with HackerNoon! For those who are reading this feature for the first time - every week, we invite to the podium a standout business that has left a big mark on the technological scene of the world. All the data and information are provided by HackerNoon’s tech company database, where we rank S&P 500 companies and top startups. This week, we are glad to feature Degate - A safe, low-fee platform to buy, sell, and manage crypto assets across multiple chains. Recently DeGate has announced a major update in our product roadmap: the upcoming launch of Cross-Chain Intent Trading, a secure and seamless way to trade tokens across blockchains, including all your favorite meme coins. Request your own Tech Company News Page on HackerNoon Meet DeGate: Fun Fact Do you know that DeGate’s security is backed by Ethereum? As one of the leading layer 2 rollups, DeGate is ranked Stage 2 on L2Beat (achieved by only the top 2 out of 52 rollups! DeGate also offers a bug bounty program that encourages security experts to identify and report vulnerabilities in the platform. The program’s rewards range from $1,000 to $1,110,000, depending on the severity of the bugs. The program covers almost all aspects of the DeGate platform, including smart contracts, circuits, and the web application. DeGate 🤝 HackerNoon Tech Community This year, DeGate partnered with HackerNoon to run the Ethereum Writing Contest for the Web3 community. Participants were invited to discuss why Ethereum is a leader in balancing decentralization, scalability, and security; examine how Layer 2 solutions extend the blockchain’s capabilities; analyze its role in a new global financial system; and consider how defi impacts governance, power structures, and trust. See the winners’ announcement here. Do you want to learn more about sponsoring a HackerNoon Writing Contest? Book a call today. That's all this week, folks! Stay Creative, Stay Iconic. The HackerNoon Team We are back with another Company of the Week feature with HackerNoon! Company of the Week For those who are reading this feature for the first time - every week, we invite to the podium a standout business that has left a big mark on the technological scene of the world. All the data and information are provided by HackerNoon’s tech company database , where we rank S&P 500 companies and top startups. tech company database This week, we are glad to feature Degate - A safe, low-fee platform to buy, sell, and manage crypto assets across multiple chains. Recently DeGate has announced a major update in our product roadmap: the upcoming launch of Cross-Chain Intent Trading , a secure and seamless way to trade tokens across blockchains, including all your favorite meme coins. Degate Cross-Chain Intent Trading Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Request your own Tech Company News Page on HackerNoon Meet DeGate: Fun Fact Do you know that DeGate’s security is backed by Ethereum ? As one of the leading layer 2 rollups, DeGate is ranked Stage 2 on L2Beat (achieved by only the top 2 out of 52 rollups! security is backed by Ethereum DeGate also offers a bug bounty program that encourages security experts to identify and report vulnerabilities in the platform. The program’s rewards range from $1,000 to $1,110,000, depending on the severity of the bugs. The program covers almost all aspects of the DeGate platform, including smart contracts, circuits, and the web application. offers a bug bounty program DeGate 🤝 HackerNoon Tech Community This year, DeGate partnered with HackerNoon to run the Ethereum Writing Contest for the Web3 community. Participants were invited to discuss why Ethereum is a leader in balancing decentralization, scalability, and security; examine how Layer 2 solutions extend the blockchain’s capabilities; analyze its role in a new global financial system; and consider how defi impacts governance, power structures, and trust. See the winners’ announcement here . Ethereum Writing Contest here Do you want to learn more about sponsoring a HackerNoon Writing Contest? Book a call today. Do you want to learn more about sponsoring a HackerNoon Writing Contest? Book a call today . Book a call today That's all this week, folks! That's all this week, folks! Stay Creative, Stay Iconic. Stay Creative, Stay Iconic. The HackerNoon Team The HackerNoon Team

Meet DeGate: HackerNoon Company of the Week

DeGate ukamp uñt’asipxam: HackerNoon Empresa de la Semana

Знаёмцеся, DeGate: Кампанія тыдня HackerNoon

Coneix DeGate: HackerNoon Company of the Week

Conozca a DeGate: la empresa de la semana de HackerNoon

הכירו את DeGate: חברת השבוע של HackerNoon

Upoznajte DeGate: HackerNoon tvrtka tjedna

DeGate 氏に会いましょう: HackerNoon の今週の企業

Temui DeGate: HackerNoon Company of the Week

Faceți cunoștință cu DeGate: Compania HackerNoon a săptămânii

டீகேட்டை சந்திக்கவும்: வாரத்தின் ஹேக்கர்நூன் நிறுவனம்

Gặp gỡ DeGate: Công ty HackerNoon của tuần

Hlangana ne-DeGate: Inkampani ye-HackerNoon yeviki

React has completely changed the process of building user interfaces for developers. In a nutshell, React teaches us the concept of components—namely, self-contained, reusable pieces of the UI. Designing reusable but maintainable and scalable components is the nucleus of any React application. In this blog post, we are going to examine several key component design patterns that will help you build sturdy and reusable UI components. Component design patterns are standardized methods of creating and organizing components to solve specific problems in UI design and architecture. These patterns offer a structured way of managing component logic, data flow, and UI composition to make it easier to build complex applications with a clean and maintainable codebase. 1. Presentational and Container Components One of the basic design patterns in React is separating presentational and container components. Presentational Components Presentational components are mainly concerned with how things look. They are mostly stateless and focus on rendering UI based on props. These components receive data and callbacks as props and do not handle data-fetching logic or state management. Example: const Button = ({ label, onClick }) => {
  //
return <button onClick={onClick}>{label}</button>;
}; Container Components Container components manage the state and logic of your application. They fetch data, handle stateful logic, and pass data down to presentational components. Example: class ButtonContainer extends React.Component {
    handleClick = () => {
        console.log('Button clicked!');
    };

    render()
return <Button label="Click Me" onClick={this.handleClick} />;
    }
} Benefits Separation of Concerns: This pattern makes your components easier to reason about by separating UI from business logic.
Reusability: Presentational components can be reused across different parts of the application without being tied to specific logic. 2. Higher-Order Components (HOCs) Higher-order components are a high-level pattern for the reuse of the logic of a component. A higher-order component is a function that accepts a component and returns a new component, maybe with extended functionality. Example Imagine you wish to add loading functionality. You can create an HOC to handle the loading state. const withLoading = (WrappedComponent) => {
    return class extends React.Component {
``
state = { loading: true };

        componentDidMount() {
            setTimeout(() => this.setState({ loading: false }), 2000); // Simulate API call
        }

        render()
return this.state.loading? <div>Loading.</div> : <WrappedComponent {.this.props} />;
        }
    };
};

const MyComponent = () => <div>Data Loaded!</div>;
const MyComponentWithLoading = withLoading(MyComponent); Advantages Code Reusability: HOCs allow shared logic without changing the original component.
Separation of Concerns: Logic for scenarios like data fetching, state management, or subscription can be encapsulated within HOCs. 3. Render Props Render props is a pattern for sharing code between components using a prop that is a function. This function will return a React element, allowing for greater flexibility. Example: You can create a simple counter that uses render props to control the displayed count. class Counter extends React.Component {
state = { count: 0 };

    increment = () => {
        this.setState((prevState) => ({ count: prevState.count + 1 }));
    };

    render() {
        return this.props.render(this.state.count, this.increment);
    }
}

const App = () => (
    <Counter render={(count, increment) => (
<div>
            <p>Count: {count}</p>
            <button onClick={increment}>Increment</button>
        </div>
    )} />
); Benefits Flexibility: The render props pattern allows for greater flexibility as components can control their rendering logic.
Shared Behavior: Easily shares stateful logic without modifying the component structure. 4. Compound Components The compound component pattern is a set of components working together. This pattern is quite useful when you want to create a more complex component with subcomponents that are tightly related. Example: Imagine a tab component: Tab and TabPanel. const Tabs = ({ children }) =>
const [activeIndex, setActiveIndex] = React.useState(0);
    
    return (
        <div>
            <div>
                {React.Children.map(children, (child, index) =>
React.cloneElement(child, {
                        isActive: index === activeIndex,
onClick: () => setActiveIndex(index),
                    })
                )}
</div>
            <div>
                {React.Children.toArray(children)[activeIndex].props.children}
            </div>
        </div>
    );
};

const Tab = ({ isActive, onClick, children }) => (
    <button style={{ fontWeight: isActive? 'bold' : 'normal' }} onClick={onClick}>
        {children}
    </button>
); Advantages Encapsulation: The compound component encapsulates the behavior and, hence the child can communicate freely without extra prop drilling.
Increased Readability: The depth hierarchy describes the structure between elements in clear terms. 5. Hooks for Reusability Hooks is extracted into React to be able to move the stateful logic around the code without affecting the component structure. Custom hooks are great for encapsulation of logics. Example Custom hook to use form's state. const useForm = (initialValues) => {
  const [values, setValues] = React.useState(initialValues);
 
  const handleChange = (event) =>
setValues((prevValues) => ({
           .prevValues,
            [event.target.name]: event.target.value,
        }));
    };

    return [values, handleChange];
};

const MyForm = () => {
const [formValues, handleChange] = useForm({ name: '', email: '' });

return (
<form>
    <input
        name="name"
        value={formValues.name}
        onChange={handleChange}
    />
    <input
        name="email"
        value={formValues.email}
        onChange={handleChange}
    />
</form>
)
);
}; Benefits Simplifies Logic Sharing: Custom hooks allow you to encapsulate logic in a way that is independent of components.
Clean Components: Promotes cleaner, more focused component implementation. Conclusion Crafting reusable UI components in React requires understanding and applying design patterns to promote code reusability, maintainability, and scalability. Whether you opt for presentational and container components, HOCs, render props, compound components, or hooks, each pattern has its unique benefits that can improve your development process. With these component design patterns in hand, you will become empowered to build complex applications even more efficiently as React continues to grow. Accept these patterns and begin experimenting with them within your projects, and see your components become flexible and easy to maintain. React has completely changed the process of building user interfaces for developers. In a nutshell, React teaches us the concept of components—namely, self-contained, reusable pieces of the UI. Designing reusable but maintainable and scalable components is the nucleus of any React application. In this blog post, we are going to examine several key component design patterns that will help you build sturdy and reusable UI components. Component design patterns are standardized methods of creating and organizing components to solve specific problems in UI design and architecture. These patterns offer a structured way of managing component logic, data flow, and UI composition to make it easier to build complex applications with a clean and maintainable codebase. 1. Presentational and Container Components One of the basic design patterns in React is separating presentational and container components. Presentational Components Presentational components are mainly concerned with how things look. They are mostly stateless and focus on rendering UI based on props. These components receive data and callbacks as props and do not handle data-fetching logic or state management. Example: Example: const Button = ({ label, onClick }) => {
  //
return <button onClick={onClick}>{label}</button>;
}; const Button = ({ label, onClick }) => {
  //
return <button onClick={onClick}>{label}</button>;
}; Container Components Container components manage the state and logic of your application. They fetch data, handle stateful logic, and pass data down to presentational components. Example: Example: class ButtonContainer extends React.Component {
    handleClick = () => {
        console.log('Button clicked!');
    };

    render()
return <Button label="Click Me" onClick={this.handleClick} />;
    }
} class ButtonContainer extends React.Component {
    handleClick = () => {
        console.log('Button clicked!');
    };

    render()
return <Button label="Click Me" onClick={this.handleClick} />;
    }
} Benefits Separation of Concerns: This pattern makes your components easier to reason about by separating UI from business logic. Reusability: Presentational components can be reused across different parts of the application without being tied to specific logic. Separation of Concerns : This pattern makes your components easier to reason about by separating UI from business logic. Separation of Concerns Reusability : Presentational components can be reused across different parts of the application without being tied to specific logic. Reusability 2. Higher-Order Components (HOCs) Higher-order components are a high-level pattern for the reuse of the logic of a component. A higher-order component is a function that accepts a component and returns a new component, maybe with extended functionality. Example Imagine you wish to add loading functionality. You can create an HOC to handle the loading state. const withLoading = (WrappedComponent) => {
    return class extends React.Component {
``
state = { loading: true };

        componentDidMount() {
            setTimeout(() => this.setState({ loading: false }), 2000); // Simulate API call
        }

        render()
return this.state.loading? <div>Loading.</div> : <WrappedComponent {.this.props} />;
        }
    };
};

const MyComponent = () => <div>Data Loaded!</div>;
const MyComponentWithLoading = withLoading(MyComponent); const withLoading = (WrappedComponent) => {
    return class extends React.Component {
``
state = { loading: true };

        componentDidMount() {
            setTimeout(() => this.setState({ loading: false }), 2000); // Simulate API call
        }

        render()
return this.state.loading? <div>Loading.</div> : <WrappedComponent {.this.props} />;
        }
    };
};

const MyComponent = () => <div>Data Loaded!</div>;
const MyComponentWithLoading = withLoading(MyComponent); Advantages Code Reusability: HOCs allow shared logic without changing the original component. Separation of Concerns: Logic for scenarios like data fetching, state management, or subscription can be encapsulated within HOCs. Code Reusability : HOCs allow shared logic without changing the original component. Code Reusability Separation of Concerns : Logic for scenarios like data fetching, state management, or subscription can be encapsulated within HOCs. Separation of Concerns 3. Render Props Render props is a pattern for sharing code between components using a prop that is a function. This function will return a React element, allowing for greater flexibility. Example: You can create a simple counter that uses render props to control the displayed count. class Counter extends React.Component {
state = { count: 0 };

    increment = () => {
        this.setState((prevState) => ({ count: prevState.count + 1 }));
    };

    render() {
        return this.props.render(this.state.count, this.increment);
    }
}

const App = () => (
    <Counter render={(count, increment) => (
<div>
            <p>Count: {count}</p>
            <button onClick={increment}>Increment</button>
        </div>
    )} />
); class Counter extends React.Component {
state = { count: 0 };

    increment = () => {
        this.setState((prevState) => ({ count: prevState.count + 1 }));
    };

    render() {
        return this.props.render(this.state.count, this.increment);
    }
}

const App = () => (
    <Counter render={(count, increment) => (
<div>
            <p>Count: {count}</p>
            <button onClick={increment}>Increment</button>
        </div>
    )} />
); Benefits Flexibility: The render props pattern allows for greater flexibility as components can control their rendering logic. Shared Behavior: Easily shares stateful logic without modifying the component structure. Flexibility : The render props pattern allows for greater flexibility as components can control their rendering logic. Flexibility Shared Behavior : Easily shares stateful logic without modifying the component structure. Shared Behavior 4. Compound Components The compound component pattern is a set of components working together. This pattern is quite useful when you want to create a more complex component with subcomponents that are tightly related. Example: Imagine a tab component: Tab and TabPanel . Tab TabPanel const Tabs = ({ children }) =>
const [activeIndex, setActiveIndex] = React.useState(0);
    
    return (
        <div>
            <div>
                {React.Children.map(children, (child, index) =>
React.cloneElement(child, {
                        isActive: index === activeIndex,
onClick: () => setActiveIndex(index),
                    })
                )}
</div>
            <div>
                {React.Children.toArray(children)[activeIndex].props.children}
            </div>
        </div>
    );
};

const Tab = ({ isActive, onClick, children }) => (
    <button style={{ fontWeight: isActive? 'bold' : 'normal' }} onClick={onClick}>
        {children}
    </button>
); const Tabs = ({ children }) =>
const [activeIndex, setActiveIndex] = React.useState(0);
    
    return (
        <div>
            <div>
                {React.Children.map(children, (child, index) =>
React.cloneElement(child, {
                        isActive: index === activeIndex,
onClick: () => setActiveIndex(index),
                    })
                )}
</div>
            <div>
                {React.Children.toArray(children)[activeIndex].props.children}
            </div>
        </div>
    );
};

const Tab = ({ isActive, onClick, children }) => (
    <button style={{ fontWeight: isActive? 'bold' : 'normal' }} onClick={onClick}>
        {children}
    </button>
); Advantages Encapsulation: The compound component encapsulates the behavior and, hence the child can communicate freely without extra prop drilling. Increased Readability: The depth hierarchy describes the structure between elements in clear terms. Encapsulation : The compound component encapsulates the behavior and, hence the child can communicate freely without extra prop drilling. Encapsulation Increased Readability : The depth hierarchy describes the structure between elements in clear terms. Increased Readability 5. Hooks for Reusability Hooks is extracted into React to be able to move the stateful logic around the code without affecting the component structure. Custom hooks are great for encapsulation of logics. Example Custom hook to use form's state. const useForm = (initialValues) => {
  const [values, setValues] = React.useState(initialValues);
 
  const handleChange = (event) =>
setValues((prevValues) => ({
           .prevValues,
            [event.target.name]: event.target.value,
        }));
    };

    return [values, handleChange];
};

const MyForm = () => {
const [formValues, handleChange] = useForm({ name: '', email: '' });

return (
<form>
    <input
        name="name"
        value={formValues.name}
        onChange={handleChange}
    />
    <input
        name="email"
        value={formValues.email}
        onChange={handleChange}
    />
</form>
)
);
}; const useForm = (initialValues) => {
  const [values, setValues] = React.useState(initialValues);
 
  const handleChange = (event) =>
setValues((prevValues) => ({
           .prevValues,
            [event.target.name]: event.target.value,
        }));
    };

    return [values, handleChange];
};

const MyForm = () => {
const [formValues, handleChange] = useForm({ name: '', email: '' });

return (
<form>
    <input
        name="name"
        value={formValues.name}
        onChange={handleChange}
    />
    <input
        name="email"
        value={formValues.email}
        onChange={handleChange}
    />
</form>
)
);
}; Benefits Simplifies Logic Sharing: Custom hooks allow you to encapsulate logic in a way that is independent of components. Clean Components: Promotes cleaner, more focused component implementation. Simplifies Logic Sharing : Custom hooks allow you to encapsulate logic in a way that is independent of components. Simplifies Logic Sharing Clean Components : Promotes cleaner, more focused component implementation. Clean Components Conclusion Crafting reusable UI components in React requires understanding and applying design patterns to promote code reusability, maintainability, and scalability. Whether you opt for presentational and container components, HOCs, render props, compound components, or hooks, each pattern has its unique benefits that can improve your development process. With these component design patterns in hand, you will become empowered to build complex applications even more efficiently as React continues to grow. Accept these patterns and begin experimenting with them within your projects, and see your components become flexible and easy to maintain.

Mastering React Component Design for Reusable UI Components 

How I Scraped YouTube Comments with Bright Data to Understand Customer Sentiment

Embeddings for RAG - A Complete Overview

التضمينات لـ RAG - نظرة عامة كاملة

Incrustaciones para RAG: una descripción general completa

Ներդրումներ RAG-ի համար՝ ամբողջական ակնարկ

Incorporamenti per RAG - Una panoramica completa

RAG の埋め込み - 完全な概要

Embeddings mpo na RAG - Botali ya mozindo ya mobimba

RAG įterpimai – visa apžvalga

RAG का लागि इम्बेडिङहरू - एक पूर्ण सिंहावलोकन

Încorporare pentru RAG - O prezentare generală completă

Embeddings ye RAG - A Complete Overview

การฝังสำหรับ RAG - ภาพรวมที่สมบูรณ์

RAG uchun oʻrnatishlar – Toʻliq koʻrib chiqish

China and Vietnam May Have Cracked The Perfect Recipe for Digital Complacency

China y Vietnam podrían haber encontrado la receta perfecta para la complacencia digital

Baliteke Txinak eta Vietnamek konplazentzia digitalaren errezeta perfektua hautsi izana

China e Vietnam poden ter a receita perfecta para a compracencia dixital

中国とベトナムはデジタル社会の自己満足の完璧なレシピを解明したかもしれない

ჩინეთმა და ვიეტნამმა შესაძლოა დაარღვიეს ციფრული თვითკმაყოფილების შესანიშნავი რეცეპტი

Қытай мен Вьетнам цифрлық қанағаттанудың тамаша рецептін бұзған болуы мүмкін

Kinija ir Vietnamas galėjo išnaudoti tobulą skaitmeninio pasitenkinimo receptą

چین او ویتنام ممکن د ډیجیټل اطمینان لپاره مناسب ترکیب مات کړي

Kina dhe Vietnami mund të kenë thyer recetën perfekte për vetëkënaqësinë dixhitale

Чин ва Ветнам шояд дорухатҳои комили қаноатмандии рақамиро шикастанд

จีนและเวียดนามอาจค้นพบสูตรสำเร็จสำหรับความประมาททางดิจิทัล

Maaaring Nabasag ng China at Vietnam ang Perpektong Recipe para sa Digital Complacency

As organizations increasingly incorporate machine learning into their operations, the cost of training models has become a significant concern. Training complex models requires computationally intensive resources, often involving powerful GPUs, vast memory, and fast storage, all of which come at a premium. When using cloud services like AWS, these costs can escalate rapidly, especially for prolonged usage or experiments involving large datasets. On the other hand, maintaining an on-premises infrastructure for model training is often capital-intensive and lacks the scalability required for peak demands. A hybrid cloud/on-premises approach provides an ideal middle ground, enabling organizations to manage costs effectively without sacrificing scalability or performance. A hybrid model leverages the strengths of both environments. Predictable workloads that require consistent compute resources can be handled on-premises, reducing reliance on cloud resources and allowing organizations to maximize the utility of their local infrastructure. Cloud resources, such as AWS, can then be used to handle dynamic, bursty, or resource-intensive tasks. This approach allows organizations to maintain cost control, optimize resource usage, and achieve flexibility in scaling their operations as demand fluctuates. One of the most significant ways to reduce costs in a hybrid setup is through the use of AWS Spot Instances. Spot Instances provide access to unused EC2 capacity at a fraction of the cost of On-Demand Instances, making them ideal for non-critical or checkpointable tasks. For example, in my own implementation, I used Spot Instances for early-stage experiments and hyperparameter tuning, where the computational demands were high but the need for immediate availability was lower. By coupling Spot Instances with robust failover strategies, such as replicating workloads to on-premises resources during interruptions, it is possible to achieve significant savings without compromising reliability. Storage optimization is another critical area for cost reduction. In a hybrid setup, organizations can use a tiered storage strategy, taking advantage of both on-premises and cloud storage. Large datasets that are frequently accessed during training can remain on-premises to reduce data transfer costs. Historical or infrequently accessed data can be archived in AWS S3 Glacier or S3 Intelligent-Tiering, where storage costs are lower. Data transfer between on-premises and the cloud is an area where expenses can quickly add up, so it’s crucial to use tools like AWS DataSync to move only the required subsets of data into the cloud. Compression and deduplication techniques further help minimize the volume of data transferred, reducing both costs and latency. A key to the success of any hybrid architecture is automation. AWS provides tools like AWS Lambda and Step Functions to streamline and automate the allocation of resources across on-premises and cloud environments. For example, I developed an automated workflow where training jobs were initiated on on-premises resources during off-peak hours. When resource thresholds were exceeded, the system dynamically escalated to AWS resources, ensuring seamless scaling while keeping costs under control. Such automation not only reduces manual effort but also ensures that cloud resources are used judiciously, maximizing cost efficiency. Another significant cost consideration in hybrid architectures is ensuring that the cloud environment is configured to match the exact requirements of workloads. Overprovisioning cloud resources is a common pitfall that leads to unnecessary expenses. By right-sizing AWS instances, organizations can ensure that they are not paying for unused capacity. Tools like AWS Savings Plans or Reserved Instances can provide further cost reductions for predictable workloads. In my implementation, we analyzed training workloads to identify consistent patterns and used Reserved Instances to handle these needs at a lower cost. For unpredictable peaks, Spot Instances offered a cost-effective solution. Data preprocessing and feature engineering are computationally demanding tasks that are often part of the model training pipeline. These tasks can be efficiently handled in the cloud, leaving the on-premises infrastructure focused on the core training activities. Preprocessing data in the cloud allows organizations to leverage AWS services like Lambda or Batch, which are designed for scalable, pay-as-you-go processing. This division of labor between preprocessing and training ensures that the most resource-intensive aspects of the workflow are distributed in a way that minimizes costs while maintaining performance. Monitoring and cost tracking are critical components of any cost-optimization strategy. AWS Cost Explorer and AWS Budgets provide detailed insights into spending patterns, allowing organizations to identify inefficiencies and adjust their strategies in real time. During my implementation, we set up cost alarms to notify the team when cloud usage exceeded predefined thresholds. This enabled us to make timely adjustments, such as reallocating workloads back to on-premises resources or scaling down cloud resources during periods of lower demand. A practical example of this approach can be seen in a project I worked on involving natural language processing (NLP) models. The core training of these models, which required high GPU utilization, was performed on-premises to leverage existing infrastructure and reduce cloud costs. However, tasks such as hyperparameter tuning and data augmentation, which involved running multiple parallel experiments, were offloaded to AWS. Using Spot Instances and tiered storage, we were able to handle the dynamic demands of these tasks without incurring excessive costs. By syncing datasets using AWS DataSync, we ensured that the cloud environment had access to the necessary data without duplicating the entire dataset, further optimizing costs. Data transfer costs often go unnoticed but can have a significant impact on the overall cost of cloud usage in a hybrid setup. By implementing strategies like edge processing, where raw data is processed on-premises before being transferred to the cloud, organizations can significantly reduce data transfer volumes. Establishing a dedicated connection to AWS, such as AWS Direct Connect, can also lower data transfer rates compared to using the public internet. The hybrid approach also offers resilience and flexibility. By distributing workloads between on-premises and cloud resources, organizations can avoid overreliance on either environment. During periods of high demand, the cloud acts as an extension of the on-premises infrastructure, providing the additional capacity needed. Conversely, when cloud resources are interrupted or costs spike unexpectedly, the on-premises infrastructure serves as a reliable fallback. This duality not only optimizes costs but also ensures operational continuity. In conclusion, implementing a hybrid cloud/on-premises solution for model training on AWS is a powerful strategy for optimizing costs while maintaining the flexibility and performance needed for modern AI workloads. By leveraging tools like Spot Instances, tiered storage, automated workflows, and cost monitoring, organizations can achieve substantial savings. The success of such a setup hinges on careful planning, workload profiling, and the strategic use of both environments. Drawing from my experience, I can confidently say that a well-executed hybrid strategy is a transformative approach for organizations looking to balance innovation with cost efficiency. As organizations increasingly incorporate machine learning into their operations, the cost of training models has become a significant concern. Training complex models requires computationally intensive resources, often involving powerful GPUs, vast memory, and fast storage, all of which come at a premium. When using cloud services like AWS, these costs can escalate rapidly, especially for prolonged usage or experiments involving large datasets. On the other hand, maintaining an on-premises infrastructure for model training is often capital-intensive and lacks the scalability required for peak demands. A hybrid cloud/on-premises approach provides an ideal middle ground, enabling organizations to manage costs effectively without sacrificing scalability or performance. A hybrid model leverages the strengths of both environments. Predictable workloads that require consistent compute resources can be handled on-premises, reducing reliance on cloud resources and allowing organizations to maximize the utility of their local infrastructure. Cloud resources, such as AWS, can then be used to handle dynamic, bursty, or resource-intensive tasks. This approach allows organizations to maintain cost control, optimize resource usage, and achieve flexibility in scaling their operations as demand fluctuates. One of the most significant ways to reduce costs in a hybrid setup is through the use of AWS Spot Instances. Spot Instances provide access to unused EC2 capacity at a fraction of the cost of On-Demand Instances, making them ideal for non-critical or checkpointable tasks. For example, in my own implementation, I used Spot Instances for early-stage experiments and hyperparameter tuning, where the computational demands were high but the need for immediate availability was lower. By coupling Spot Instances with robust failover strategies, such as replicating workloads to on-premises resources during interruptions, it is possible to achieve significant savings without compromising reliability. Storage optimization is another critical area for cost reduction. In a hybrid setup, organizations can use a tiered storage strategy, taking advantage of both on-premises and cloud storage. Large datasets that are frequently accessed during training can remain on-premises to reduce data transfer costs. Historical or infrequently accessed data can be archived in AWS S3 Glacier or S3 Intelligent-Tiering, where storage costs are lower. Data transfer between on-premises and the cloud is an area where expenses can quickly add up, so it’s crucial to use tools like AWS DataSync to move only the required subsets of data into the cloud. Compression and deduplication techniques further help minimize the volume of data transferred, reducing both costs and latency. A key to the success of any hybrid architecture is automation. AWS provides tools like AWS Lambda and Step Functions to streamline and automate the allocation of resources across on-premises and cloud environments. For example, I developed an automated workflow where training jobs were initiated on on-premises resources during off-peak hours. When resource thresholds were exceeded, the system dynamically escalated to AWS resources, ensuring seamless scaling while keeping costs under control. Such automation not only reduces manual effort but also ensures that cloud resources are used judiciously, maximizing cost efficiency. Another significant cost consideration in hybrid architectures is ensuring that the cloud environment is configured to match the exact requirements of workloads. Overprovisioning cloud resources is a common pitfall that leads to unnecessary expenses. By right-sizing AWS instances, organizations can ensure that they are not paying for unused capacity. Tools like AWS Savings Plans or Reserved Instances can provide further cost reductions for predictable workloads. In my implementation, we analyzed training workloads to identify consistent patterns and used Reserved Instances to handle these needs at a lower cost. For unpredictable peaks, Spot Instances offered a cost-effective solution. Data preprocessing and feature engineering are computationally demanding tasks that are often part of the model training pipeline. These tasks can be efficiently handled in the cloud, leaving the on-premises infrastructure focused on the core training activities. Preprocessing data in the cloud allows organizations to leverage AWS services like Lambda or Batch, which are designed for scalable, pay-as-you-go processing. This division of labor between preprocessing and training ensures that the most resource-intensive aspects of the workflow are distributed in a way that minimizes costs while maintaining performance. Monitoring and cost tracking are critical components of any cost-optimization strategy. AWS Cost Explorer and AWS Budgets provide detailed insights into spending patterns, allowing organizations to identify inefficiencies and adjust their strategies in real time. During my implementation, we set up cost alarms to notify the team when cloud usage exceeded predefined thresholds. This enabled us to make timely adjustments, such as reallocating workloads back to on-premises resources or scaling down cloud resources during periods of lower demand. A practical example of this approach can be seen in a project I worked on involving natural language processing (NLP) models. The core training of these models, which required high GPU utilization, was performed on-premises to leverage existing infrastructure and reduce cloud costs. However, tasks such as hyperparameter tuning and data augmentation, which involved running multiple parallel experiments, were offloaded to AWS. Using Spot Instances and tiered storage, we were able to handle the dynamic demands of these tasks without incurring excessive costs. By syncing datasets using AWS DataSync, we ensured that the cloud environment had access to the necessary data without duplicating the entire dataset, further optimizing costs. Data transfer costs often go unnoticed but can have a significant impact on the overall cost of cloud usage in a hybrid setup. By implementing strategies like edge processing, where raw data is processed on-premises before being transferred to the cloud, organizations can significantly reduce data transfer volumes. Establishing a dedicated connection to AWS, such as AWS Direct Connect, can also lower data transfer rates compared to using the public internet. The hybrid approach also offers resilience and flexibility. By distributing workloads between on-premises and cloud resources, organizations can avoid overreliance on either environment. During periods of high demand, the cloud acts as an extension of the on-premises infrastructure, providing the additional capacity needed. Conversely, when cloud resources are interrupted or costs spike unexpectedly, the on-premises infrastructure serves as a reliable fallback. This duality not only optimizes costs but also ensures operational continuity. In conclusion, implementing a hybrid cloud/on-premises solution for model training on AWS is a powerful strategy for optimizing costs while maintaining the flexibility and performance needed for modern AI workloads. By leveraging tools like Spot Instances, tiered storage, automated workflows, and cost monitoring, organizations can achieve substantial savings. The success of such a setup hinges on careful planning, workload profiling, and the strategic use of both environments. Drawing from my experience, I can confidently say that a well-executed hybrid strategy is a transformative approach for organizations looking to balance innovation with cost efficiency.

Optimizing AI/ML Compute Costs With a Hybrid Cloud/on-Premises Approach

DreamLLM: What We Can Conclude From This Comprehensive Framework?

Stories, News & Mentions about COM

Com’s Stories on HackerNoon

Com's News & Mentions