SAM-DIMENSION

samdimension

Authors:
(1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com;
(2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Table of Links Abstract and Introduction
Related Works
Purpose
Methods
Results
Discussion
Conclusion and Bibliography 2. Related Works Existing ESG-related research falls under two main categories. Some papers aim to correlate ESG performance with financial performance and see if a company’s Corporate Social Responsibility (CSR) can be used to predict future stock performance (Jain et al., 2019). Other papers propose new data-driven methods for enhancing and automating ESG rating measurement to avoid existing fallacies/inefficiencies (Hisano et al., 2020; Krappel et al., 2021; Liao et al., 2017; Lin et al., 2018; Shahi et al., 2011; Sokolov et al., 2021; Venturelli et al., 2017; Wicher et al., 2019). This paper will fall into the latter category. Since many firms publish sustainability reports on an annual basis, many researchers use this content for analysis. This is typically done using text mining to identify ESG topics and trends. In order to parse out and leverage this data, researchers have created classification models that can classify sentences/paragraphs into various ESG subdimensions (Liao et al., 2017; Lin et al., 2018). Additionally, some researchers have used these text classification algorithms to analyze the completeness of sustainability reports (Shahi et al., 2011). This is because companies sometimes limit disclosure regarding negative ESG aspects within their filings. Both tools can assist in automatic ESG scoring using company filings, which increases access for companies without ESG coverage. However, there are deficiencies in solely relying on self-reported filings for analysis since it fails to consider omitted data or newer developments. As a result, researchers have been testing out alternative methods to solve this. For instance, some researchers utilize Fuzzy Expert System (FES) or a Fuzzy Analytic Network Process (FANP), pulling data from quantitative indicators (i.e., metrics provided by the Global Reporting Initiative) and qualitative features from surveys/interviews (Venturelli et al., 2017; Wicher et al., 2019). Others collected data from online social networks like Twitter to analyze a company’s sustainability profile. For example, some used Natural Language Processing (NLP) frameworks to classify Tweets into various ESG topics and determine whether they are positive or negative (Sokolov et al., 2021). Furthermore, some used heterogeneous information networks that combined data from various negative news datasets and used machine learning to predict ESG (Hisano et al., 2020). Finally, others explored the viability of using fundamental data such as a company’s profile and financials to predict ESG (Krappel et al., 2021). Overall, all these methods aimed to improve self-reported filings by using more balanced, unbiased, and real-time data. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Authors: Authors: (1) Aarav Patel, Amity Regional High School – email: aarav.dhp@gmail.com; (2) Peter Gloor, Center for Collective Intelligence, Massachusetts Institute of Technology and Corresponding author – email: pgloor@mit.edu. Table of Links Abstract and Introduction Related Works Purpose Methods Results Discussion Conclusion and Bibliography Abstract and Introduction Abstract and Introduction Related Works Related Works Purpose Purpose Methods Methods Results Results Discussion Discussion Conclusion and Bibliography Conclusion and Bibliography 2. Related Works Existing ESG-related research falls under two main categories. Some papers aim to correlate ESG performance with financial performance and see if a company’s Corporate Social Responsibility (CSR) can be used to predict future stock performance (Jain et al., 2019). Other papers propose new data-driven methods for enhancing and automating ESG rating measurement to avoid existing fallacies/inefficiencies (Hisano et al., 2020; Krappel et al., 2021; Liao et al., 2017; Lin et al., 2018; Shahi et al., 2011; Sokolov et al., 2021; Venturelli et al., 2017; Wicher et al., 2019). This paper will fall into the latter category. Since many firms publish sustainability reports on an annual basis, many researchers use this content for analysis. This is typically done using text mining to identify ESG topics and trends. In order to parse out and leverage this data, researchers have created classification models that can classify sentences/paragraphs into various ESG subdimensions (Liao et al., 2017; Lin et al., 2018). Additionally, some researchers have used these text classification algorithms to analyze the completeness of sustainability reports (Shahi et al., 2011). This is because companies sometimes limit disclosure regarding negative ESG aspects within their filings. Both tools can assist in automatic ESG scoring using company filings, which increases access for companies without ESG coverage. However, there are deficiencies in solely relying on self-reported filings for analysis since it fails to consider omitted data or newer developments. As a result, researchers have been testing out alternative methods to solve this. For instance, some researchers utilize Fuzzy Expert System (FES) or a Fuzzy Analytic Network Process (FANP), pulling data from quantitative indicators (i.e., metrics provided by the Global Reporting Initiative) and qualitative features from surveys/interviews (Venturelli et al., 2017; Wicher et al., 2019). Others collected data from online social networks like Twitter to analyze a company’s sustainability profile. For example, some used Natural Language Processing (NLP) frameworks to classify Tweets into various ESG topics and determine whether they are positive or negative (Sokolov et al., 2021). Furthermore, some used heterogeneous information networks that combined data from various negative news datasets and used machine learning to predict ESG (Hisano et al., 2020). Finally, others explored the viability of using fundamental data such as a company’s profile and financials to predict ESG (Krappel et al., 2021). Overall, all these methods aimed to improve self-reported filings by using more balanced, unbiased, and real-time data. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. This paper is available on arxiv under CC BY-NC-ND 4.0 DEED license. available on arxiv

Creating a Systematic ESG Scoring System: Related Works

একটি পদ্ধতিগত ESG স্কোরিং সিস্টেম তৈরি করা: সম্পর্কিত কাজ

Erstellen eines systematischen ESG-Bewertungssystems: Verwandte Arbeiten

Creación de un sistema sistemático de puntuación ESG: trabajos relacionados

Créer un système de notation ESG systématique : travaux connexes

एक व्यवस्थित ईएसजी स्कोरिंग प्रणाली बनाना: संबंधित कार्य

体系的なESGスコアリングシステムの構築：関連研究

체계적인 ESG 채점 시스템 구축: 관련 연구

Criando um Sistema Sistemático de Pontuação ESG: Trabalhos Relacionados

Создание систематической системы оценки ESG: сопутствующие работы

Sistematik ÇSY Puanlama Sistemi Oluşturma: İlgili Çalışmalar

Tạo hệ thống tính điểm ESG có hệ thống: Công việc liên quan

创建系统的 ESG 评分体系：相关工作

Quite commonly in our applications, we need to create interactive report builders to let users build custom reports and dashboards. This usually involves selecting the metrics, groupings, date ranges, filters, and chart types. To help developers build such interactive components, we've created a query builder component in Cube.js client libraries. We've already covered how to use it in the , and in this blog post, we'll talk about using it with Vue.js. The query builder component uses the technique and lets developers implement their own render logic. This way it gives maximum flexibility for building a custom-tailored UI with minimal API. Below you can see the demo of the query builder component with . React client library scoped slots Vuetify You can find the and . live demo of the example here its source code is available on Github Setup a Demo Backend *if you already have Cube.js backend up and running you can skip this step.* Let's start by setting up a database with some sample data. We'll use PostgreSQL and our example e-commerce dataset for this tutorial. You can download and import it by running the following commands. $ curl <http://cube.dev/downloads/ecom-dump.sql> > ecom-dump.sql
$ createdb ecom
$ psql --dbname ecom -f ecom-dump.sql Next, install the Cube.js CLI if you don't have it already, and create a new project. $ npm install -g cubejs-cli
$ cubejs create -d postgres vue-query-builder Cube.js uses environment variables for configuration, which starts with `CUBEJS_`. To configure the connection to our database, we need to specify the DB type and name. In the Cube.js project folder replace the contents of `.env` file with the following: CUBEJS_DB_NAME=ecom
CUBEJS_DB_TYPE=postgres
CUBEJS_API_SECRET=SECRET Now that we have everything configured, let's start the Cube.js development server with the following command. $ npm run dev Navigate to in your browser to access the Cube.js Playground. It is a development environment that generates the Cube.js schema, creates scaffolding for charts, and lets you test your queries and debug them. It also has its own query builder, which lets you generate charts with different charting libraries. http://localhost:4000 Now let’s move on to building our own query builder with Vue.js! 💻 Building a Query Builder We're going to use to generate a new project. Run the following command to install Vue CLI if you don't have it already. Vue CLI $ npm install -g @vue/cli To a create a new project with Vue CLI run the following command inside the Cube.js project folder. $ vue create dashboard-app To render the UI for query builder we are going to use , a Vue UI Library with material components. Let's add it to our project. Run the following command inside the `dashboard-app` folder. Vuetify $ vue add vuetify To create our color scheme you can open `src/plugins/vuetify.js` and add this code: import Vue from 'vue'
import Vuetify from 'vuetify/lib'

Vue.use(Vuetify)

export default new Vuetify({ }) +  theme: { +    themes: { +      light: { +        primary: '#7A77FF', +      }, +    }, +  }, Now we can start our frontend application. $ yarn serve You can check your newly created Vue app at . Next, let's install dependencies we'll need for building our Query Builder: Cube.js Vue client, Vue Chartkick, and Chart.js. http://localhost:8080 $ npm install --save vue-chartkick chart.js core-js @cubejs-client/core @cubejs-client/vue Let's create a first simple Query Builder to allow users to select the metric from the dropdown list and then render it as a line chart over time. Cube.js Query Builder component can load the list of available measures based on the data schema from the backend. We can access these measures as an `availableMeasures` slot prop. We'll render that list with the `v-select` component from Vuetify. Then when the user selects the measure, we're going to use a `setMeasures` slot prop to update the measures in our query and finally render the query result as a line chart with Vue Chartkick and Chart.js. . You can learn more about other slot props in the Query Builder component in the docs Replace the content of the `src/HelloWord.vue` file with the following. < > template < = > v-container fluid class "text-center background pa-0" < = = = > query-builder :cubejs-api "cubejsApi" :query "query" style "width: 100%" < = > template v-slot:builder "{measures,setMeasures,availableMeasures}" < = > v-container fluid class "pa-4 pa-md-8 pt-6 background-white" < > v-row < = = > v-col cols "12" md "2" < = = @ = = /> v-select multiple label "Measures" outlined hide-details :value "measures.map(i => (i.name))" change "setMeasures" :items "availableMeasures.map(i => (i.name))" </ > v-col </ > v-row </ > v-container </ > template < = > template v-slot "{ resultSet }" < = = > div class "pa-4 pa-md-8" v-if "resultSet" < = > div class "border-light pa-4 pa-md-12" < = = > line-chart legend "bottom" :data "series(resultSet)" </ > line-chart </ > div </ > div </ > template </ > query-builder </ > v-container </ > template < > script cubejs { QueryBuilder } cubejsApi = cubejs( , { : }); { : , : {
    QueryBuilder
  }, : { query = { : , : [
        { : , : , : }
      ],
    } {
      cubejsApi,
      query
    }
  }, : {
    series (resultSet) { resultSet.series().map( ({ : series.key, : series.series.map( [row.x, row.value])
      }))
    }
  }
} import from '@cubejs-client/core' import from '@cubejs-client/vue' const "CUBEJS-TOKEN" apiUrl `http://localhost:4000/cubejs-api/v1` export default name 'HelloWorld' components data => () const limit 100 timeDimensions dimension 'LineItems.createdAt' granularity 'day' dateRange 'Last 30 days' return methods return => series name data => row </ > script < > style scopped { : ; : ;
  } { : ;
  } { : ; : ;
  } .background background #F3F3FB min-height 100vh .background-white background #fff .border-light background #FFFFFF border-radius 8px </ > style Now we can use updated `HelloWorld` component in our `App` component. Replace the content of the `src/App.vue` with the following. < > template < > v-app < = > v-app-bar app color "#43436B" dark < = > div class "d-flex align-center" < = = = = /> v-img alt "Vuetify Logo" class "shrink mr-2" contain src "<https://cube.dev/downloads/logo-full.svg>" transition "scale-transition" </ > div </ > v-app-bar < > v-main < /> HelloWorld </ > v-main </ > v-app </ > template < > script HelloWorld { : , : {
    HelloWorld
  }
} import from './components/HelloWorld' export default name 'App' components </ > script The last small change we need to make is to register the `VueChartkick` plugin. Update the `src/main.js` file. import Vue from 'vue'
import App from './App.vue'
import vuetify from './plugins/vuetify' Vue.config.productionTip = false new Vue({
  vuetify,
  render: h => h(App)
}).$mount('#app') + import Chart from 'chart.js' + import VueChartkick from 'vue-chartkick' + Vue.use(VueChartkick, { adapter: Chart }) We've just built our first simple query builder 🎉. Navigate to in your browser and you should be able to test it out. http://localhost:8080/ We can already plot the count of orders over time. But what if we want to see the breakdown of orders by the status? To do so, we'd need to introduce the dimensions dropdown to let users select the grouping option. We'll use more slot props for this: `dimensions`, `availableDimensions` and `setDimensions`. They work they same as slot props for measures allowing us to list the available dimensions and update the list of selected ones. Update `src/HelloWorld.vue` file. <template>
  <v-container fluid class="text-center background pa-0">
    <query-builder :cubejs-api="cubejsApi" :query="query" style="width: 100%"> <v-container fluid class="pa-4 pa-md-8 pt-6 background-white">
            <v-row>
	          <v-col cols="12" md="2">
	            <v-select
	              multiple
	              label="Measures"
	              outlined
		          hide-details
	              :value="measures.map(i => (i.name))"
	              @change="setMeasures"
	              :items="availableMeasures.map(i => (i.name))"
	            />
	          </v-col> </v-row>
          </v-container>
        </template>
        <template v-slot="{ resultSet }">
	        <div class="pa-4 pa-md-8" v-if="resultSet">
	          <div class="border-light pa-4 pa-md-12">
	            <line-chart legend="bottom" :data="series(resultSet)"></line-chart>
	          </div>
	        </div>
	      </template>
      </query-builder>
  </v-container>
</template> -    <template v-slot:builder="{measures,setMeasures,availableMeasures}" +    <template +       v-slot:builder="{ +       measures, +       setMeasures, +       availableMeasures, +       dimensions, +       setDimensions, +       availableDimensions +       }" +     > +             <v-col cols="12" md="2"> +               <v-select +                 multiple +                 label="Dimensions" +                 outlined +                 hide-details +                 :value="dimensions.map(i => (i.name))" +                 @change="setDimensions" +                 :items="availableDimensions.map(i => (i.name))" +               /> +             </v-col> Refresh your browser and now you should be able to select the dimensions for grouping as well! That's all for this tutorial. Congratulations on completing it! 🎉 There are other controls you can add to your query builder like filters, date range, and granularity, as well as chart type selector. You can find and . a more complicated example with all these controls here its source code here on Github Please send any comments or feedback you might have to this . Thank you and I hope you found this tutorial helpful! Slack Community

Vue Query Builder with Cube.js - A Tutorial

Since the release of React 16.8, I’ve been enjoying the ability to use to create composable and reusable logic, and write fewer class components with explicit lifecycle methods. This not only leads to a more enjoyable dev experience, but (in my opinion) a more readable code base. hooks Today I am going to introduce a few hooks and use them to build a simple responsive layout. Using the Context API, we can ensure that all components have access to up-to-date window dimensions, without relying on lifecycles to attach and clean up event listeners. The Finished Product v responsive The finished code can be found on . github First Steps To begin, we will scaffold a new react app with , and add the wonderful css library: create-react-app bulma $ create-react-app my-responsive-app$ cd !$$ yarn add bulma node-sass$ yarn start That’s it for getting started. We are going to be using for some nice-looking components, but we will handle all the responsive design using React and JS. bulma On Being Responsive Handling different device sizes is pretty important from what I hear. What is responsive web design exactly? According to the internet: ( ) is an approach to that makes web pages render well on a variety of devices and window or screen sizes Responsive web design RWD web design — Wikipedia Okay! This seems like something we can handle in CSS, using relative units and media queries, right? Well, yes and no. Most of the time, CSS can handle the job if the job is simply arranging content on a page. However, sometimes, you may want to change render based on the page size, and for this, you almost definitely will need some (or other dark magic). behavior Javascript The React Way So React is all about creating reusable bits of presentation logic (components) and using them to compose views. Now that we have hooks, we can actually simplify this composition further: hooks allow us to encapsulate certain behaviors, often composed of multiple hooks, into functions that integrate directly into React’s renderer (using the new , which we won’t dive into here) to automatically update the components using them. React Fiber So? So, this old thing ( if you’ve written this in one of your React Apps): /clap class NavBar extends Component {state = { open: false } setOpen = open => this.setState({ open }) render() {return (this.state.open ?<NavMenu /> :<HamburgerButton onClick={() => this.setOpen(true)} />)}} Has now become: function NavBar() {const [open, setOpen] = useState(false)return (open ?<NavMenu /> :<HamburgerButton onClick={() => setOpen(true)} />)} If this doesn’t seem like a big deal yet, you can check out some of the cool things people have made with hooks here: https://codesandbox.io/react-hooks The point is, hooks are nice. We don’t have to type as much, and we almost never have to worry about or the status of the class properties proposal (thank you babel) again. componentDidMount/componentDidUpdate/setState Now that we know what responsive web design is (kind of), and hooks (also kind of), let’s use both of them to build something! To start, let’s implement our fundamental building block (for this article): the component. ResponsiveLayout To start, we’ll create a good old functional component (in ), that accepts three props: , , and . src/components/ResponsiveLayout/index.js renderDesktop renderMobile breakpoint import { useState, useEffect } from 'react' const ResponsiveLayout = ({ breakpoint, renderMobile, renderDesktop }) => {const [width, setWidth] = useState(window.innerWidth)useEffect(() => {const handleResize = () => {setWidth(window.innerWidth)}window.addEventListener(‘resize’, handleResize)return () => { window.removeEventListener(‘resize’, handleResize) }}, [])return (width > breakpoint ? renderDesktop() : renderMobile())} We are simply reading the window’s width when the component gets created and storing it using the hook, then establishing an event listener inside of our hook. useState useEffect useState allows us to have stateful functional components! you call and it returns a pair of . Because it returns an array and not an object, you are free to name these references however you please. Most importantly, hooks into React DOM and triggers a render when you use the function returned from it, so it works just like would for class components. useState useState(initialValue) [state, setState] useState setState this.setState useEffect will normally run its code every time a component re-renders, however it accepts a second argument, an array of variables, that inform that it should only re-run when a value inside the array is changed. When provided an empty array, it will never re-run, so it behaves exactly like ! The return value for should be a cleanup function, if required, so that it can be run before the effect is re-run, or the component is being removed from the DOM. Here we specify an anonymous function that will remove the event listener when this component is un-mounting (sound familiar? this is what we’ve been doing inside of ). useEffect useEffect componentDidMount useEffect componentWillUnmount Now this seems pretty good, but what happens if there are multiple places where things on the page need to render based on a breakpoint? We shouldn’t be setting up new event listeners for the same event every time one of these components is mounting, especially since we only have one window resize to listen for. Enter useContext One of the ways hooks have really made things better is when using the Context API. Previously, using Context required using Consumer and Provider components, and utilizing the Consumer in any component that needed access to the value. This led to devs creating Higher Order Components for providing context as props (for example, 's ) or simply very verbose code. Now, with , we no longer have to use Components to make children aware of values from Context. react-redux connect useContext Context.Consumer Let’s rewrite the above component, using Context and an App-wide . WindowDimensionsProvider In : src/components/WindowDimensionsProvider/index.js import React, { createContext, useContext, useState, useEffect } from 'react' const WindowDimensionsCtx = createContext(null) const WindowDimensionsProvider = ({ children }) => {const [dimensions, setDimensions] = useState({width: window.innerWidth,height: window.innerHeight,})useEffect(() => {const handleResize = () => {setDimensions({width: window.innerWidth,height: window.innerHeight,})}window.addEventListener(‘resize’, handleResize)return () => { window.removeEventListener(‘resize’, handleResize) }}, [])return (<WindowDimensionsCtx.Provider value={dimensions}>{children}</WindowDimensionsCtx.Provider>)} export default WindowDimensionsProviderexport const useWindowDimensions = () => useContext(WindowDimensionsCtx) This component should be invoked in , like so: src/App.js import React from 'react'import Content from './components/Content'import WindowDimensionsProvider from './components/WindowDimensionsProvider'import items from './data.json'import 'bulma/css/bulma.css' App = () (<WindowDimensionsProvider><div ="App"><Content ={items} /></div></WindowDimensionsProvider>) const => className items App export default Note: In a real world app, you should write a Higher-Order Component, for utilization with class Components; see a sample implementation . also here Don’t worry about the and , we’ll get to those later. What’s important is that the component appear higher in your app’s render tree than any component that wants to read from its for data. (This is important so React knows which context value to provide, in case you have multiple instances of the same type of rendered in your app.) Content items Provider Context Provider By doing this, we have ensured the following: There will only be one ‘resize’ event listener active on the page It will remain active as long as React is rendering our App component All components inside our app (here, just the component) will have access to the WindowDimensionsProvider’s context Content With this plumbing set up, let’s rewrite our responsive layout handling component: import { useWindowDimensions } from '../WindowDimensionsProvider' const ResponsiveLayout = ({ breakpoint, renderMobile, renderDesktop }) => {const { width } = useWindowDimensions()return (width > breakpoint ? renderDesktop() : renderMobile())} Wow! Not only do we have a better performing implementation (as each instance does not have to set up/tear down event listeners), but there’s much less going on in the component. Semantically, each line of code perfectly describes what it is doing: Get the width using window dimensions. If the width is greater than the breakpoint, render the desktop view. Otherwise, render the mobile view. Pretty straightforward. Now that we have this tool, let’s use it to make a responsive layout. Needs More Content So let’s build our two layouts. For our mobile view, we’ll render a tabbed view: React 'react' TabbedView './TabbedView' import from import from MobileView = ({ items }) (<div ='container box'><TabbedView ={items} /></div>) const => className items MobileView export default For the TabbedView, we will use to keep track of the active tab, so it receives proper styles and we know what to render in the content box. useState React, { useState } 'react' import from TabbedView = ({ className, items, renderItem }) { [active, setActive] = useState(0) (<div ='tabs-container'><nav ='tabs is-centered'><ul>{items.map(({ title }, idx) (<li ={idx === active ? 'is-active' : ''} ={title}><a ={() setActive(idx)}>{title}</a></li>))}</ul></nav><div><p ='content'>{items[active].content}</p></div></div>)} const => const return className className => className key onClick => className TabbedView export default Here we simply set up a container for tabs at the top (inside a ) and render the content based on the active tab. nav For Desktops, we will instead give each item its own tile. React 'react' Tile './Tile' { useWindowDimensions } '../WindowDimensionsProvider' import from import from import from DesktopView = ({ items }) { { width } = useWindowDimensions()return (<div ={‘tile is-ancestor ‘.concat(width < 1088 ? ‘is-vertical’ : ‘’)}>{items.map((item, idx) (<Tile ={item.title}{...item}/>))}</div>)} const => const className => key DesktopView export default Our desktop view can even handle width as well, for a minimal change (like adding a class name), without getting too complex. Our Tile is just a couple of divs ‘n’ spans: import React from 'react' const Tile = ({ title, content }) => (<div className='tile is-parent notification box'><div className='tile is-child'><p className='title'>{title}</p><span className='content'>{content}</span></div></div>) export default Tile In , we’ll write a basic wrapper for the responsive layout: src/Content/index.js import React from 'react'import ResponsiveLayout from '../ResponsiveLayout'import MobileView from './MobileView'import DesktopView from './DesktopView' Content = ({ items }) (<ResponsiveLayout ={767} ={() (<DesktopView ={items} />)} ={() (<MobileView ={items} />)}/>) const => breakPoint renderDesktop => items renderMobile => items Content export default Wrapping Up Now we’ve defined our component, we just need some data to render. In , we can create some placeholder data to see how we’re doing so far: Content src/data.json [{ title: "Bananas", "content": "Bananas! I will write some great placeholder text – and nobody writes better placeholder text than me, believe me – and I’ll write it very inexpensively. I will write some great, great text on your website’s Southern border, and I will make Google pay for that text. Mark my words. Lorem Ipsum is a choke artist. It chokes!" },... more data] With everything in place, we should be able to confirm by resizing the window that the view switches from a tabbed view to a set of tiles. I hope this walkthrough has shown a few ways hooks can be used in your React apps today. Here are some of the other great ways I have been able to use hooks in apps recently: Creating an component with OnScrollIntoView IntersectionObserver Creating reusable animation components (using the amazing package) react-spring Building a lazy-loaded Image component for rendering images on slow connections That’s all for this guide! Let me know in the comments if you enjoyed this article, if you would like me to write about something else, or if you have a question.

Simplifying Responsive Layouts with React Hooks

It’s kind of fun to do the impossible. S You are a chef, and you have been asked to prepare milkshakes for your best friend’s baby shower. Because of the huge income chef’s usually have, you are a proud owner of a Cylindrical Automated Transformer( ) that you can use to make milkshakes and whatnot. o, Here’s the problem: CAT You could make the milkshakes yourself, and it will take you to do it. Option 1: 2 minutes You could use the , which takes about , no matter the request. Option 2: CAT 20 minutes You choose: Option 1 (good choice) Impressed by your speed in the kitchen, the Queen of Whales asks you to cook an eight course dinner, with appetizers, and dessert, and milkshakes on her son’s wedding. If you chose to have at it all by yourself now, not only will you not be able to complete the job, you will be barred from Whales and the Kingdom for the rest of your life. However, if you are a wee bit smart at Math, you’d choose the CAT, finish the job in (right!?!), and gain an all access pass to the fanciest hotels in the United Kingdom. 20 minutes Machine Learning is that eight-course dinner, in a catered wedding of the Prince of whales with 200,000 guests. Would you want to cook all that yourself(CPU) or use a service? ( gpu.js is that service.) Hint: In the GPU can help you cut the time to 1/100th of the original time taken. And maybe more. (Keep going! Results will show up.) Machine Learning, Introducing, gpu.js! If you are baffled and want to dive straight into the pool of , feel free to skip to the next section. brackets is a GPGPU(General purpose Programming on Graphical Processing Units) library that lets you hand over hefty calculations to the GPU for super fast operation and output. It currently runs on the browser and node.js, wherein it is using WebGl API’s in the browser, and a single threaded operation on node.js. is on the roadmap.(🎉) gpu.js OpenCL Github Stars ⭐️ You might ask: “But why? Aren’t Intel’s i7, or even i9 fast enough? They seem to work fine for me. I don’t need this.” Before you get bogged down by that, check out the results: MacBook Pro Retina 2015, Google Chrome times faster!?! 22.97 ( : MacBook Pro , 2015) Specs Retina Right, right! That’s a powerful machine, so here are the results on a system with Integrated Graphics Card ( ) and no dedicated GPU: Intel HD 3000 Intel HD 3000, Google Chrome All in all, the thing that separates form the lot is that it doesn’t chain you to use the library in a specific way. It does what the tagline says: It lets you your hefty JavaScript. gpu.js accelerate Let’s have some code now: We are going to perform Matrix Multiplication, and benchmark CPU’s performance vs GPU. Size of the Matrices: X 512 512 Code You are right. It’s hosted on GitHub: gpu.js-demo The source files, namely and can be downloaded from our website ( ) or github( ). gpu.min.js gpu-core.min.js gpu.rocks gpu.js I am assuming you have already initialized a prototype HTML/JS/CSS project ( , , ) Note: index.html index.js style.css Step 1. Import gpu lib files In your index.html, import the files, and you are good to go: Step 2. Matrix Multiplication on CPU To multiply two matrices, we need to make sure that the number of columns in the first matrix is equal to the number of rows in the second matrix. Matrix A: X (m X n) 512 512 Matrix B: X (n X r) 512 512 Result: X (m X r) 512 512 Here’s a generic Matrix Multiplication algorithm that runs on the CPU: The next step is where the magic begins. (WebGL magic 😆) Step 3. Setup GPU The lib files export a global function named that you can use to create a new gpu instance. A gpu GPU const gpu = new GPU({mode: 'webgl'}); A few options can be sent to the constructor, the complete list of which can be find on GitHub and the automatically generated . JSDocs The option specifies where the function will run. There are three options: mode “gpu” “webgl” “cpu” gpu and webgl are aliases, for the time being. We are targeting to incorporate for and then the gpu will solely mean use the gpu via OpenCL API on server. OpenCL v2 Currently, both webgl and gpu use WebGL API’s to defer work to the GPU. Step 4. Matrix Multiplication on GPU The gpu variable we just initialized has several different methods attached to it, all of which have varying use-cases. We’ll use the method which, essentially, creates a “kernel” (An abstract term for it could be, in fact, ) which you can call from JS. Behind the scenes, your code is compiled to GLSL shaders using an AST and a jison based parser. That ensures that the code written inside the kernel will be executed on a GPU. createKernel function You pass a JS Function as an argument to the kernel, and have access to the thread dimensions(As a mnemonic, you can think of the thread dimensions as the lengths of the for-loops we used in CPU mode.) sets the dimension of the loop. (See the API page for complete reference.) .setDimensions This is an inherent problem in the way most GPU written software works: . The GPU is like its own computer; a black box that we send commands to from the CPU. We can transfer things to it and read data back from it, but all that comes with a penalty. The overall penalty of transfer especially becomes a bottleneck if your case involves performing several mathematical operations on the GPU, and the net fine keeps increasing with every operation. Transfer Penalty You can, however, leave values on the GPU. They exist on the GPU as Textures. (You can think of Textures as sort of data containers, but, for the GPU.) By setting flag to , you can make sure that you incurring no transfer penalty thereby eliciting an important speed gain. outputToTexture true is where the happens! .setOutputToTexture REAL STUFF WiffleGif.com And as important as they are**, A** and are matrices which we’ll create in the next step. B Step 5. Initialize Matrices This code is taken from the demo you saw on our website. If you don’t get it, no problem. Here’s what it does: It adds elements to a JavaScript Array. ( ) and then divides them into parts, which means, in the end, we have a array of size . (Every array element has child elements.) 512*512 1D 512 2D 512*512 All done! Let’s hit the gas. Step 6. Run it and Benchmark For simplicity, we are going to use the Web performance API to benchmark this but you can use as well. (Our website uses that.) benchmark.js First we generate the matrices by calling the above function, and then we run the methods for both and . matMult CPU GPU BAM! Open in the browser and see for yourself. Here is what I got: (Support for is coming soon!) index.html Safari Chrome: Firefox(What’s up, ): Chrome? And that’s just If you change that number to 1024, you’ll notice that the GPU is a powerful beast and can run your code much faster than the CPU. 512 X 512. much We would like to let the community know that JavaScript has been gifted a rocket. 🚀 What will you do with it? All the code is on GitHub and the team will be thrilled to have more users and contributors. — Go have some epiphanies. 🎉 gpu.js

Introducing gpu.js: GPU Accelerated JavaScript

Stories, News & Mentions about SAMDIMENSION

Samdimension’s Stories on HackerNoon