If you buy through a <strong>BGR</strong> link, we may earn an affiliate commission, helping support our expert product labs.

It might be time for NASA to bail on Boeing's Starliner

In recent years, the logistics industry has poured unprecedented amounts of time, effort, and money into revolutionizing and optimizing the way goods move

White Paper: Identifying Current Gaps in Parcel Shipping: Packing and Packaging Optimization

Eunomia Research & Consulting and Zero Waste Europe have researched greenwashing in PET beverage packaging. The report is based on previous work by circular economy specialists at Eunomia, which concluded that PET is not currently a circular material within even the best recycling systems in Europe.

Report finds high likelihood of greenwashing in beverage packaging

The global Gift Packaging Industry is on a trajectory of significant growth, with an estimated market value reaching an impressive US$ 37.4 billion by the year 2033. The demand for gift packaging is set to maintain a steady Compound Annual Growth Rate (CAGR) of 4.

Gift Packaging Industry Size Projected to US$ 37.4 Billion by 2033: Market Analysis by Demands, Trends, Regional Insights, Opportunities and more

Transparency Market Research Inc. - The rigid paper container market was estimated to have acquired US$ 339.1 billion in 2021. It is anticipated to

Rigid Paper Container Market Size Worth USD 443.4 billion by 2026, Garnering 5.5% CAGR | Exclusive Report by Transparency Market Research Inc.

The worldwide corrugated bin boxes market is poised for substantial growth, with an estimated market value of US$ 25,231.2 million projected for the year 2023. This growth is underpinned by several key factors,

Corrugated Bin Boxes Market Value Projected Huge Growth of US$ 38,439.8 Million by 2033: In Depth Industry Analysis

Business owners and packaging producers in the Empire State argue that elected officials are rushing the process,

New York farmers, businesses balk at packaging bill

The United States and Canada child resistant bottles market is poised for substantial growth, with a projected valuation of approximately US$ 1.06 billion by the year 2023. This upward trajectory is expected to continue,

United States and Canada Child Resistant Bottles Market Value to Reach US$ 1.59 Billion by 2030: FMI Study

A study from Argonne National Laboratory indicates that recycling post-use plastic through pyrolysis can reduce GHGs up to 23%.

Study: Advanced Recycled Plastic Reduces GHGs

U PM Specialty Papers has collaborated with bakery group Lantmännen Unibake and corrugated cardboard packaging manufacturer Adara to create a fibre-based packaging solution for the frozen baked goods market. The collaboration aimed to introduce a sustainable alternative to minimise the use of fossil-based materials within the sector.

UPM and others create inner packaging for frozen baked goods

Meet the Bot That Reads All the Bad News Headlines So You Don’t Have To

Γνωρίστε το Bot που διαβάζει όλους τους τίτλους των κακών ειδήσεων για να μην χρειάζεται

Conozca el bot que lee todos los titulares de malas noticias para que usted no tenga que hacerlo

Découvrez le robot qui lit tous les gros titres des mauvaises nouvelles pour que vous n'ayez pas à le faire

Հանդիպեք այն բոտին, որը կարդում է բոլոր վատ լուրերի վերնագրերը, որպեսզի դուք ստիպված չլինեք դա անել

Incontra il bot che legge tutti i titoli delle brutte notizie così non devi farlo tu

הכירו את הבוט שקורא את כל כותרות החדשות הרעות כדי שלא תצטרכו

悪いニュースの見出しをあなたが読む代わりに読んでくれるボットをご紹介します

ພົບກັບ Bot ທີ່ອ່ານທຸກຫົວຂໍ້ຂ່າວບໍ່ດີດັ່ງນັ້ນທ່ານບໍ່ຈໍາເປັນຕ້ອງ

Faceți cunoștință cu botul care citește toate titlurile știrilor proaste, astfel încât să nu aveți nevoie

Hura na Bot isoma amakuru yose mabi mumutwe kugirango utagomba

Бо бот вохӯред, ки ҳама сарлавҳаҳои хабарҳои бадро мехонад, то ба шумо лозим нест

Sizga kerak bo'lmasligi uchun barcha yomon yangiliklar sarlavhalarini o'qiydigan bot bilan tanishing

Welcome to the Beginners Guide to Polkadot API series! This particular tutorial will focus on learning how to build and compose decentralized applications (dApps) on the Polkadot network. We will also define what that means exactly, and how to get started with creating your first light client-powered dapp on Polkadot. In this tutorial, we will build a dead simple “You’ve Got Mail“ CLI app using the Polkadot API. build compose If you're new to Polkadot (and blockchain development) in general then keep on reading, otherwise, you can skip to the tutorial. Quick Introduction: What is Polkadot? Polkadot's is a protocol that coordinates and secures different rollups (often called parachains) allowing for a horizontally scaling, heterogeneously sharded, multi-chain approach to Web3. One of the keywords here is heterogeneously sharded, meaning that each shard, or blockchain (or state machine, if you want to get more technical), contains its unique domain-specific logic. Using the Polkadot SDK, anyone can build a rollup and inherit security from the Polkadot relay chain. A rollup can be quite literally anything from a bridge to Ethereum and other protocols (Hyperbridge), a decentralized knowledge graph️ (OriginTrail), or even a cloud computing and oracle platform that is powered by old smartphones (Acurast) coordinates secures heterogeneously sharded bridge to Ethereum and other protocols (Hyperbridge) a decentralized knowledge graph️ (OriginTrail) a cloud computing and oracle platform that is powered by old smartphones (Acurast) Once deployed, rollups can use cross-consensus messaging (XCM) to communicate with one another. This is not limited to just rollups within Polkadot, but even to other protocols, such as Ethereum. XCM Composing Applications Using the Polkadot Stack As Polkadot has a wide range of different application-specific rollups at our creative disposal, the concept of composing apps should not be a foreign one. Similar to how a traditional, web2 application may use different services, APIs, and technologies to build a fullstack application, we can utilize the different parts of the Polkadot stack to build a web3 native application. You even go as far as to host your application on a web3 service to completely bypass the conventional means of deployment. composing The Composer - The Polkadot API (PAPI) Although you can use a number of languages to build apps on Polkadot, such as Rust, Python, or Typescript/Javascript, we'll be using Polkadot API, or PAPI, which is a Typescript library for interacting with Polkadot (and its rollups). The main differentiator with PAPI is its light-client-first approach, in which it has native support for communicating to Polkadot via a light client. Polkadot API Polkadot API PAPI The light client implementation, called smoldot, runs in the background and ensures that we have the latest, verified chain state. Using PAPI, you can even interact with multiple rollups on Polkadot at once. smoldot Why Are Light Clients Important? Light clients are one of the two options for connecting to a blockchain, with the other usually depending on a single RPC provider (which often runs on a centralized server). They are typically a more secure, trust-minimized, efficient way of communicating to a blockchain. Light clients verify the state of the blockchain using Merkle proofs, ensuring it has not only the latest but correct state. As it just verifies the headers of the blocks, it has no need to download the whole state, making it ideal for resource-constrained environments. correct Unlike RPC connections, they do not depend on a single RPC provider and can be embedded in both the browser and natively. "You've Got Mail!" - Polkadot API Example With the explanation out of the way, let's get our hands dirty with some code. Project Introduction Our project will be quite simple - it will be a CLI application that runs in the terminal, which watches the relay chain for a certain extrinsic (a transaction). This extrinsic will be the system.remarkWithEvent extrinsic, meaning it is coming from the system pallet (module) on the Westend test network. extrinsic system.remarkWithEvent system The system.remarkWithEvent extrinsic allows us to send any arbitrary data on-chain, with the end result being a hash that is the address and the word "email" combined (address+email). We'll hash this combination and watch for remarks on a chain that are addressed to us. The system.remarkWithEvent extrinsic emits an event that we can use PAPI to watch the chain for. system.remarkWithEvent address+email system.remarkWithEvent Once we receive a remark addressed to us, we will play the infamous "You've Got Mail!" sound byte. Prerequisites You should have the following installed as a prerequisite: npm (or other package manager)
node
git
Polkadot.js Browser Extension (wallet) npm (or other package manager) npm node node git git Polkadot.js Browser Extension (wallet) Polkadot.js Browser Extension (wallet) You will also need an account with Westend tokens. Below you can find guides for both Polkadot.js and the faucet: Creating Accounts on Polkadot.js
Westend Faucet Creating Accounts on Polkadot.js Creating Accounts on Polkadot.js Westend Faucet Westend Faucet Cloning the repository For this tutorial, you can choose to run the example directly by cloning the main branch of the repository, or to use a boilerplate/template and follow the tutorial. main branch of the repository We need to clone the template, which has everything we need to get started with the Polkadot API and Typescript. Be sure you clone the correct branch (empty-cli) which already provides all dependencies: empty-cli git clone https://github.com/CrackTheCode016/polkadot-api-example-cli --branch empty-cli git clone https://github.com/CrackTheCode016/polkadot-api-example-cli --branch empty-cli Once cloned, run the following to ensure npm dependencies are installed: npm cd polkadot-api-example-cli
npm install cd polkadot-api-example-cli
npm install Exploring the Template (Light Clients!) When we open the repository, we should see the following code (excluding imports): async function withLightClient(): Promise<PolkadotClient> {
    // Start the light client
    const smoldot = start();
    // The Westend Relay Chain
    const relayChain = await smoldot.addChain({ chainSpec: westEndChainSpec })
    return createClient(
        getSmProvider(relayChain)
    );
}

async function main() {
    // CLI Code goes here...
}

main() async function withLightClient(): Promise<PolkadotClient> {
    // Start the light client
    const smoldot = start();
    // The Westend Relay Chain
    const relayChain = await smoldot.addChain({ chainSpec: westEndChainSpec })
    return createClient(
        getSmProvider(relayChain)
    );
}

async function main() {
    // CLI Code goes here...
}

main() The notable function to pay attention to is the withLightClient function. This function uses the built in light client functionality (powered by smoldot) to actually create a light client that syncs and interacts with Polkadot right there in our application. withLightClient smoldot Creating the CLI Next, let's create our CLI, which is to be done within the confines of the main function. We will include an option (-a / --account), which will be the account we will watch for our "mail": main -a --account const program = new Command();
console.log(chalk.white.dim(figlet.textSync("Web3 Mail Watcher")));
program.version('0.0.1').description('Web3 Mail Watcher - A simple CLI tool to watch for remarks on Polkadot network');
    .option('-a, --account <account>', 'Account to watch')
    .parse(process.argv);

// CLI Arguments from commander
const options = program.opts(); const program = new Command();
console.log(chalk.white.dim(figlet.textSync("Web3 Mail Watcher")));
program.version('0.0.1').description('Web3 Mail Watcher - A simple CLI tool to watch for remarks on Polkadot network');
    .option('-a, --account <account>', 'Account to watch')
    .parse(process.argv);

// CLI Arguments from commander
const options = program.opts(); Watching for Remarks Next, we need to start watching the Westend network for remarks sent to our account. As was done before, all code should be within the main function: main // We check for the --account flag, if its not provided we exit
    if (options.account) {
        console.log(chalk.black.bgRed("Watching account:"), chalk.bold.whiteBright(options.account));
        // We create a light client to connect to the Polkadot (Westend) network
        const lightClient = await withLightClient();
        // We get the typed API to interact with the network
        const dotApi = lightClient.getTypedApi(wnd);
        // We subscribe to the System.Remarked event and watch for remarks from our account
        dotApi.event.System.Remarked.watch().subscribe((event) => {
            // We look for a specific hash, indicating that its our address + an email
            const { sender, hash } = event.payload;
            // We calculate the hash of our account + email
            const calculatedHash = bytesToHex(blake2b(`${options.account}+email`, { dkLen: 32 }));
            // If the hash matches, we play a sound and log the message - You got mail!
            if (`0x${calculatedHash}` == hash.asHex()) {
                sound.play("youve-got-mail-sound.mp3")
                console.log(chalk.black.bgRed(`You got mail!`));
                console.log(chalk.black.bgCyan("From:"), chalk.bold.whiteBright(sender.toString()));
                console.log(chalk.black.bgBlue("Hash:"), chalk.bold.whiteBright(hash.asHex()));
            }
        });
    } else {
        // If the account is not provided, we exit
        console.error('Account is required');
        return;
    } // We check for the --account flag, if its not provided we exit
    if (options.account) {
        console.log(chalk.black.bgRed("Watching account:"), chalk.bold.whiteBright(options.account));
        // We create a light client to connect to the Polkadot (Westend) network
        const lightClient = await withLightClient();
        // We get the typed API to interact with the network
        const dotApi = lightClient.getTypedApi(wnd);
        // We subscribe to the System.Remarked event and watch for remarks from our account
        dotApi.event.System.Remarked.watch().subscribe((event) => {
            // We look for a specific hash, indicating that its our address + an email
            const { sender, hash } = event.payload;
            // We calculate the hash of our account + email
            const calculatedHash = bytesToHex(blake2b(`${options.account}+email`, { dkLen: 32 }));
            // If the hash matches, we play a sound and log the message - You got mail!
            if (`0x${calculatedHash}` == hash.asHex()) {
                sound.play("youve-got-mail-sound.mp3")
                console.log(chalk.black.bgRed(`You got mail!`));
                console.log(chalk.black.bgCyan("From:"), chalk.bold.whiteBright(sender.toString()));
                console.log(chalk.black.bgBlue("Hash:"), chalk.bold.whiteBright(hash.asHex()));
            }
        });
    } else {
        // If the account is not provided, we exit
        console.error('Account is required');
        return;
    } This code is doing quite a bit, so let's break it down: First, we check for the existance of the --account argument, and log that we are watching that account, else we exit. We are using the chalk package to add color to our console.log statements.
Next, we create our light client.
We use a light client and the Westend chain specification (wnd) to access a typed API.
Once we have our API, we then begin to reactively watch the account for the event that corresponds to the remark. We analyze the payload, looking for a hash which is calculated as follows:

hash of: account_address+email


When an event containing this hash is identified, it then plays the "You've Got Mail!" soundbite. First, we check for the existance of the --account argument, and log that we are watching that account, else we exit. We are using the chalk package to add color to our console.log statements. --account chalk console.log Next, we create our light client. We use a light client and the Westend chain specification (wnd) to access a typed API. wnd Once we have our API, we then begin to reactively watch the account for the event that corresponds to the remark. We analyze the payload, looking for a hash which is calculated as follows:

hash of: account_address+email hash of: account_address+email hash of: account_address+email account_address+email When an event containing this hash is identified, it then plays the "You've Got Mail!" soundbite. Compiling and running Once we have all of our code in place, we should compile and run the repository: npm start -- --account <account-address> npm start -- --account <account-address> Upon running, we should have the following output: ❯ npm start -- --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

> youve-got-mail-web3@1.0.0 start
> tsc && node ./dist/index.js --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
[smoldot] Smoldot v2.0.34
[smoldot] Chain initialization complete for westend2. Name: "Westend". Genesis hash: 0xe143…423e. Chain specification starting at: 0x10cf…b908 (#23920337) ❯ npm start -- --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

> youve-got-mail-web3@1.0.0 start
> tsc && node ./dist/index.js --account 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY

 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY
[smoldot] Smoldot v2.0.34
[smoldot] Chain initialization complete for westend2. Name: "Westend". Genesis hash: 0xe143…423e. Chain specification starting at: 0x10cf…b908 (#23920337) Testing the CLI Now that our application is actively watching for remark events on-chain, we can move to testing to see if it works! As mentioned previously, you will need a Westend account with some tokens to pay for fees. As mentioned previously, you will need a Westend account with some tokens to pay for fees. Navigate to the PAPI Dev Console > Extrinsics. You then want to select the System pallet, and the remark_with_event call: PAPI Dev Console > Extrinsics System remark_with_event Next, we want to be sure we get the correct input for the text field. We want to be sure we are following the convention we set forth in our application: address+email address+email address+email address+email If for example, we are watching 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY, then the field should look like the following: 5GrwvaEF5zXb26Fz9rcQpDWS57CtERHpNehXCPcNoHGKutQY Once this input is in place, you may click the Submit extrinsic button, where you can sign using the Polkadot.js browser wallet: Submit extrinsic Heading back to our CLI, we should soon see the following, along with the fact that "YOU'VE GOT MAIL!" (as in the sound should play): __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
You've got mail!
From: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
Hash: 0xb6999c9082f5b1dede08b387404c9eb4eb2deee4781415dfa7edf08b87472050 __        __   _    _____   __  __       _ _  __        __    _       _
 \ \      / /__| |__|___ /  |  \/  | __ _(_) | \ \      / /_ _| |_ ___| |__   ___ _ __
  \ \ /\ / / _ \ '_ \ |_ \  | |\/| |/ _` | | |  \ \ /\ / / _` | __/ __| '_ \ / _ \ '__|
   \ V  V /  __/ |_) |__) | | |  | | (_| | | |   \ V  V / (_| | || (__| | | |  __/ |
    \_/\_/ \___|_.__/____/  |_|  |_|\__,_|_|_|    \_/\_/ \__,_|\__\___|_| |_|\___|_|

Watching account: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
You've got mail!
From: 5Cm8yiG45rqrpyV2zPLrbtr8efksrRuCXcqcB4xj8AejfcTB
Hash: 0xb6999c9082f5b1dede08b387404c9eb4eb2deee4781415dfa7edf08b87472050 Conclusion This application can be expanded in a number of ways, whether that is by adding a chatroom through remarks, or by using some of the rollups on Polkadot to expand the functionality. If you have any ideas, questions, comments, or concerns, feel free to shoot me a message here on X! X

Everything You Need to Know About The Polkadot API (PAPI)

Weather Image Recognition with AI: Dataset Labeling, Model Training, and Real-world Usecases

Want to Search for Something With an Image and a Text Description? Try a Multimodal RAG

¿Mä Imagen ukat Texto Descripción ukampi kuns thaqhañ munasmati? Mä RAG Multimodal ukamp yant’aña

¿Quieres buscar algo con una imagen y una descripción de texto? Prueba un RAG multimodal

آیا می خواهید چیزی را با یک تصویر و یک توضیح متنی جستجو کنید؟ یک RAG Multimodal را امتحان کنید

Vous souhaitez rechercher quelque chose avec une image et une description textuelle ? Essayez un RAG multimodal

画像とテキストの説明を使って何かを検索したいですか? マルチモーダル RAG をお試しください

ចង់ស្វែងរកអ្វីមួយដែលមានរូបភាព និងការពិពណ៌នាអត្ថបទ? សាកល្បងប្រើ Multimodal RAG

Зураг болон текстийн тайлбартай ямар нэг зүйл хайхыг хүсч байна уу? Multimodal RAG-г туршаад үзээрэй

Ingin Mencari Sesuatu Dengan Imej dan Penerangan Teks? Cuba RAG Multimodal

غواړئ د عکس او متن توضیحاتو سره یو څه وپلټئ؟ د ملټي موډل RAG هڅه وکړئ

රූපයක් සහ පෙළ විස්තරයක් සමඟ යමක් සෙවීමට අවශ්‍යද? Multimodal RAG එකක් උත්සාහ කරන්න

ต้องการค้นหาบางสิ่งที่มีรูปภาพและคำอธิบายหรือไม่ ลองใช้ RAG แบบหลายโหมด

Surat we tekst beýany bilen bir zat gözlemek isleýärsiňizmi? Multimodal RAG synap görüň

How I Created AI Photocraft: An AI SaaS Tool Using Open Source Projects on GitHub

The vast majority of modern systems are built on a microservice architecture. This means that you can be the maintainer of about a hundred services, which are being worked on by several teams of software engineers. As the person responsible for the system, it is important for you to monitor the relevance of the master branch of all projects. One of the easiest and fastest ways to do this is to check how much your main project branch lags behind the test branch after the release. Thanks to this simple check, you will be sure that the teams have brought all the services to production. Also, a quick report on the lag of the master branch from dev will be useful for understanding the state of development. If more than a few hundred commits have accumulated in the dev branch, then this is a red flag and you, as a team lead, should raise this issue at the sprint retro, because it is obvious that there were interruptions in the process of delivering improvements to production. To solve the problem of quickly viewing ahead/behind my projects, I use the rest API for GitLab (https://docs.gitlab.com/ee/api/rest/), which provides me with all the necessary capabilities. As a language, I chose JavaScript without frameworks, because we have a fast development for ourselves, which should not require a special environment. As a result of the script's work, I want to see a table with columns in the console: group_id - gitlab project group id
group_name - the name of the project group
id - project id
name - project name
behind - how many commits is the master branch ahead of the dev
ahead - how many commits is the dev branch ahead of the master To access the data, I will use a personal access token, which can be obtained in the settings of my GitLab profile. First, I'll get a list of groups using the/api/v4/groups method. After that, I need to get a list of project repositories using the /api/v4/groups/${group.id}/projects method. All that remains is to get the number of commits using the /api/v4/projects/${project.id}/repository/compare method. Next, I collect the data in a table, perform a sorting that is convenient for me, and highlight problematic lines. To perform REST requests, I use axios, and to output a table with data, I use the console-table-printer project. As a result, I got the following script. const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); After its execution, the following table is output to the console: group_id

group_name

id

name

behind

ahead



235

common

34

common_service

5

2



235

common

455

master_data

0

0



379

core

453

core_service

7

0



379

core

344

core_tasks

3

1 The vast majority of modern systems are built on a microservice architecture. This means that you can be the maintainer of about a hundred services, which are being worked on by several teams of software engineers. As the person responsible for the system, it is important for you to monitor the relevance of the master branch of all projects. One of the easiest and fastest ways to do this is to check how much your main project branch lags behind the test branch after the release. Thanks to this simple check, you will be sure that the teams have brought all the services to production. Also, a quick report on the lag of the master branch from dev will be useful for understanding the state of development. If more than a few hundred commits have accumulated in the dev branch, then this is a red flag and you, as a team lead, should raise this issue at the sprint retro, because it is obvious that there were interruptions in the process of delivering improvements to production. To solve the problem of quickly viewing ahead/behind my projects, I use the rest API for GitLab ( https://docs.gitlab.com/ee/api/rest/ ), which provides me with all the necessary capabilities. https://docs.gitlab.com/ee/api/rest/ As a language, I chose JavaScript without frameworks, because we have a fast development for ourselves, which should not require a special environment. As a result of the script's work, I want to see a table with columns in the console: group_id - gitlab project group id group_name - the name of the project group id - project id name - project name behind - how many commits is the master branch ahead of the dev ahead - how many commits is the dev branch ahead of the master group_id - gitlab project group id group_name - the name of the project group id - project id name - project name behind - how many commits is the master branch ahead of the dev ahead - how many commits is the dev branch ahead of the master To access the data, I will use a personal access token, which can be obtained in the settings of my GitLab profile. First, I'll get a list of groups using the /api/v4/groups method. /api/v4/groups After that, I need to get a list of project repositories using the /api/v4/groups/${group.id}/projects method. /api/v4/groups/${group.id}/projects All that remains is to get the number of commits using the /api/v4/projects/${project.id}/repository/compare method. /api/v4/projects/${project.id}/repository/compare Next, I collect the data in a table, perform a sorting that is convenient for me, and highlight problematic lines. To perform REST requests, I use axios , and to output a table with data, I use the console-table-printer project. As a result, I got the following script. axios console-table-printer const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); const { Table } = require('console-table-printer');
const axios = require('axios');

const token = token';
const baseUrl = 'https://git.my-company.net';
const from = 'master';
const to = 'dev';

(async () => {
    let data = [];
    const groups = await axios
        .get(`${baseUrl}/api/v4/groups?private_token=${token}`)
        .then(res => res.data);

    await Promise.all(groups.map(async (group) => {
        const projects = await axios
            .get(`${baseUrl}/api/v4/groups/${group.id}/projects?per_page=100&private_token=${token}`)
            .then(res => res.data);

        await Promise.all(projects.map(async (project) => {
            const behind = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${from}&to=${to}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            const ahead = await axios
                .get(`${baseUrl}/api/v4/projects/${project.id}/repository/compare?from=${to}&to=${from}&private_token=${token}`)
                .then(res => res.data)
                .catch(err => {});
            if (behind && behind.commits && ahead && ahead.commits){
                data.push({
                    group_id: group.id,
                    group_name: group.name,
                    id: project.id,
                    name: project.name,
                    behind: behind.commits.length,
                    ahead: ahead.commits.length,
                });
            }
        }));
    }))

    data = data
        .sort((a,b) =>
            (a.group_name > b.group_name)
                ? 1
                : ((b.group_name > a.group_name) ? -1
                    : (a.name > b.name)
                        ? 1
                        : ((b.name > a.name) ? -1 : 0)));

    const table = new Table();
    data.forEach((row) => {
        table.addRow(row, {
            color: row.behind ? 'red' : undefined,
        });
    });
    table.printTable();
})(); After its execution, the following table is output to the console: group_id

group_name

id

name

behind

ahead



235

common

34

common_service

5

2



235

common

455

master_data

0

0



379

core

453

core_service

7

0



379

core

344

core_tasks

3

1 group_id

group_name

id

name

behind

ahead 235

common

34

common_service

5

2 235

common

455

master_data

0

0 379

core

453

core_service

7

0 379

core

344

core_tasks

3

1 group_id group_name id name behind ahead group_id group_id group_name group_name id id name name behind behind ahead ahead 235 common 34 common_service 5 2 235 235 common common 34 34 common_service common_service 5 5 2 2 235 common 455 master_data 0 0 235 235 common common 455 455 master_data master_data 0 0 0 0 379 core 453 core_service 7 0 379 379 core core 453 453 core_service core_service 7 7 0 0 379 core 344 core_tasks 3 1 379 379 core core 344 344 core_tasks core_tasks 3 3 1 1

Git Ahead Dashboard: A Quick Guide

Building a Logo Creation App with Next.js, Shadcn/ui, and Lucide React

Building Advanced Video Search: Frame Search Versus Multi-Modal Embeddings

উন্নত ভিডিও অনুসন্ধান তৈরি করা: ফ্রেম অনুসন্ধান বনাম মাল্টি-মোডাল এম্বেডিং

Erstellen einer erweiterten Videosuche: Frame-Suche im Vergleich zu multimodalen Einbettungen

Creación de búsqueda de vídeo avanzada: búsqueda de fotogramas frente a incrustaciones multimodales

Création d'une recherche vidéo avancée : recherche de trames et intégrations multimodales

उन्नत वीडियो खोज का निर्माण: फ़्रेम खोज बनाम मल्टी-मोडल एम्बेडिंग

高度なビデオ検索の構築: フレーム検索とマルチモーダル埋め込み

고급 비디오 검색 구축: 프레임 검색과 다중 모드 임베딩 비교

Construindo pesquisa avançada de vídeo: pesquisa de quadros versus incorporações multimodais

Создание расширенного поиска видео: поиск кадров в сравнении с мультимодальными встраиваниями

Gelişmiş Video Arama Oluşturma: Çerçeve Aramaya Karşı Çok Modlu Yerleştirmeler

Xây dựng Tìm kiếm video nâng cao: Tìm kiếm khung so với nhúng đa phương thức

构建高级视频搜索：帧搜索与多模态嵌入

Video Scene Location Recognition Using AI: Methodology

Moving to the upcoming WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics. But this migration will turn out better with preparation and understanding — and this article will get you ready. Hello everyone, my name is Dmitrii Ivashchenko and I'm a software engineer at MY.GAMES. In this article, we'll discuss the differences between WebGL and the upcoming WebGPU, and we'll lay out how to prepare your project for migration. Content Overview Timeline of WebGL and WebGPU The current state of WebGPU, and what's to come High-level Conceptual Differences Initialization • WebGL: The Context Model • WebGPU: The Device Model Programs and Pipelines • WebGL: Program • WebGPU: Pipeline Uniforms • Uniforms in WebGL 1 • Uniforms in WebGL 2 • Uniforms in WebGPU Shaders • Shader Language: GLSL vs WGSL • Comparison of Data Types • Structures • Function Declarations • Built-in functions • Shader Conversion Convention Differences Textures • Viewport Space • Clip Spaces WebGPU Tips & Tricks • Minimize the number of pipelines you use. • Create pipelines in advance • Use RenderBundles Summary Timeline of WebGL and WebGPU , like many other web technologies, has roots that stretch back quite far into the past. To understand the dynamics and motivation behind the move towards WebGPU, it's helpful to first take a quick look at the history of WebGL development: WebGL The desktop version of OpenGL debuts. OpenGL desktop (1993) : This was the first stable release of WebGL, based on OpenGL ES 2.0, which was itself introduced in 2007. It provided web developers with the ability to use 3D graphics directly in browsers, without the need for additional plugins. WebGL 1.0 (2011) : Introduced six years after the first version, WebGL 2.0 was based on OpenGL ES 3.0 (2012). This version brought with it a number of improvements and new capabilities, making 3D graphics on the web even more powerful. WebGL 2.0 (2017) In recent years, there has been a surge of interest in new graphics APIs that provide developers with more control and flexibility: : Created by the Khronos group, this cross-platform API is the "successor" to OpenGL. Vulkan provides lower-level access to graphics hardware resources, allowing for high-performance applications with better control over graphics hardware. Vulkan (2016) : This API was created by Microsoft and is exclusively for Windows and Xbox. D3D12 is the successor to D3D10/11 and provides developers with deeper control over graphics resources. D3D12 (2015) : Created by Apple, Metal is an exclusive API for Apple devices. It was designed with maximum performance on Apple hardware in mind. Metal (2014) The current state of WebGPU, and what's to come Today, WebGPU is available on multiple platforms such as Windows, Mac, and ChromeOS through the Google Chrome and Microsoft Edge browsers, starting with version 113. Support for Linux and Android is expected in the near future. Here are some of the engines that already support (or offer experimental support) for WebGPU: : Full support for WebGPU. Babylon JS : Experimental support at the moment. ThreeJS : In development, but with very promising prospects. PlayCanvas : Very early and experimental WebGPU support was announced in version 2023.2 alpha. Unity : Officially supports WebGPU, making it one of the pioneers in this area. Cocos Creator 3.6.2 : currently supported in v113+ for Windows, macOS, and ChromeOS only. Construct Considering this, transitioning to WebGPU or at least preparing projects for such a transition appears to be a timely step in the near future. High-level Conceptual Differences Let's zoom out and take a look at some of the high-level conceptual differences between WebGL and WebGPU, starting with initialization. Initialization When starting to work with graphics APIs, one of the first steps is to initialize the main object for interaction. This process differs between WebGL and WebGPU, with some peculiarities for both systems. WebGL: The Context Model In WebGL, this object is known as "context", which essentially represents an interface for drawing on an HTML5 canvas element. Obtaining this context is quite simple: const gl = canvas.getContext('webgl'); The context of WebGL is actually tied to a specific canvas. This means that if you need to render on multiple canvases, you will need multiple contexts. WebGPU: The Device Model WebGPU introduces a new concept called "device". This device represents a GPU abstraction that you will interact with. The initialization process is a bit more complex than in WebGL, but it provides more flexibility: const adapter = await navigator.gpu.requestAdapter();
const device = await adapter.requestDevice();

const context = canvas.getContext('webgpu');
context.configure({
   device,
   format: 'bgra8unorm',
}); One of the advantages of this model is that one device can render on multiple canvases or even none. This provides additional flexibility; for example, one device may control rendering in multiple windows or contexts. Programs and Pipelines WebGL and WebGPU represent different approaches to managing and organizing the graphics pipeline. WebGL: Program In WebGL, the main focus is on the shader program. The program combines vertex and fragment shaders, defining how vertices should be transformed and how each pixel should be colored. const program = gl.createProgram();
gl.attachShader(program, vertShader);
gl.attachShader(program, fragShader);
gl.bindAttribLocation(program, 'position', 0);
gl.linkProgram(program); Steps for creating a program in WebGL: : The source code for shaders is written and compiled. Creating Shaders : Compiled shaders are attached to the program and then linked. Creating Program : The program is activated before rendering. Using Program : Data is transmitted to the activated program. Data Transmission This process allows for flexible graphics control, but can also be complex and prone to errors, especially for large and complex projects. WebGPU: Pipeline WebGPU introduces the concept of a "pipeline" instead of a separate program. This pipeline combines not only shaders but also other information, which in WebGL, is established as states. So, creating a pipeline in WebGPU looks more complex: const pipeline = device.createRenderPipeline({
 layout: 'auto',
 vertex: {
   module: shaderModule, entryPoint: 'vertexMain',
   buffers: [{
     arrayStride: 12,
     attributes: [{
       shaderLocation: 0, offset: 0, format: 'float32x3'
     }]
   }],
 },
 fragment: {
   module: shaderModule, entryPoint: 'fragmentMain',
   targets: [{ format, }],
 },
}); Steps to create a pipeline in WebGPU: : The shader source code is written and compiled, similar to how it's done in WebGL. Shader definition : Shaders and other rendering parameters are combined into a pipeline. Pipeline creation : The pipeline is activated before rendering. Pipeline usage While WebGL separates each aspect of rendering, WebGPU tries to encapsulate more aspects into a single object, making the system more modular and flexible. Instead of separately managing shaders and rendering states, as is done in WebGL, WebGPU combines everything into one pipeline object. This makes the process more predictable and less prone to errors: Uniforms Uniform variables provide constant data that is available to all shader instances. Uniforms in WebGL 1 In basic WebGL, we have the ability to set variables directly through API calls. uniform : GLSL uniform vec3 u_LightPos;
uniform vec3 u_LightDir;
uniform vec3 u_LightColor; : JavaScript const location = gl.getUniformLocation(p, "u_LightPos");
gl.uniform3fv(location, [100, 300, 500]); This method is simple, but requires multiple API calls for each variable. uniform Uniforms in WebGL 2 With the arrival of WebGL 2, we now have the ability to group variables into buffers. Although you can still use separate uniform shaders, a better option is to group different uniforms into a larger structure using uniform buffers. Then you send all this uniform data to the GPU at once, similar to how you can load a vertex buffer in WebGL 1. This has several performance advantages, such as reducing API calls and being closer to how modern GPUs work. uniform : GLSL layout(std140) uniform ub_Params {
   vec4 u_LightPos;
   vec4 u_LightDir;
   vec4 u_LightColor;
}; : JavaScript gl.bindBufferBase(gl.UNIFORM_BUFFER, 1, gl.createBuffer()); To bind subsets of a large uniform buffer in WebGL 2, you can use a special API call known as . In WebGPU, there is something similar called dynamic uniform buffer offsets where you can pass a list of offsets when calling the API. bindBufferRange setBindGroup Uniforms in WebGPU WebGPU offers us an even better method. In this context, individual variables are no longer supported, and work is done exclusively through buffers. uniform uniform : WGSL [[block]] struct Params {
   u_LightPos : vec4<f32>;
   u_LightColor : vec4<f32>;
   u_LightDirection : vec4<f32>;
};
[[group(0), binding(0)]] var<uniform> ub_Params : Params; : JavaScript const buffer = device.createBuffer({
  usage: GPUBufferUsage.UNIFORM,
  size: 8
}); Modern GPUs prefer data to be loaded in one large block, rather than many small ones. Instead of recreating and rebinding small buffers each time, consider creating one large buffer and using different parts of it for different draw calls. This approach can significantly increase performance. WebGL is more imperative, resetting global state with each call, and striving to be as simple as possible. WebGPU, on the other hand, aims to be more object-oriented and focused on resource reuse, which leads to efficiency. Transitioning from WebGL to WebGPU may seem difficult due to differences in methods. However, starting with a transition to WebGL 2 as an intermediate step can simplify your life. Shaders Migrating from WebGL to WebGPU requires changes not only in the API, but also in shaders. The WGSL specification is designed to make this transition smooth and intuitive, while maintaining efficiency and performance for modern GPUs. Shader Language: GLSL vs WGSL WGSL is designed to be a bridge between WebGPU and native graphics APIs. Compared to GLSL, WGSL looks a bit more verbose, but the structure remains familiar. Here's an example shader for texture: : GLSL sampler2D myTexture;
varying vec2 vTexCoord;
void main() {
  return texture(myTexture, vTexCoord);
} : WGSL [[group(0), binding(0)]] var mySampler: sampler;
[[group(0), binding(1)]] var myTexture: texture_2d<f32>;
[[stage(fragment)]]
fn main([[location(0)]] vTexCoord: vec2<f32>) -> [[location(0)]] vec4<f32> {
  return textureSample(myTexture, mySampler, vTexCoord);
} Comparison of Data Types The table below shows a comparison of the basic and matrix data types in GLSL and WGSL: Transitioning from GLSL to WGSL demonstrates a desire for stricter typing and explicit definition of data sizes, which can improve code readability and reduce the likelihood of errors. Structures The syntax for declaring structures has also changed: GLSL: struct Light {
  vec3 position;
  vec4 color;
  float attenuation;
  vec3 direction;
  float innerAngle;
  float angle;
  float range;
}; WGSL: struct Light {
  position: vec3<f32>,
  color: vec4<f32>,
  attenuation: f32,
  direction: vec3<f32>,
  innerAngle: f32,
  angle: f32,
  range: f32,
}; Introducing explicit syntax for declaring fields in WGSL structures emphasizes the desire for greater clarity and simplifies understanding of data structures in shaders. Function Declarations : GLSL float saturate(float x) {
	return clamp(x, 0.0, 1.0);
} : WGSL fn saturate(x: f32) -> f32 {
  return clamp(x, 0.0, 1.0);
} Changing the syntax of functions in WGSL reflects the unification of the approach to declarations and return values, making the code more consistent and predictable. Built-in functions In WGSL, many built-in GLSL functions have been renamed or replaced. For example: Renaming built-in functions in WGSL not only simplifies their names, but also makes them more intuitive, which can facilitate the transition process for developers familiar with other graphics APIs. Shader Conversion For those who are planning to convert their projects from WebGL to WebGPU, it's important to know that there are tools for automatically converting GLSL to WGSL, such as **[Naga](https://github.com/gfx-rs/naga/)**, which is a Rust library for converting GLSL to WGSL. It can even work right in your browser with the help of WebAssembly. Here are Naga supported end-points: Convention Differences Textures After migration, you may encounter a surprise in the form of flipped images. Those who have ever ported applications from OpenGL to Direct3D (or vice versa) have already faced this classic problem. In the context of OpenGL and WebGL, textures are usually loaded in such a way that the starting pixel corresponds to the bottom left corner. However, in practice, many developers load images starting from the top left corner, which leads to the flipped image error. Nevertheless, this error can be compensated by other factors, ultimately leveling out the problem. Unlike OpenGL, systems such as Direct3D and Metal traditionally use the upper-left corner as the starting point for textures. Considering that this approach seems to be the most intuitive for many developers, the creators of WebGPU decided to follow this practice. Viewport Space If your WebGL code selects pixels from the frame buffer, be prepared for the fact that WebGPU uses a different coordinate system. You may need to apply a simple "y = 1.0 - y" operation to correct the coordinates. Clip Spaces When a developer faces a problem where objects are clipped or disappear earlier than expected, this is often related to differences in the depth domain. There's a difference between WebGL and WebGPU in how they define the depth range of the clip space. While WebGL uses a range from -1 to 1, WebGPU uses a range from 0 to 1, similar to other graphics APIs such as Direct3D, Metal, and Vulkan. This decision was made due to several advantages of using a range from 0 to 1 that were identified while working with other graphics APIs. The main responsibility for transforming your model's positions into clip space lies with the projection matrix. The simplest way to adapt your code is to ensure that your projection matrix outputs results in the range of 0 to 1. For those using libraries such as gl-matrix, there is a simple solution: instead of using the function, you can use ; similar functions are available for other matrix operations. perspective perspectiveZO if (webGPU) {
	// Creates a matrix for a symetric perspective-view frustum
  // using left-handed coordinates
  mat4.perspectiveZO(out, Math.PI / 4, ...);
} else {
  // Creates a matrix for a symetric perspective-view frustum
  // based on the default handedness and default near
  // and far clip planes definition.
  mat4.perspective(out, Math.PI / 4, …);
} However, sometimes you may have an existing projection matrix and you can't change its source. In this case, to transform it into a range from 0 to 1, you can pre-multiply your projection matrix by another matrix that corrects the depth range. WebGPU Tips & Tricks Now, let's discuss some tips and tricks for working with WebGPU. Minimize the number of pipelines you use. The more pipelines you use, the more state switching you have, and the less performance; this may not be trivial, depending on where your assets come from. Create pipelines in advance Creating a pipeline and using it immediately may work, but this is not recommended. Instead, create functions that return immediately and start working on a different thread. When you use the pipeline, the execution queue needs to wait for pending pipeline creations to finish. This can result in significant performance issues. To avoid this, make sure to leave some time between creating the pipeline and first using it. Or, even better, use the variants! The promise resolves when the pipeline is ready to use, without any stalling. create*PipelineAsync device.createComputePipelineAsync({
 compute: {
   module: shaderModule,
   entryPoint: 'computeMain'
 }
}).then((pipeline) => {
  const commandEncoder = device.createCommandEncoder();
  const passEncoder = commandEncoder.beginComputePass();
  passEncoder.setPipeline(pipeline);
  passEncoder.setBindGroup(0, bindGroup);
  passEncoder.dispatchWorkgroups(128);
  passEncoder.end();
  device.queue.submit([commandEncoder.finish()]);
}); Use RenderBundles Render bundles are pre-recorded, partial, reusable render passes. They can contain most rendering commands (except for things like setting the viewport) and can be "replayed" as part of an actual render pass later on. const renderPass = encoder.beginRenderPass(descriptor);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.executeBundles([renderBundle]);

renderPass.setPipeline(renderPipeline);
renderPass.draw(3);

renderPass.end(); Render bundles can be executed alongside regular render pass commands. The render pass state is reset to defaults before and after every bundle execution. This is primarily done to reduce the JavaScript overhead of drawing. GPU performance remains the same regardless of the approach. Summary Transitioning to WebGPU means more than just switching graphics APIs. It's also a step towards the future of web graphics, combining successful features and practices from various graphics APIs. This migration requires a thorough understanding of technical and philosophical changes, but the benefits are significant. Useful Resources & Links: WebGPU — All of the cores, none of the canvas From WebGL to WebGPU in Construct by Alain Galvan Raw WebGPU tutorial by Brandon Jones WebGPU Best Practices WebGL + WebGPU Meetup - July 2023 Link

Migrating from WebGL to WebGPU

WebGL থেকে WebGPU-তে স্থানান্তরিত হচ্ছে

Migration von WebGL zu WebGPU

Migrando de WebGL a WebGPU

Migration de WebGL vers WebGPU

WebGL से WebGPU पर माइग्रेट किया जा रहा है

Stories, News & Mentions about BGR

Categories

Trending Topics

Stories, News & Mentions about BGR

Bgr’s Stories on HackerNoon

Bgr's News & Mentions

Categories

Trending Topics