**Product Manager, Credit Card**\n\nWe’re looking for an entrepreneurial product manager to take a lead role in continuing to build the first health and wellness credit card

Limit

Being a software engineer who works extensively with financial data, I recently hit a wall with traditional stock market APIs. After getting frustrated with rate limits and expensive subscriptions, I decided to build my own solution using web scraping. Here's how I did it, and what I learned along the way. Introduction: Why I Needed a Different Approach My breaking point came during a personal project where I was trying to analyze market trends. Yahoo Finance's API kept hitting rate limits, and Bloomberg Terminal's pricing made me laugh out loud - there was no way I could justify that cost for a side project. I needed something that would let me: Fetch data without arbitrary limits
Get real-time prices and trading volumes
Access historical data without paying premium fees
Scale up my analysis as needed The Web Scraping Solution After some research and experimentation, I settled on scraping data from two main sources: CNN Money for trending stocks and Yahoo Finance for detailed metrics. Here's how I built it: Setting Up the Basic Infrastructure First, I installed the essential tools: pip install requests bs4 Then I created a basic scraper that could handle network issues gracefully: import requests
from bs4 import BeautifulSoup
import time
import logging

def make_request(url, max_retries=3):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    for attempt in range(max_retries):
        try:
            return requests.get(url, headers=headers, timeout=10)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(attempt + 1) Grabbing Trending Stocks I started with CNN Money's hot stocks list, which gives me three categories of stocks to track: def get_trending_stocks():
    url = 'https://money.cnn.com/data/hotstocks/index.html'
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    tables = soup.findAll("table", {"class": "wsod_dataTable wsod_dataTableBigAlt"})
    categories = ["Most Actives", "Gainers", "Losers"]
    
    stocks = []
    for i, table in enumerate(tables):
        for row in table.findAll("tr")[1:]:  # Skip headers
            cells = row.findAll("td")
            if cells:
                stocks.append({
                    'category': categories[i],
                    'symbol': cells[0].find(text=True),
                    'company': cells[0].span.text.strip()
                })
    
    return stocks Getting the Financial Details For each trending stock, I fetch additional data from Yahoo Finance: def get_stock_details(symbol):
    url = f"https://finance.yahoo.com/quote/{symbol}"
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    data = {}
    
    # Find the main quote table
    table = soup.find("table", {"class": "W(100%)"})
    if table:
        for row in table.findAll("tr"):
            cells = row.findAll("td")
            if len(cells) > 1:
                key = cells[0].text.strip()
                value = cells[1].text.strip()
                data[key] = value
    
    return data The Gotchas I Encountered Building this wasn't all smooth sailing. Here are some real issues I hit and how I solved them: Rate Limiting: Yahoo Finance started blocking me after too many rapid requests. I added random delays between requests: time.sleep(random.uniform(1, 3))  # Random delay between 1-3 seconds Data Inconsistencies: Sometimes the scraped data would be malformed. I added validation: def validate_price(price_str):
    try:
        return float(price_str.replace('$', '').replace(',', ''))
    except:
        return None Website Changes: The sites occasionally update their HTML structure. I made my selectors more robust: # Instead of exact class matches, use partial matches
table = soup.find("table", class_=lambda x: x and 'dataTable' in x) Storing and Using the Data I keep things simple with CSV storage - it's easy to work with and perfect for my needs: import csv
from datetime import datetime

def save_stock_data(stocks):
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
    with open('stock_data.csv', 'a', newline='') as file:
        writer = csv.writer(file)
        for stock in stocks:
            writer.writerow([timestamp, stock['symbol'], 
                           stock['price'], stock['volume']]) What I Learned After running this scraper for several weeks, here are my key takeaways: Web scraping isn't just a hack - it's a viable alternative to expensive APIs when done rightly.
Building in error handling and logging from the start saves huge headaches later.
Stock data is messy - so always validate what you scrape.
Starting simple and iterating works better than trying to build everything at once! What's Next? I'm currently working on adding: News sentiment analysis
Basic pattern recognition
A simple dashboard for visualization Also, would you like to integrate this scraper with machine learning models to predict stock trends? Let me know in the comments! Being a software engineer who works extensively with financial data, I recently hit a wall with traditional stock market APIs. After getting frustrated with rate limits and expensive subscriptions, I decided to build my own solution using web scraping. Here's how I did it, and what I learned along the way. Introduction: Why I Needed a Different Approach My breaking point came during a personal project where I was trying to analyze market trends. Yahoo Finance's API kept hitting rate limits, and Bloomberg Terminal's pricing made me laugh out loud - there was no way I could justify that cost for a side project. I needed something that would let me: Fetch data without arbitrary limits Get real-time prices and trading volumes Access historical data without paying premium fees Scale up my analysis as needed Fetch data without arbitrary limits Get real-time prices and trading volumes Access historical data without paying premium fees Scale up my analysis as needed The Web Scraping Solution After some research and experimentation, I settled on scraping data from two main sources: CNN Money for trending stocks and Yahoo Finance for detailed metrics. Here's how I built it: Setting Up the Basic Infrastructure First, I installed the essential tools: pip install requests bs4 pip install requests bs4 Then I created a basic scraper that could handle network issues gracefully: import requests
from bs4 import BeautifulSoup
import time
import logging

def make_request(url, max_retries=3):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    for attempt in range(max_retries):
        try:
            return requests.get(url, headers=headers, timeout=10)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(attempt + 1) import requests
from bs4 import BeautifulSoup
import time
import logging

def make_request(url, max_retries=3):
    headers = {
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
    
    for attempt in range(max_retries):
        try:
            return requests.get(url, headers=headers, timeout=10)
        except Exception as e:
            if attempt == max_retries - 1:
                raise
            time.sleep(attempt + 1) Grabbing Trending Stocks I started with CNN Money's hot stocks list, which gives me three categories of stocks to track: def get_trending_stocks():
    url = 'https://money.cnn.com/data/hotstocks/index.html'
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    tables = soup.findAll("table", {"class": "wsod_dataTable wsod_dataTableBigAlt"})
    categories = ["Most Actives", "Gainers", "Losers"]
    
    stocks = []
    for i, table in enumerate(tables):
        for row in table.findAll("tr")[1:]:  # Skip headers
            cells = row.findAll("td")
            if cells:
                stocks.append({
                    'category': categories[i],
                    'symbol': cells[0].find(text=True),
                    'company': cells[0].span.text.strip()
                })
    
    return stocks def get_trending_stocks():
    url = 'https://money.cnn.com/data/hotstocks/index.html'
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    tables = soup.findAll("table", {"class": "wsod_dataTable wsod_dataTableBigAlt"})
    categories = ["Most Actives", "Gainers", "Losers"]
    
    stocks = []
    for i, table in enumerate(tables):
        for row in table.findAll("tr")[1:]:  # Skip headers
            cells = row.findAll("td")
            if cells:
                stocks.append({
                    'category': categories[i],
                    'symbol': cells[0].find(text=True),
                    'company': cells[0].span.text.strip()
                })
    
    return stocks Getting the Financial Details For each trending stock, I fetch additional data from Yahoo Finance: def get_stock_details(symbol):
    url = f"https://finance.yahoo.com/quote/{symbol}"
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    data = {}
    
    # Find the main quote table
    table = soup.find("table", {"class": "W(100%)"})
    if table:
        for row in table.findAll("tr"):
            cells = row.findAll("td")
            if len(cells) > 1:
                key = cells[0].text.strip()
                value = cells[1].text.strip()
                data[key] = value
    
    return data def get_stock_details(symbol):
    url = f"https://finance.yahoo.com/quote/{symbol}"
    response = make_request(url)
    soup = BeautifulSoup(response.text, "html.parser")

    data = {}
    
    # Find the main quote table
    table = soup.find("table", {"class": "W(100%)"})
    if table:
        for row in table.findAll("tr"):
            cells = row.findAll("td")
            if len(cells) > 1:
                key = cells[0].text.strip()
                value = cells[1].text.strip()
                data[key] = value
    
    return data The Gotchas I Encountered Building this wasn't all smooth sailing. Here are some real issues I hit and how I solved them: Rate Limiting: Yahoo Finance started blocking me after too many rapid requests. I added random delays between requests: Rate Limiting : Yahoo Finance started blocking me after too many rapid requests. I added random delays between requests: Rate Limiting time.sleep(random.uniform(1, 3))  # Random delay between 1-3 seconds time.sleep(random.uniform(1, 3))  # Random delay between 1-3 seconds Data Inconsistencies: Sometimes the scraped data would be malformed. I added validation: Data Inconsistencies : Sometimes the scraped data would be malformed. I added validation: Data Inconsistencies def validate_price(price_str):
    try:
        return float(price_str.replace('$', '').replace(',', ''))
    except:
        return None def validate_price(price_str):
    try:
        return float(price_str.replace('$', '').replace(',', ''))
    except:
        return None Website Changes: The sites occasionally update their HTML structure. I made my selectors more robust: Website Changes : The sites occasionally update their HTML structure. I made my selectors more robust: Website Changes # Instead of exact class matches, use partial matches
table = soup.find("table", class_=lambda x: x and 'dataTable' in x) # Instead of exact class matches, use partial matches
table = soup.find("table", class_=lambda x: x and 'dataTable' in x) Storing and Using the Data I keep things simple with CSV storage - it's easy to work with and perfect for my needs: import csv
from datetime import datetime

def save_stock_data(stocks):
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
    with open('stock_data.csv', 'a', newline='') as file:
        writer = csv.writer(file)
        for stock in stocks:
            writer.writerow([timestamp, stock['symbol'], 
                           stock['price'], stock['volume']]) import csv
from datetime import datetime

def save_stock_data(stocks):
    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
    
    with open('stock_data.csv', 'a', newline='') as file:
        writer = csv.writer(file)
        for stock in stocks:
            writer.writerow([timestamp, stock['symbol'], 
                           stock['price'], stock['volume']]) What I Learned After running this scraper for several weeks, here are my key takeaways: After running this scraper for several weeks, here are my key takeaways: Web scraping isn't just a hack - it's a viable alternative to expensive APIs when done rightly. Building in error handling and logging from the start saves huge headaches later. Stock data is messy - so always validate what you scrape. Starting simple and iterating works better than trying to build everything at once! Web scraping isn't just a hack - it's a viable alternative to expensive APIs when done rightly. Building in error handling and logging from the start saves huge headaches later. Stock data is messy - so always validate what you scrape. Starting simple and iterating works better than trying to build everything at once! What's Next? I'm currently working on adding: I'm currently working on adding: News sentiment analysis Basic pattern recognition A simple dashboard for visualization News sentiment analysis Basic pattern recognition A simple dashboard for visualization Also, would you like to integrate this scraper with machine learning models to predict stock trends? Let me know in the comments! machine learning models

How to Build a No-Limits Stock Market Scraper with Python

Table of Links Abstract and I. Introduction II. Background III. Related Works IV. Comparative Analysis V. Findings and Evaluation VI. Conclusion and References V. FINDINGS AND EVALUATION Through this research we’ve observed the inability to successfully implement layer-one sharding on account based transactional models. As demonstrated in section III. B account based systems implement layer-two scaling to emulate the parallelization of UTXO sharding. We also observe the inability for off-chain automation dependent solutions to exist on UTXO based systems, due to smart contract incompatibility. The impact of this lack of solution interoperability between layer one and two presents a glass ceiling of scale out potential. Layer two projects such as Plasma still rely on a heavily constrained main chain for coordination and dispute resolution, zero-knowledge and optimistic rollups all have similar dependencies on parent coordination. If sharding were implemented harmoniously underneath these architectures, bottlenecks would be avoided in main-chain coordination. This allows both scalability layers to scale-out by a factor of the other. Imagine a scenario where a mainchain can handle 10,000 transactions-per-second through off-chain scaling and smart contract automation. The overall network architecture can continually scale on layer-two through nested parent/child relationships, however coordination and resolution cause a mainchain bottleneck. Resolving this with layer-one solutions, such as OmniLedgers linear scale-out sharding would increase potential speeds by a factor of n, where n is equal to mainchain parrelization. To address this we propose the use of an Extended-UTXO model that allows for smart contract compatibility. This specification allows for off-chain automation in rollups, while maintaining the ability to shard UTXO states and transactions at layer-one. A. Design Architecture The eUTXO follows the same graph based approach that the UTXO model does, complementing the concurrent and distributed attributes of blockchains. The graph based model eliminates the need for a globally shared mutable state, which is known to cause highly complex problems when facing computations involving that shared state [6]. The first account model blockchain, Ethereum, did solve how to run expressive smart contracts on a global state machine capable of execution on-chain. The eUTXO is an extension onto the UTXO ledger which notably increases the expressiveness of the model, while still utilizing the concurrent data flows of unspent transactions. In creating a more extensible model, transactions can occur on more expressive state machines without needing to use an account model. Each individual transaction that occurs on a concurrent chain represents steps in state machine and to utilize a more expressive model, the state needs to be maintained and the same contract code is used along the whole sequence of transactions. The eUTXO model maintains contract state by extending unspent transaction outputs from being a pair of validator and digital asset to a now being a treble containing a validator, the asset and a datum, where the datum contains arbitrary contract specific data [6]. The eUTXO model implements local state machines which are capable of running smart contracts on them to produces new unspent transactions as well as maintain the new state to be maintained. This enables developers to build distributed applications on massively scalable platforms. OmniLedger inspired sharding protocols will be adapted to the eUTXO model using verifiable random function (VRF) to accomplish network sharding at layer-one [20]. We intend to use a temporary shard coordinator delegated through VRF election, to generate an unbiased random string. Each epoch the unbiased random string is used in shard assignment. eUTXO transactions will be assigned through the use of a randomly chosen directory service shard. This phase is based on Zilliqa’s approach to transaction sharding [22]. We intend to use the unbiased random string generated by the temporary epoch coordinator to delegate this directory service shard. The directory shard will assign transactions to shards based on the sender’s address and smart contract state being interacted with. Smart contract states will be maintained in the eUTXO transactions respective shard. Contracts will be fully executed globally at the end of each epoch when the directory service coordinator synchronises the entire network state. As the eUTXO model supports the use of smart contracts, further layer 2 solutions such as Zero-Knowledge and Optimistic Rollups could be implemented, and even create nestedchains that communicate through smart contract two-way pegs which could increase throughput exponentially. Authors:
(1) Cayo Fletcher-Smith, Bournemouth University;
(2) Frazer Chard. This paper is available on arxiv under CC0 1.0 DEED license. Table of Links Abstract and I. Introduction Abstract and I. Introduction II. Background II. Background III. Related Works III. Related Works IV. Comparative Analysis IV. Comparative Analysis V. Findings and Evaluation V. Findings and Evaluation VI. Conclusion and References VI. Conclusion and References V. FINDINGS AND EVALUATION Through this research we’ve observed the inability to successfully implement layer-one sharding on account based transactional models. As demonstrated in section III. B account based systems implement layer-two scaling to emulate the parallelization of UTXO sharding. We also observe the inability for off-chain automation dependent solutions to exist on UTXO based systems, due to smart contract incompatibility. The impact of this lack of solution interoperability between layer one and two presents a glass ceiling of scale out potential. Layer two projects such as Plasma still rely on a heavily constrained main chain for coordination and dispute resolution, zero-knowledge and optimistic rollups all have similar dependencies on parent coordination. If sharding were implemented harmoniously underneath these architectures, bottlenecks would be avoided in main-chain coordination. This allows both scalability layers to scale-out by a factor of the other. Imagine a scenario where a mainchain can handle 10,000 transactions-per-second through off-chain scaling and smart contract automation. The overall network architecture can continually scale on layer-two through nested parent/child relationships, however coordination and resolution cause a mainchain bottleneck. Resolving this with layer-one solutions, such as OmniLedgers linear scale-out sharding would increase potential speeds by a factor of n, where n is equal to mainchain parrelization. To address this we propose the use of an Extended-UTXO model that allows for smart contract compatibility. This specification allows for off-chain automation in rollups, while maintaining the ability to shard UTXO states and transactions at layer-one. A. Design Architecture A. Design Architecture The eUTXO follows the same graph based approach that the UTXO model does, complementing the concurrent and distributed attributes of blockchains. The graph based model eliminates the need for a globally shared mutable state, which is known to cause highly complex problems when facing computations involving that shared state [6]. The first account model blockchain, Ethereum, did solve how to run expressive smart contracts on a global state machine capable of execution on-chain. The eUTXO is an extension onto the UTXO ledger which notably increases the expressiveness of the model, while still utilizing the concurrent data flows of unspent transactions. In creating a more extensible model, transactions can occur on more expressive state machines without needing to use an account model. Each individual transaction that occurs on a concurrent chain represents steps in state machine and to utilize a more expressive model, the state needs to be maintained and the same contract code is used along the whole sequence of transactions. The eUTXO model maintains contract state by extending unspent transaction outputs from being a pair of validator and digital asset to a now being a treble containing a validator, the asset and a datum, where the datum contains arbitrary contract specific data [6]. The eUTXO model implements local state machines which are capable of running smart contracts on them to produces new unspent transactions as well as maintain the new state to be maintained. This enables developers to build distributed applications on massively scalable platforms. OmniLedger inspired sharding protocols will be adapted to the eUTXO model using verifiable random function (VRF) to accomplish network sharding at layer-one [20]. We intend to use a temporary shard coordinator delegated through VRF election, to generate an unbiased random string. Each epoch the unbiased random string is used in shard assignment. eUTXO transactions will be assigned through the use of a randomly chosen directory service shard. This phase is based on Zilliqa’s approach to transaction sharding [22]. We intend to use the unbiased random string generated by the temporary epoch coordinator to delegate this directory service shard. The directory shard will assign transactions to shards based on the sender’s address and smart contract state being interacted with. Smart contract states will be maintained in the eUTXO transactions respective shard. Contracts will be fully executed globally at the end of each epoch when the directory service coordinator synchronises the entire network state. As the eUTXO model supports the use of smart contracts, further layer 2 solutions such as Zero-Knowledge and Optimistic Rollups could be implemented, and even create nestedchains that communicate through smart contract two-way pegs which could increase throughput exponentially. Authors: (1) Cayo Fletcher-Smith, Bournemouth University; (2) Frazer Chard. Authors: Authors: (1) Cayo Fletcher-Smith, Bournemouth University; (2) Frazer Chard. This paper is available on arxiv under CC0 1.0 DEED license. This paper is available on arxiv under CC0 1.0 DEED license. available on arxiv

New Research Reveals How Blockchain Can Scale Beyond Current Limits with eUTXO

Authors:
(1) Avrim Blum, Toyota Technological Institute at Chicago, IL, USA;
(2) Melissa Dutz, Toyota Technological Institute at Chicago, IL, USA. Table of Links Abstract and 1 Introduction 2 Setting and 2.1 Models of behaviorally-biased opponents 3 Preliminaries and Intuition 4.1 Myopic Best Responder and 4.2 Gambler’s Fallacy Opponent 4.3 Win-Stay, Lose-Shift Opponent 4.4 Follow-the-Leader Opponent and 4.5 Highest Average Payoff Opponent 5 Generalizing 5.1 Other Behaviorally-Biased Strategies 5.2 Exploiting an Unknown Strategy from a Known Set of Strategies 6 Future Work and References A Appendix A.1 Win-Stay Lose-Shift Variant: Tie-Stay A.2 Follow-the-Leader Variant: Limited History A.3 Ellipsoid Mistake Bounds A.4 Highest Average Payoff Opponent A.2 Follow-the-Leader Variant: Limited History Recall that the limited-history variant of the Follow-the-Leader opponent plays the action that would have achieved the highest net payoff against the last r rounds of our play. Note that we assume r > 0. If r = 0, the opponent would simply play the same action every round (the first action in their action ordering) regardless of our play. In that case, their play would not reveal any information about best responses, so the best we could do is tie in most rounds by playing the same action as the opponent. We again use the ellipsoid algorithm for prediction, essentially the same way as described for the unlimited-history variant of this opponent in 4.4. In this case, the inequality we observe when a mistake is made is only relative to the past r rounds. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Avrim Blum, Toyota Technological Institute at Chicago, IL, USA; (2) Melissa Dutz, Toyota Technological Institute at Chicago, IL, USA. Authors: Authors: (1) Avrim Blum, Toyota Technological Institute at Chicago, IL, USA; (2) Melissa Dutz, Toyota Technological Institute at Chicago, IL, USA. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2 Setting and 2.1 Models of behaviorally-biased opponents 2 Setting and 2.1 Models of behaviorally-biased opponents 3 Preliminaries and Intuition 3 Preliminaries and Intuition 4.1 Myopic Best Responder and 4.2 Gambler’s Fallacy Opponent 4.1 Myopic Best Responder and 4.2 Gambler’s Fallacy Opponent 4.3 Win-Stay, Lose-Shift Opponent 4.3 Win-Stay, Lose-Shift Opponent 4.4 Follow-the-Leader Opponent and 4.5 Highest Average Payoff Opponent 4.4 Follow-the-Leader Opponent and 4.5 Highest Average Payoff Opponent 5 Generalizing 5.1 Other Behaviorally-Biased Strategies 5.1 Other Behaviorally-Biased Strategies 5.2 Exploiting an Unknown Strategy from a Known Set of Strategies 5.2 Exploiting an Unknown Strategy from a Known Set of Strategies 6 Future Work and References 6 Future Work and References A Appendix A.1 Win-Stay Lose-Shift Variant: Tie-Stay A.1 Win-Stay Lose-Shift Variant: Tie-Stay A.2 Follow-the-Leader Variant: Limited History A.2 Follow-the-Leader Variant: Limited History A.3 Ellipsoid Mistake Bounds A.3 Ellipsoid Mistake Bounds A.4 Highest Average Payoff Opponent A.4 Highest Average Payoff Opponent A.2 Follow-the-Leader Variant: Limited History Recall that the limited-history variant of the Follow-the-Leader opponent plays the action that would have achieved the highest net payoff against the last r rounds of our play. Note that we assume r > 0. If r = 0, the opponent would simply play the same action every round (the first action in their action ordering) regardless of our play. In that case, their play would not reveal any information about best responses, so the best we could do is tie in most rounds by playing the same action as the opponent. We again use the ellipsoid algorithm for prediction, essentially the same way as described for the unlimited-history variant of this opponent in 4.4. In this case, the inequality we observe when a mistake is made is only relative to the past r rounds. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Ways to Counter Limited-History Opponents with Algorithmic Tools

To Pump The Gas Or Not: Analyzing The Ethereum Gas Limit Debate

Qazı Pompalamaq və ya etməmək: Ethereum Qaz Limiti Müzakirəsinin Təhlili

Pumpati plin ili ne: Analiza debate o ograničenju Ethereum plina

At pumpe gassen eller ej: Analyse af Ethereum-gasgrænsedebatten

Bombear gasolina o no: análisis del debate sobre el límite de gas de Ethereum

ガスを注入するか否か: イーサリアムのガス制限論争を分析

Gas pompen of niet: analyse van het Ethereum-gaslimietdebat

Kuvoma gaze cyangwa Oya: Gusesengura Impaka za Gaz ya Ethereum

ගෑස් පොම්ප කිරීමට හෝ නොකිරීමට: Ethereum ගෑස් සීමාව විවාදය විශ්ලේෂණය කිරීම

Kupomba Gasi Kana Kuti Kwete: Kuongorora Iyo Ethereum Gasi Limit Gakava

Për të pompuar gazin apo jo: duke analizuar debatin e kufirit të gazit Ethereum

Ukumpompa igesi okanye hayi: Ukuhlalutya iNgxoxo yoMda weGesi ye-Ethereum

Ukupompa Igesi Noma Cha: Ukuhlaziya Inkulumo-mpikiswano Yomkhawulo Wegesi ye-Ethereum

Chrome extensions are a great way for developers to provide users with useful tools without having to build an entire web app. However, Chrome extensions have a specific structure, and data persistence can be tricky. While there are great docs for Chrome’s Storage API, that doesn’t cover everything. Currently, no single resource clearly explains all the options for persisting state in Chrome extensions for different durations. This guide explains the options and limitations for state persistence in Chrome extensions, helping developers choose the best fit for their projects. Popup lifetime storage - the default for popups For Chrome extensions that use a popup, anytime the user opens a popup, it is a new instance of that popup. So if the user closes the popup (which happens automatically if they click into the browser), and then reopens it, that new popup will not remember or be aware of anything done previously. Side Panel lifetime storage - default for side panels Like popups, when the user closes and reopens a side panel, they are creating a new instance of the side panel.  Data will only persist as long as the side panel is open, and any data created when they had the side panel open earlier will be lost. However, unlike popups, side panels will not automatically close whenever the user clicks outside of it, so side panels are able to have much longer lifetimes than popups. A side panel can stay open as the user navigates to different web pages in a tab or even different tabs within Chrome. As a result, data in a side panel is capable of persisting much longer than in a popup, though it still will be lost if the user closes and reopens it. Page Lifetime Storage - Message Passing If an extension interacts with the webpage, the extension must track changes or actions already taken. For instance, if an extension changes a web page’s colors to display in dark mode, it should remember this, so it does not prompt the user to repeat something they have already done. Additionally, if the user refreshes the page, any previously executed code is cleared. So, we don’t want to persist data beyond the current page session, as it will be outdated. To handle this, we use message passing. The content script has the code we run on the webpage, which automatically persists for the page lifetime. However, as mentioned above, popups and side panels - the UIs for the user - do not. Message passing allows us to make sure the UIs are up to date. First, we define the state in the content script (e.g., "initial," "loading," "success," or "error"). We pass a message every time it changes so the UI is up to date. We also request the current state every time the popup or side panel is opened. So if the user closes and reopens a popup while the extension is loading, the new popup will request the state, receive ‘loading’, and render the ‘loading’ UI. Here is an example: popup.js chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
   chrome.tabs.sendMessage(tabs[0].id, {action: "getExtensionState"}, function(response) {
       // if the content script hasn't been injected, then the code in that script hasn't been run, and we'll get an error or no response
       if (chrome.runtime.lastError || !response) {
           return;
       } else if (response) {
           // if the code in content script has been injected, we'll get a response which tells us what state the code is at (initial, loading, success, error, etc)
           renderUI(response.extensionState)
       }
   });
}); content-script.js let extensionState = 'initial';

chrome.runtime.onMessage.addListener(
   function(request, sender, sendResponse) {
     if (request.action === "getExtensionState")
       sendResponse({extensionState});
   }); In some cases, the content script will be injected every time we open the extension. In others, we run the content script at a specific time - ie, the user clicks a button in the popup, which then injects the code (ie,  “Click me to display this page in dark mode”). If the content script has never been run, we will get an error when we send the “getExtensionState” message from the popup. The first if statement in the example popup.js code is there to catch that error and allow us to do whatever we want to do. Deprecated: extension lifetime - background worker This option is deprecated and no longer usable. However, a lot of Chrome resources are older, and it’s not always obvious which 8 year old Stack Overflow answers are still relevant and which ones aren’t, so I’m briefly touching on it so you know not to try to implement this. In past versions of Chrome extensions, there was the option of ‘background workers’ (V2 background worker docs). It was possible to set these to ‘persist,’ and they would stay active for the extension instance lifetime, and across tabs. The field ‘background’ still exists in Manifest V3, but it is now considered a service worker and only stays active as long as it is running code - it is put to sleep within 30 seconds of inactivity (service workers docs). There is no out of the box option to set these service workers as persistent. Chrome Storage API Chrome’s Storage API provides multiple options to persist data longer. To use any of these, you’ll have to add ‘storage’ permissions in the Manifest. The docs for the Chrome Storage API are here and cover the final three options. Browser Session storage - chrome.storage.session The shortest Chrome Storage API option is chrome session storage, which holds data in memory for the duration of the Chrome browser session. In this context, a Chrome browser session is the time period any windows are open with the same Chrome profile. So if a user has two Chrome windows open, closes one but the other remains open, the user is still in the same browser session, and the data will persist. Additionally, if the user refreshes the page or closes the tab, the data will persist. The data will be cleared only if they close all browser windows for that Chrome profile, restart Chrome, or reload the extension. Example implementation from the API docs: chrome.storage.session.set({ key: value }).then(() => {
  console.log("Value was set");
});

chrome.storage.session.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Extension installation lifetime storage - chrome.storage.local Chrome’s local storage allows the data to be saved as long as the extension is installed. It will persist even if the page is refreshed, or the browser is fully closed and reopened. It is only cleared if the extension is removed or chrome.storage.local.clear() is called. Example implementation from the API docs: chrome.storage.local.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.local.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Storage across chrome devices - chrome.storage.sync
Chrome’s sync storage will sync the saved data to any Chrome browser the user is logged into. If a user does not have sync enabled, it will fall back to local storage behavior. The data is only cleared if the extension is uninstalled or chrome.storage.local.clear() is called. Example implementation from the API docs: chrome.storage.sync.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.sync.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Did I miss anything? Please let me know in the comments! Chrome extensions are a great way for developers to provide users with useful tools without having to build an entire web app. However, Chrome extensions have a specific structure, and data persistence can be tricky. While there are great docs for Chrome’s Storage API, that doesn’t cover everything. Currently, no single resource clearly explains all the options for persisting state in Chrome extensions for different durations. This guide explains the options and limitations for state persistence in Chrome extensions, helping developers choose the best fit for their projects. Chrome extensions Popup lifetime storage - the default for popups Popup lifetime storage - the default for popups Popup lifetime storage - the default for popups For Chrome extensions that use a popup, anytime the user opens a popup, it is a new instance of that popup. So if the user closes the popup (which happens automatically if they click into the browser), and then reopens it, that new popup will not remember or be aware of anything done previously. Side Panel lifetime storage - default for side panels Side Panel lifetime storage - default for side panels Side Panel lifetime storage - default for side panels Like popups, when the user closes and reopens a side panel, they are creating a new instance of the side panel.  Data will only persist as long as the side panel is open, and any data created when they had the side panel open earlier will be lost. However, unlike popups, side panels will not automatically close whenever the user clicks outside of it, so side panels are able to have much longer lifetimes than popups. A side panel can stay open as the user navigates to different web pages in a tab or even different tabs within Chrome. As a result, data in a side panel is capable of persisting much longer than in a popup, though it still will be lost if the user closes and reopens it. Page Lifetime Storage - Message Passing Page Lifetime Storage - Message Passing Page Lifetime Storage - Message Passing Page Lifetime Storage - Message Passing If an extension interacts with the webpage, the extension must track changes or actions already taken. For instance, if an extension changes a web page’s colors to display in dark mode, it should remember this, so it does not prompt the user to repeat something they have already done. Additionally, if the user refreshes the page, any previously executed code is cleared. So, we don’t want to persist data beyond the current page session, as it will be outdated. To handle this, we use message passing. The content script has the code we run on the webpage, which automatically persists for the page lifetime. However, as mentioned above, popups and side panels - the UIs for the user - do not. Message passing allows us to make sure the UIs are up to date. First, we define the state in the content script (e.g., "initial," "loading," "success," or "error"). We pass a message every time it changes so the UI is up to date. We also request the current state every time the popup or side panel is opened. So if the user closes and reopens a popup while the extension is loading, the new popup will request the state, receive ‘loading’, and render the ‘loading’ UI. Here is an example: popup.js popup.js chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
   chrome.tabs.sendMessage(tabs[0].id, {action: "getExtensionState"}, function(response) {
       // if the content script hasn't been injected, then the code in that script hasn't been run, and we'll get an error or no response
       if (chrome.runtime.lastError || !response) {
           return;
       } else if (response) {
           // if the code in content script has been injected, we'll get a response which tells us what state the code is at (initial, loading, success, error, etc)
           renderUI(response.extensionState)
       }
   });
}); chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
   chrome.tabs.sendMessage(tabs[0].id, {action: "getExtensionState"}, function(response) {
       // if the content script hasn't been injected, then the code in that script hasn't been run, and we'll get an error or no response
       if (chrome.runtime.lastError || !response) {
           return;
       } else if (response) {
           // if the code in content script has been injected, we'll get a response which tells us what state the code is at (initial, loading, success, error, etc)
           renderUI(response.extensionState)
       }
   });
}); content-script.js content-script.js let extensionState = 'initial';

chrome.runtime.onMessage.addListener(
   function(request, sender, sendResponse) {
     if (request.action === "getExtensionState")
       sendResponse({extensionState});
   }); let extensionState = 'initial';

chrome.runtime.onMessage.addListener(
   function(request, sender, sendResponse) {
     if (request.action === "getExtensionState")
       sendResponse({extensionState});
   }); In some cases, the content script will be injected every time we open the extension. In others, we run the content script at a specific time - ie, the user clicks a button in the popup, which then injects the code (ie,  “Click me to display this page in dark mode”). If the content script has never been run, we will get an error when we send the “getExtensionState” message from the popup. The first if statement in the example popup.js code is there to catch that error and allow us to do whatever we want to do. Deprecated: extension lifetime - background worker Deprecated: extension lifetime - background worker Deprecated: extension lifetime - background worker This option is deprecated and no longer usable. However, a lot of Chrome resources are older, and it’s not always obvious which 8 year old Stack Overflow answers are still relevant and which ones aren’t, so I’m briefly touching on it so you know not to try to implement this. In past versions of Chrome extensions, there was the option of ‘background workers’ ( V2 background worker docs ). It was possible to set these to ‘persist,’ and they would stay active for the extension instance lifetime, and across tabs. The field ‘background’ still exists in Manifest V3, but it is now considered a service worker and only stays active as long as it is running code - it is put to sleep within 30 seconds of inactivity ( service workers docs ). There is no out of the box option to set these service workers as persistent. V2 background worker docs service workers docs Chrome Storage API Chrome’s Storage API provides multiple options to persist data longer. To use any of these, you’ll have to add ‘storage’ permissions in the Manifest. The docs for the Chrome Storage API are here and cover the final three options. The docs for the Chrome Storage API are here Browser Session storage - chrome.storage.session Browser Session storage - chrome.storage.session Browser Session storage - chrome.storage.session The shortest Chrome Storage API option is chrome session storage, which holds data in memory for the duration of the Chrome browser session. In this context, a Chrome browser session is the time period any windows are open with the same Chrome profile. So if a user has two Chrome windows open, closes one but the other remains open, the user is still in the same browser session, and the data will persist. Additionally, if the user refreshes the page or closes the tab, the data will persist. The data will be cleared only if they close all browser windows for that Chrome profile, restart Chrome, or reload the extension. Example implementation from the API docs: chrome.storage.session.set({ key: value }).then(() => {
  console.log("Value was set");
});

chrome.storage.session.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); chrome.storage.session.set({ key: value }).then(() => {
  console.log("Value was set");
});

chrome.storage.session.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Extension installation lifetime storage - chrome.storage.local Extension installation lifetime storage - chrome.storage.local Extension installation lifetime storage - chrome.storage.local Chrome’s local storage allows the data to be saved as long as the extension is installed. It will persist even if the page is refreshed, or the browser is fully closed and reopened. It is only cleared if the extension is removed or chrome.storage.local.clear() is called. Example implementation from the API docs: chrome.storage.local.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.local.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); chrome.storage.local.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.local.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Storage across chrome devices - chrome.storage.sync
Chrome’s sync storage will sync the saved data to any Chrome browser the user is logged into. If a user does not have sync enabled, it will fall back to local storage behavior. The data is only cleared if the extension is uninstalled or chrome.storage.local.clear() is called. Storage across chrome devices - chrome.storage.sync Chrome’s sync storage will sync the saved data to any Chrome browser the user is logged into. If a user does not have sync enabled, it will fall back to local storage behavior. The data is only cleared if the extension is uninstalled or chrome.storage.local.clear() is called. Storage across chrome devices - chrome.storage.sync Storage across chrome devices - chrome.storage.sync Chrome’s sync storage will sync the saved data to any Chrome browser the user is logged into. If a user does not have sync enabled, it will fall back to local storage behavior. The data is only cleared if the extension is uninstalled or chrome.storage.local.clear() is called. Example implementation from the API docs: Example implementation from the API docs: chrome.storage.sync.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.sync.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); chrome.storage.sync.set({ key: value }).then(() => {
  console.log("Value is set");
});

chrome.storage.sync.get(["key"]).then((result) => {
  console.log("Value is " + result.key);
}); Did I miss anything? Please let me know in the comments!

State Storage in Chrome Extensions: Options, Limits, and Best Practices

Challenges for Life in the Venusian Clouds Include Severe Acidity, Extreme Dryness, & Limited Water

Authors:
(1) Clauvin Almeida, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil;
(2) Marcos Kalinowski, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil;
(3) Anderson Uchoa, Federal University of Ceara (UFC), Itapaje, Brazil;
(4) Bruno Feijo, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil. Table of Links Abstract and 1 Introduction 2. Background and Related Work and 2.1. Gamification 2.2. Game Design Elements and 2.3. Gamification Effects 2.4. Related Work on Gamification Negative Effects 3. Systematic Mapping and 3.1. The Research Questions 3.2. Search Strategy and 3.3. Inclusion and Exclusion Criteria 3.4. Applying the Search Strategy 3.5. Data Extraction 4. Systematic Mapping Results 5. Focus Group: Developer Perception on the Negative Effects of Game Design Elements 5.1. Context and Participant Characterization 5.2. Focus Group Design 5.3. The Developers’ Perception on The Negative Effects 5.4. On the Perceived Usefulness, Ease of use and Intent of Adoption of Mapped Negative Effects 5.5. Participant Feedback 6. Limitations 7. Concluding Remarks 7.1. Future Research Directions Acknowledgements and References 6. Limitations One of the limitations of our mapping study concerns potentially missing papers. After analyzing 3458 papers (see the list in our online repository), based on our inclusion and exclusion criteria, we initially included 79 papers. While our combined search strategy allowed identifying significantly more papers than the database search strategy employed by Toda et al. [27] (we identified 34 papers published between 2012 and 2016, against 17), the sets had differences. Therefore, we manually included the papers found by Toda et al., which were missed by our first search and extended searches, ending up with a final set of 87 papers. It is noteworthy that we verified that many of the missed papers would also have been retrieved by subsequent snowballing iterations. Nevertheless, an extension applying subsequent snowballing iterations and investigating different hybrid strategies [15], would require significant additional effort, involving analyzing several thousands of papers which could characterize a different publication instead of an extension. We are confident that our final set of included papers as part of this publication allowed providing an unbiased and meaningful overview of the adverse effects related to GDEs in gamified education software. Another risk of false negatives concerns the filtering process. We screened all papers considering only titles, abstracts, and keywords, which may not contain sufficient information to decide upon inclusion. We avoided applying EC1 and EC3 during the initial screening to lower this risk, only excluding papers that we had high confidence of not investigating GDE effects (EC1) and reporting negative effects (EC3). In case of any doubt, the paper was left for full text-based assessment. Moreover, the application of the inclusion and exclusion criteria made by the first author was reviewed by the second and fourth authors in meetings. In case of doubt, during the initial screening or full-text-based assessment, discussions were held to reach a consensus. Furthermore, we chose not to consider grey literature as part of our inclusion criteria. There is the possibility of relevant grey literature that does not have equivalent in non-grey academic papers. On the other hand, even though we did not explicitly evaluate the strength of evidence, the results herein reported are based on peer-reviewed research and backed by empirical studies. Moreover, while research that reaches negative results is essential because it shows us what does not work [115], there still seems to be a publication bias towards positive outcomes. Research reporting negative results tends to have less scientific interest, fewer citations, and to be less often published [116]. Hence, there may be additional negative results that were not published and which, for that reason, could not be included in our mapping study. Finally, in our summary of the negative effects of GDEs (cf. Figure 4), we included negative effects that may affect different roles (e.g., the students and the maintainers/teachers responsible for configuring the system and keeping it up and running with appropriate educational resources), as we found them reported in the literature. Our goal was to organize evidence regarding the overall adverse effects of GDEs in gamified education software. While we included an overview of the negative effects for different roles (e.g., RQ1.B and RQ1.C), we considered a fine-grained analysis of the effects of each GDEs for each of these roles out of the scope of our intended overview and part of future work. With regard to the focus group session, we wanted to gather insights on the mapped negative effects of game design elements from the point of view of practitioners. In a virtual focus group, generally, the number of participants is reduced, four being considered appropriate (our case) [117]. However, it is suggested to plan more online focus groups with fewer participants than when conducting face-to-face groups [118]. While we carefully planned our focus group, followed best practices, and carefully conducted our qualitative analyses, a single session is surely a limitation. Therefore, we interpret the focus group results as preliminary complementary discussions with practitioners, avoiding validity claims. Nevertheless, we had rich discussions that nicely complemented our literature study findings. It is noteworthy that these discussions already revealed interesting facts, such as the potential unawareness of developers about the negative effects of GDEs, and some example arguments on the perceived pros and cons of including the GDEs in gamified software. Still, we are aware that a single focus group is not be enough to reach generalizable findings. Unfortunately, identifying teams with experience in developing gamified software and willing to collaborate with academia is not a trivial task. Therefore, conducting new focus group sessions is part of future work. This paper is available on arxiv under CC BY 4.0 DEED license. Authors: (1) Clauvin Almeida, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil; (2) Marcos Kalinowski, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil; (3) Anderson Uchoa, Federal University of Ceara (UFC), Itapaje, Brazil; (4) Bruno Feijo, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil. Authors: Authors: (1) Clauvin Almeida, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil; (2) Marcos Kalinowski, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil; (3) Anderson Uchoa, Federal University of Ceara (UFC), Itapaje, Brazil; (4) Bruno Feijo, Pontifical Catholic University of Rio de Janeiro (PUC-Rio), Rio de Janeiro, Brazil. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2. Background and Related Work and 2.1. Gamification 2. Background and Related Work and 2.1. Gamification 2.2. Game Design Elements and 2.3. Gamification Effects 2.2. Game Design Elements and 2.3. Gamification Effects 2.4. Related Work on Gamification Negative Effects 2.4. Related Work on Gamification Negative Effects 3. Systematic Mapping and 3.1. The Research Questions 3. Systematic Mapping and 3.1. The Research Questions 3.2. Search Strategy and 3.3. Inclusion and Exclusion Criteria 3.2. Search Strategy and 3.3. Inclusion and Exclusion Criteria 3.4. Applying the Search Strategy 3.4. Applying the Search Strategy 3.5. Data Extraction 3.5. Data Extraction 4. Systematic Mapping Results 4. Systematic Mapping Results 5. Focus Group: Developer Perception on the Negative Effects of Game Design Elements 5. Focus Group: Developer Perception on the Negative Effects of Game Design Elements 5.1. Context and Participant Characterization 5.1. Context and Participant Characterization 5.2. Focus Group Design 5.2. Focus Group Design 5.3. The Developers’ Perception on The Negative Effects 5.3. The Developers’ Perception on The Negative Effects 5.4. On the Perceived Usefulness, Ease of use and Intent of Adoption of Mapped Negative Effects 5.4. On the Perceived Usefulness, Ease of use and Intent of Adoption of Mapped Negative Effects 5.5. Participant Feedback 5.5. Participant Feedback 6. Limitations 6. Limitations 7. Concluding Remarks 7. Concluding Remarks 7.1. Future Research Directions 7.1. Future Research Directions Acknowledgements and References Acknowledgements and References 6. Limitations One of the limitations of our mapping study concerns potentially missing papers. After analyzing 3458 papers (see the list in our online repository), based on our inclusion and exclusion criteria, we initially included 79 papers. While our combined search strategy allowed identifying significantly more papers than the database search strategy employed by Toda et al. [27] (we identified 34 papers published between 2012 and 2016, against 17), the sets had differences. Therefore, we manually included the papers found by Toda et al., which were missed by our first search and extended searches, ending up with a final set of 87 papers. It is noteworthy that we verified that many of the missed papers would also have been retrieved by subsequent snowballing iterations. Nevertheless, an extension applying subsequent snowballing iterations and investigating different hybrid strategies [15], would require significant additional effort, involving analyzing several thousands of papers which could characterize a different publication instead of an extension. We are confident that our final set of included papers as part of this publication allowed providing an unbiased and meaningful overview of the adverse effects related to GDEs in gamified education software. Another risk of false negatives concerns the filtering process. We screened all papers considering only titles, abstracts, and keywords, which may not contain sufficient information to decide upon inclusion. We avoided applying EC1 and EC3 during the initial screening to lower this risk, only excluding papers that we had high confidence of not investigating GDE effects (EC1) and reporting negative effects (EC3). In case of any doubt, the paper was left for full text-based assessment. Moreover, the application of the inclusion and exclusion criteria made by the first author was reviewed by the second and fourth authors in meetings. In case of doubt, during the initial screening or full-text-based assessment, discussions were held to reach a consensus. Furthermore, we chose not to consider grey literature as part of our inclusion criteria. There is the possibility of relevant grey literature that does not have equivalent in non-grey academic papers. On the other hand, even though we did not explicitly evaluate the strength of evidence, the results herein reported are based on peer-reviewed research and backed by empirical studies. Moreover, while research that reaches negative results is essential because it shows us what does not work [115], there still seems to be a publication bias towards positive outcomes. Research reporting negative results tends to have less scientific interest, fewer citations, and to be less often published [116]. Hence, there may be additional negative results that were not published and which, for that reason, could not be included in our mapping study. Finally, in our summary of the negative effects of GDEs (cf. Figure 4), we included negative effects that may affect different roles (e.g., the students and the maintainers/teachers responsible for configuring the system and keeping it up and running with appropriate educational resources), as we found them reported in the literature. Our goal was to organize evidence regarding the overall adverse effects of GDEs in gamified education software. While we included an overview of the negative effects for different roles (e.g., RQ1.B and RQ1.C), we considered a fine-grained analysis of the effects of each GDEs for each of these roles out of the scope of our intended overview and part of future work. With regard to the focus group session, we wanted to gather insights on the mapped negative effects of game design elements from the point of view of practitioners. In a virtual focus group, generally, the number of participants is reduced, four being considered appropriate (our case) [117]. However, it is suggested to plan more online focus groups with fewer participants than when conducting face-to-face groups [118]. While we carefully planned our focus group, followed best practices, and carefully conducted our qualitative analyses, a single session is surely a limitation. Therefore, we interpret the focus group results as preliminary complementary discussions with practitioners, avoiding validity claims. Nevertheless, we had rich discussions that nicely complemented our literature study findings. It is noteworthy that these discussions already revealed interesting facts, such as the potential unawareness of developers about the negative effects of GDEs, and some example arguments on the perceived pros and cons of including the GDEs in gamified software. Still, we are aware that a single focus group is not be enough to reach generalizable findings. Unfortunately, identifying teams with experience in developing gamified software and willing to collaborate with academia is not a trivial task. Therefore, conducting new focus group sessions is part of future work. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

Limitations and Insights on The Effects of GDEs in Education

Authors:
(1) Dan Kondratyuk, Google Research and with Equal contribution;
(2) Lijun Yu, Google Research, Carnegie Mellon University and with Equal contribution;
(3) Xiuye Gu, Google Research and with Equal contribution;
(4) Jose Lezama, Google Research and with Equal contribution;
(5) Jonathan Huang, Google Research and with Equal contribution;
(6) Grant Schindler, Google Research;
(7) Rachel Hornung, Google Research;
(8) Vighnesh Birodkar, Google Research;
(9) Jimmy Yan, Google Research;
(10) Krishna Somandepalli, Google Research;
(11) Hassan Akbari, Google Research;
(12) Yair Alon, Google Research;
(13) Yong Cheng, Google DeepMind;
(14) Josh Dillon, Google Research;
(15) Agrim Gupta, Google Research;
(16) Meera Hahn, Google Research;
(17) Anja Hauth, Google Research;
(18) David Hendon, Google Research;
(19) Alonso Martinez, Google Research;
(20) David Minnen, Google Research;
(21) Mikhail Sirotenko, Google Research;
(22) Kihyuk Sohn, Google Research;
(23) Xuan Yang, Google Research;
(24) Hartwig Adam, Google Research;
(25) Ming-Hsuan Yang, Google Research;
(26) Irfan Essa, Google Research;
(27) Huisheng Wang, Google Research;
(28) David A. Ross, Google Research;
(29) Bryan Seybold, Google Research and with Equal contribution;
(30) Lu Jiang, Google Research and with Equal contribution. Table of Links Abstract and 1 Introduction 2. Related Work 3. Model Overview and 3.1. Tokenization 3.2. Language Model Backbone and 3.3. Super-Resolution 4. LLM Pretraining for Generation 4.1. Task Prompt Design 4.2. Training Strategy 5. Experiments 5.1. Experimental Setup 5.2. Pretraining Task Analysis 5.3. Comparison with the State-of-the-Art 5.4. LLM’s Diverse Capabilities in Video Generation and 5.5. Limitations 6. Conclusion, Acknowledgements, and References A. Appendix 5.4. LLM’s Diverse Capabilities in Video Generation This subsection presents several capabilities we discover from the pretrained VideoPoet, shedding light on the LLM’s promising potential in video generation. By combining the flexibility of our autoregressive language model to perform diverse tasks such as extending video in time, inpainting, outpainting, and stylization, VideoPoet accomplishes multiple tasks in a unified model. Coherent long video generation and image-to-video. A benefit of an decoder-based language model is that it pairs well with autoregressively extending generation in time. We present two different variants: Generating longer videos and converting images to videos. Encoding the first frame independently allows us to convert any image into the initial frame of a video without padding. Subsequent frames are generated by predicting remaining tokens, transforming the image into a video as shown in Fig. 6 [1]. based on previously generated video, and produces temporally consistent videos without significant distortion. Such capabilities are rarely observed in contemporary diffusion models. Zero-shot video editing and task chaining. With the multi-task pretraining, VideoPoet exhibits task generalization that can be chained together to perform novel tasks. We show the model can apply image-to-video animation followed by video-to-video stylization in Fig. 7. In the Appendix, Fig. 10 shows another example applying video-tovideo outpainting, followed by editing them with additional video-to-video effects. At each stage, the quality of the output is sufficient to remain in-distribution (i.e. teacher forcing) for the next stage without noticeable artifacts. These capabilities can be attributed to our multimodal task design within an LLM transformer framework that allows for modeling multimodal content using a single transformer architecture over a unified vocabulary. Zero-shot video stylization. Stylization results are presented in Appendix A.4 where the structure and text are used as prefixes to guide the language model. Unlike other stylization methods that employ adapter modules such as cross-attention networks (Zhang et al., 2023b) or latent blending (Meng et al., 2021), our approach stylizes videos within an LLM as one of several generative tasks. 3D structure, camera motion, visual styles. Even though we do not add specific training data or losses to encourage 3D consistency, our model can rotate around objects and predict reasonable visualizations of the backside of objects. Additionally, with only a small proportion of input videos and texts describing camera motion, our model can use short text prompts to apply a range of camera motions to image-to-video and text-to-video generations (see Fig. 11). 5.5. Limitations Despite VideoPoet demonstrating highly competitive performance of LLMs relative to state-of-the-art models, certain limitations are still observed. For example, the RGB frame reconstruction from compressed and quantized tokens place an upper bound on the generative model’s visual fidelity. Second, the per-frame aesthetic biases in static scenes does not match the best baseline. This difference is largely due to a choice of training data, where we focus our training on more natural aesthetics and excluded some sources containing copyrighted images, such as LAION (Schuhmann et al., 2022), which is commonly used in other work. Finally, small objects and fine-grained details, especially when coupled with significant motions, remains difficult within the token-based modeling. This paper is available on arxiv under CC BY 4.0 DEED license. [1] For image-to-video examples we source images from Wikimedia Commons: https://commons.wikimedia.org/wiki/Main Page Authors: (1) Dan Kondratyuk, Google Research and with Equal contribution; (2) Lijun Yu, Google Research, Carnegie Mellon University and with Equal contribution; (3) Xiuye Gu, Google Research and with Equal contribution; (4) Jose Lezama, Google Research and with Equal contribution; (5) Jonathan Huang, Google Research and with Equal contribution; (6) Grant Schindler, Google Research; (7) Rachel Hornung, Google Research; (8) Vighnesh Birodkar, Google Research; (9) Jimmy Yan, Google Research; (10) Krishna Somandepalli, Google Research; (11) Hassan Akbari, Google Research; (12) Yair Alon, Google Research; (13) Yong Cheng, Google DeepMind; (14) Josh Dillon, Google Research; (15) Agrim Gupta, Google Research; (16) Meera Hahn, Google Research; (17) Anja Hauth, Google Research; (18) David Hendon, Google Research; (19) Alonso Martinez, Google Research; (20) David Minnen, Google Research; (21) Mikhail Sirotenko, Google Research; (22) Kihyuk Sohn, Google Research; (23) Xuan Yang, Google Research; (24) Hartwig Adam, Google Research; (25) Ming-Hsuan Yang, Google Research; (26) Irfan Essa, Google Research; (27) Huisheng Wang, Google Research; (28) David A. Ross, Google Research; (29) Bryan Seybold, Google Research and with Equal contribution; (30) Lu Jiang, Google Research and with Equal contribution. Authors: Authors: (1) Dan Kondratyuk, Google Research and with Equal contribution; (2) Lijun Yu, Google Research, Carnegie Mellon University and with Equal contribution; (3) Xiuye Gu, Google Research and with Equal contribution; (4) Jose Lezama, Google Research and with Equal contribution; (5) Jonathan Huang, Google Research and with Equal contribution; (6) Grant Schindler, Google Research; (7) Rachel Hornung, Google Research; (8) Vighnesh Birodkar, Google Research; (9) Jimmy Yan, Google Research; (10) Krishna Somandepalli, Google Research; (11) Hassan Akbari, Google Research; (12) Yair Alon, Google Research; (13) Yong Cheng, Google DeepMind; (14) Josh Dillon, Google Research; (15) Agrim Gupta, Google Research; (16) Meera Hahn, Google Research; (17) Anja Hauth, Google Research; (18) David Hendon, Google Research; (19) Alonso Martinez, Google Research; (20) David Minnen, Google Research; (21) Mikhail Sirotenko, Google Research; (22) Kihyuk Sohn, Google Research; (23) Xuan Yang, Google Research; (24) Hartwig Adam, Google Research; (25) Ming-Hsuan Yang, Google Research; (26) Irfan Essa, Google Research; (27) Huisheng Wang, Google Research; (28) David A. Ross, Google Research; (29) Bryan Seybold, Google Research and with Equal contribution; (30) Lu Jiang, Google Research and with Equal contribution. Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 2. Related Work 2. Related Work 3. Model Overview and 3.1. Tokenization 3. Model Overview and 3.1. Tokenization 3.2. Language Model Backbone and 3.3. Super-Resolution 3.2. Language Model Backbone and 3.3. Super-Resolution 4. LLM Pretraining for Generation 4.1. Task Prompt Design 4.1. Task Prompt Design 4.2. Training Strategy 4.2. Training Strategy 5. Experiments 5.1. Experimental Setup 5.1. Experimental Setup 5.2. Pretraining Task Analysis 5.2. Pretraining Task Analysis 5.3. Comparison with the State-of-the-Art 5.3. Comparison with the State-of-the-Art 5.4. LLM’s Diverse Capabilities in Video Generation and 5.5. Limitations 5.4. LLM’s Diverse Capabilities in Video Generation and 5.5. Limitations 6. Conclusion, Acknowledgements, and References 6. Conclusion, Acknowledgements, and References A. Appendix A. Appendix 5.4. LLM’s Diverse Capabilities in Video Generation This subsection presents several capabilities we discover from the pretrained VideoPoet, shedding light on the LLM’s promising potential in video generation. By combining the flexibility of our autoregressive language model to perform diverse tasks such as extending video in time, inpainting, outpainting, and stylization, VideoPoet accomplishes multiple tasks in a unified model. Coherent long video generation and image-to-video. A benefit of an decoder-based language model is that it pairs well with autoregressively extending generation in time. We present two different variants: Generating longer videos and converting images to videos. Encoding the first frame independently allows us to convert any image into the initial frame of a video without padding. Subsequent frames are generated by predicting remaining tokens, transforming the image into a video as shown in Fig. 6 [1]. based on previously generated video, and produces temporally consistent videos without significant distortion. Such capabilities are rarely observed in contemporary diffusion models. Zero-shot video editing and task chaining. With the multi-task pretraining, VideoPoet exhibits task generalization that can be chained together to perform novel tasks. We show the model can apply image-to-video animation followed by video-to-video stylization in Fig. 7. In the Appendix, Fig. 10 shows another example applying video-tovideo outpainting, followed by editing them with additional video-to-video effects. At each stage, the quality of the output is sufficient to remain in-distribution (i.e. teacher forcing) for the next stage without noticeable artifacts. These capabilities can be attributed to our multimodal task design within an LLM transformer framework that allows for modeling multimodal content using a single transformer architecture over a unified vocabulary. Zero-shot video editing and task chaining. Zero-shot video stylization. Stylization results are presented in Appendix A.4 where the structure and text are used as prefixes to guide the language model. Unlike other stylization methods that employ adapter modules such as cross-attention networks (Zhang et al., 2023b) or latent blending (Meng et al., 2021), our approach stylizes videos within an LLM as one of several generative tasks. Stylization results are presented in Appendix A.4 where the structure 3D structure, camera motion, visual styles. Even though we do not add specific training data or losses to encourage 3D consistency, our model can rotate around objects and predict reasonable visualizations of the backside of objects. 3D structure, camera motion, visual styles. Additionally, with only a small proportion of input videos and texts describing camera motion, our model can use short text prompts to apply a range of camera motions to image-to-video and text-to-video generations (see Fig. 11). 5.5. Limitations Despite VideoPoet demonstrating highly competitive performance of LLMs relative to state-of-the-art models, certain limitations are still observed. For example, the RGB frame reconstruction from compressed and quantized tokens place an upper bound on the generative model’s visual fidelity. Second, the per-frame aesthetic biases in static scenes does not match the best baseline. This difference is largely due to a choice of training data, where we focus our training on more natural aesthetics and excluded some sources containing copyrighted images, such as LAION (Schuhmann et al., 2022), which is commonly used in other work. Finally, small objects and fine-grained details, especially when coupled with significant motions, remains difficult within the token-based modeling. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [1] For image-to-video examples we source images from Wikimedia Commons: https://commons.wikimedia.org/wiki/Main Page

LIMIT

limit.com

-- employees

Since n.d.

COMPANY RANKING

LIMIT

EVERGREEN INDEX #7912

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

Limit WIKI

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

LIMIT

limit.com

-- employees

Since n.d.

COMPANY RANKING

LIMIT

EVERGREEN INDEX #7912

RELATED COMPANIESRANK

STORIES ABOUT LIMIT

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

Limit WIKI

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