At MarketDial we're building software that enables companies to design and execute business experiments

MarketDial

is a multi-tool component that keeps a company afloat through many channels and approaches. It is a multiverse of metrics–you just have to find what works for you. But how do you decide whether to stick with proven approaches or follow the latest trends? The truth is, the nature of the digital landscape is ever-changing and you can never really know when the latest marketing obsession will once again become obsolete. It’s just the nature of things and in 2024 we all have to deal with it. The good news is that the overall trends are not as fleeting as they might seem, and keeping up to date with forecasts for the upcoming months can give your business the much-needed push to catch your audience’s attention in the highly competitive field. Now, few things seem to be especially prominent amongst marketing trends right now, but before we dive headfirst into modern marketing, let’s recap the basics. Marketing Why should you care? While sticking to the “if it ain’t broke, don’t fix it” philosophy certainly has its benefits, in the modern day and age staying up to date is imperative to building a successful business. Your audience has ever-changing and evolving preferences, and your competitors continually explore new strategies to see what works and what doesn’t. If you want to stay relevant, you have to put effort into understanding what "staying relevant"  in your field means. Is it creating an AI campaign for a new feature or partnering up with a user for an honest review? Your competitors reside in the same limitless space as you do–the internet, the main thing that drives progress and competition. There is plenty of useful information getting out daily, the question is: who is going to get there first? First, set your priorities In response to the very dynamic nature of social media marketing, brands are now ready to focus their attention on platforms that closely align with their goals and audience preferences. Now, that doesn’t mean you should abandon all channels except one; the goal is to prioritize a few and keep the rest low-key because having a prominent social media presence is the hallmark of good, recognizable branding. You can save time and target a specific platform instead of many, like spending your time and money on campaigns when your audience spends most of their time on . Instead, create engaging YouTube videos, showcase product demos, collaborate with influencers, build a strong presence through community engagement, and curate visually appealing content on Facebook YouTube Instagram. This is just an example, and the way you do it will be unique to your product and your goals. By identifying your priorities you can direct your attention where it needs to go, effectively reaching and engaging your audience, driving brand awareness and sales in a competitive market. Now that your priorities are set, we can get into the upcoming trends. The creativity of AI In recent years the creativity of AI has gotten truly mind-blowing. With the recent we have seen a new horizon for the creative potential of AI. While this specific tool is not released just yet, there are plenty that can help you in the process of content generation. Major brands are already collaborating with AI to create new-age marketing campaigns. , which ended up winning at the Drum Awards Festival, an annual global competition for marketers. And Nike allowed their customers to –powered by AI. , unveiling of Sora Heinz launched one with DALLE-2 design their own unique pair of shoes There are plenty of examples out there. Big companies are using artificial intelligence not only for content creation but for ideation and strategy too. There are research assistants, generative apps, tools that can enhance resolution and ones that can make up a whole marketing strategy. Can it replace a whole marketing team? Probably not, but AI will for sure become a much more present trend in the coming years. Yet, here you’ll have to be more careful since to downrank AI-generated summarized content. Google is already implementing measures User-generated content In contrast to using machines to do the work, chances are we will be seeing much more user-generated content in the near future. There’s already plenty of it, and according to the brand engagement rises by 28% when consumers see both brand and user-generated content, and user-generated videos gain 10x views than brand videos posted on YouTube. It’s expected–we trust people, and a human presence in a campaign makes it much more trustworthy. Statistics can back this up–85% of users find user-made content more influential than branded content (also according to the Gitnux report). These days creating a tikTok with a creator raving about your product is more likely to get you more reach than placing a billboard on Times Square. As you can see, an unpolished video can have more benefits than a perfectly crafted campaign. It’s authentic, and that’s its main allure. It also has to be done right. A big part of this is generating an environment that will eventually build a strong brand community. Regular communication and giveaways will make your users more likely to want to take part in creating content for you. And when they do, reward it! It’s already a very cost-effective tool, so you can direct your resources towards supporting this type of engagement. But if you choose to use this approach for your business don’t make it feel plastic. The modern consumer is overwhelmed with content and will be able to easily distinguish real from fake. Gitnux Marketdata report Micro-Influencer Marketing On the road to authenticity, brands are now scaling down their collaborations with influencers. In the past years, we’ve seen it all and a brand deal from a celebrity is now simply a given in the media space. But the market is oversaturated and brands are looking for new ways to engage the same audiences by slightly changing their approach. The by the Influencer Marketing Hub highlights a notable preference among marketers and businesses towards collaborating with nano- and micro-influencers. The reason is simple–higher engagement rates. Why? Because smaller-scale influencers seem more trustworthy. And, this strategy is much more cost-effective for the brand. 2024 State of Influencer Marketing report Partnership Marketing Competition is the driver of progress. But what if you make your rivals (or just brands that you probably share an audience with) your collaborators? You already have so much in common: your audience and your goals. That’s enough to entertain the idea of partnership marketing to help both of your brands grow and reach new customers. Imagine the value you bring–doubled. This approach also allows you to cut costs, share resources, and exchange ideas with other teams. luxury brands partner with hotels, tech companies collaborate with cafe chains, and retail stores are more than happy to spice things up by introducing a non-profit company special offer. Brands do this all the time; High-quality content No matter which direction you go, high-quality content will remain a priority. We’ve all seen how annoying those extremely low-quality mobile ads can get. While this can get users’ attention, forget about it positioning your company as a respectable brand. These days humanity is overwhelmed with the amount of content that is up for consumption and so much of it is not at all well-made. It’s an opportunity for you to earn customer loyalty by putting effort into every step of content creation: from ideation to execution. To further perfect your process you can conduct interviews with your potential customers to see what matters to them. This way you will be more attuned to your audience, so setting up an appropriate Tone of Voice and tailoring the type of content to your clients is bound to bring much better results. Your work is you An easy way to up the quality and effectiveness of the marketing content you produce is to remember that what you do is a reflection of who you are, and the way your brand communicates with its audience is a reflection of the values that lie at the core of your company. Treating your potential customers with respect by creating relevant, engaging, high-quality content will build a bond that is not achievable by dry marketing techniques and metrics.

2024 Marketing Insights: Content, Partnerships, AI Implementation and More

Mobula API is a powerful tool that allows developers to access curated datasets for various crypto assets, such as market data, wallet transactions, historical balances, and swap quotes. Mobula API provides a unified and aggregated interface to query data from multiple blockchains and sources. In this article, you will learn how to use Mobula API to fetch and display market data for any assets using React, a popular front-end library for building user interfaces. Mobula API Overview Mobula API is a blockchain data provider that offers developers a wide range of features and functionalities. It provides curated datasets, market data with Octopus, wallet data, metadata with Metacore, and REST, GraphSQL & SQL interfaces to query them. Mobula API supports several chains, including: Ethereum, Avalanche, Polygon, Fantom, Harmony, xDai, Cronos, DFK Subnet, SmartBCH, Celo, Klaytn, Aurora, HECO, Arbitrum, And more. Developers can access vital data and perform key operations using Mobula API’s endpoints, designed to provide seamless integration and efficient access to blockchain features. Mobula API also offers easy-to-integrate tools to fetch market data, wallet transactions, holdings, etc. Retrieving Bitcoin Market Data Key Requirements for API Calls: API Key: Mandatory for production environments. Obtainable from your Mobula Dashboard. Not required for development mode. Method: Use GET to retrieve data. Base URL: https://api.mobula.io/api/1/ Endpoint: /market/query (for market data queries) Query parameters: Parameter Type Description Available Values filters string A comma-separated list of filters to apply to the data. liquidity, market_cap, volume, price, price_change_24h, price_change_1h, price_change_7d sortBy string A comma-separated list of fields to sort the data by. liquidity, market_cap, volume, price, price_change_24h, price_change_1h, price_change_7d sortOrder string The order in which to sort the data. asc (ascending), desc (descending) Example Usage: This example demonstrates how to retrieve market data for with and . mid-cap cryptocurrencies strong liquidity promising potential Parameter Breakdown: : filters : Selects assets with (inclusive). This ensures sufficient trading volume for easy entry and exit. liquidity:100:1000 liquidity between 100 and 1000 : Chooses assets with (inclusive). This range targets mid-cap projects with established value and room for growth. market_cap:10000:100000 market capitalization between 10,000 and 100,000 : Sorts the retrieved data by . This prioritizes larger and potentially more stable assets. sortBy=market_cap market capitalization in descending order : Specifies . This displays the largest cap currencies first, making it easier to identify prominent mid-cap contenders. sortOrder=desc descending order for sorting filters=liquidity:100:1000,market_cap:10000:100000
sortBy=market_cap
sortOrder=desc Response: {
    "name": "NFTDAO",
    "logo": "https://metacore.mobula.io/d0acfb425c161c8e3e5426c77ec36128ecfd688c2367a411cab9c440acb8b7a3.png",
    "symbol": "NAO",
    "liquidity": 769,
    "market_cap": 97230,
    "volume": 0,
    "price": 9.723276418969192e-10,
    "price_change_1h": 0,
    "price_change_24h": 0,
    "price_change_7d": 0,
    "contracts": [
      {
        "address": "0xd049206fb408a611e543791f2d8f102a8bc253dc",
        "blockchain": "Ethereum",
        "blockchainId": "1",
        "decimals": 18
      }
    ],
    "id": 4696,
    "rank": 4673
  } Explanation of the response: Field Description Value name Name of the cryptocurrency NFTDAO logo URL of the cryptocurrency’s logo 1 symbol Symbol of the cryptocurrency NAO liquidity Liquidity of the cryptocurrency 769 market_cap Market capitalization of the cryptocurrency 97230 volume Volume of the cryptocurrency 0 price Price of the cryptocurrency 9.723276418969192e-10 price_change_1h Percentage change in price over the last hour 0 price_change_24h Percentage change in price over the last 24 hours 0 price_change_7d Percentage change in price over the last 7 days 0 contracts List of contracts associated with the cryptocurrency [{“address”: “0xd049206fb408a611e543791f2d8f102a8bc253dc”, “blockchain”: “Ethereum”, “blockchainId”: “1”, “decimals”: 18}] id Unique identifier for the cryptocurrency 4696 rank Rank of the cryptocurrency based on market capitalization Exploring Block Data with Mobula Queries To build a React project that interacts with the Mobula API and fetches data, follow these steps: Step 1: Set Up Your React Project First, ensure you have Node.js and npm installed on your machine. Then, create a new React project using Create React App: npm create vite@latest mobula-market-app -- --template react
cd mobula-market-app Step 2: Install Dependencies Install Axios, a popular HTTP client for making API requests, to handle HTTP requests in your React project: npm install axios Step 3: Create a Component for API Interaction Create a new file named inside the directory to contain the logic for fetching market data: MarketData.js src // src/MarketData.js
import React, { useState, useEffect } from "react";
import axios from "axios";
import { Line } from "react-chartjs-2";

const MarketData = () => {
  const [marketData, setMarketData] = useState(null);
  const [selectedCrypto, setSelectedCrypto] = useState(null);
  const [filters, setFilters] = useState("");
  const [sortBy, setSortBy] = useState("");
  const [sortOrder, setSortOrder] = useState("");
  const [showModal, setShowModal] = useState(false);

  const fetchData = async () => {
    try {
      const response = await axios.get(
        `https://api.mobula.io/api/1/market/query?filters=${filters}&sortBy=${sortBy}&sortOrder=${sortOrder}`
      );
      setMarketData(response.data);
    } catch (error) {
      console.error("Error fetching data:", error);
    }
  };

  useEffect(() => {
    fetchData();
  }, [filters, sortBy, sortOrder]);

  const handleCardClick = (item) => {
    setSelectedCrypto(item);
    setShowModal(true); // Ensure showModal is set to true when a card is clicked
  };

  const handleCloseModal = () => {
    setShowModal(false);
  };

  const renderChart = () => {
    if (!selectedCrypto) return null;

    const data = {
      labels: ["1h", "24h", "7d"],
      datasets: [
        {
          label: "Price Change",
          data: [
            selectedCrypto.price_change_1h,
            selectedCrypto.price_change_24h,
            selectedCrypto.price_change_7d,
          ],
          fill: false,
          borderColor: "rgb(75, 192, 192)",
          tension: 0.1,
        },
      ],
    };

    return (
      <div
        style={{
          position: "fixed",
          top: "50%",
          left: "50%",
          transform: "translate(-50%, -50%)",
          backgroundColor: "#fff",
          padding: "20px",
          zIndex: 9999,
        }}
      >
        <button
          onClick={handleCloseModal}
          style={{ position: "absolute", top: "10px", right: "10px" }}
        >
          Close
        </button>
        <h3>Price Change Chart for {selectedCrypto.name}</h3>
        <Line data={data} />
      </div>
    );
  };

  const renderCryptoCards = (cryptoData) => {
    return cryptoData.map((item, index) => (
      <div
        key={item.id}
        style={{
          border: "1px solid #ccc",
          borderRadius: "5px",
          padding: "10px",
          marginBottom: "20px",
          width: "calc(33.33% - 20px)",
          marginRight: "20px",
          display: "inline-block",
        }}
      >
        <img
          src={item.logo}
          alt={`${item.name} logo`}
          style={{ width: "50px", height: "50px", marginRight: "10px" }}
        />
        <div>
          <h3>{item.name}</h3>
          <p>
            <strong>Symbol:</strong> {item.symbol}
          </p>
          <p>
            <strong>Liquidity:</strong> {item.liquidity}
          </p>
          <p>
            <strong>Market Cap:</strong> {item.market_cap}
          </p>
          <button onClick={() => handleCardClick(item)}>View Graph</button>
        </div>
      </div>
    ));
  };

  const renderBlockchainTabs = () => {
    if (!marketData) return null;

    const categorizedData = {};

    marketData.forEach((item) => {
      const blockchain = item.contracts[0].blockchain;
      if (!categorizedData[blockchain]) {
        categorizedData[blockchain] = [];
      }
      categorizedData[blockchain].push(item);
    });

    return Object.entries(categorizedData).map(([blockchain, data]) => (
      <div key={blockchain}>
        <h2>{blockchain}</h2>
        <div style={{ display: "flex", flexWrap: "wrap" }}>
          {renderCryptoCards(data)}
        </div>
      </div>
    ));
  };

  const handleSubmit = (e) => {
    e.preventDefault();
    fetchData();
  };

  return (
    <div>
      <form onSubmit={handleSubmit}>
        <label>
          Filters:
          <input
            type="text"
            value={filters}
            onChange={(e) => setFilters(e.target.value)}
          />
        </label>
        <label>
          Sort By:
          <select value={sortBy} onChange={(e) => setSortBy(e.target.value)}>
            <option value="">Select</option>
            <option value="liquidity">Liquidity</option>
            <option value="market_cap">Market Cap</option>
          </select>
        </label>
        <label>
          Sort Order:
          <select
            value={sortOrder}
            onChange={(e) => setSortOrder(e.target.value)}
          >
            <option value="">Select</option>
            <option value="asc">Ascending</option>
            <option value="desc">Descending</option>
          </select>
        </label>
        <button type="submit">Fetch Data</button>
      </form>
      {renderBlockchainTabs()}
      {showModal && renderChart()}
    </div>
  );
};

export default MarketData; Step 4: Integrate the Component in Your App Modify the file to include the component: App.js MarketData // src/App.js
import React from 'react';
import './App.css';
import MarketData from './MarketData';

function App() {
  return (
    <div className="App">
      <header className="App-header">
        <h1>Mobula Market Data</h1>
      </header>
      <main>
        <MarketData />
      </main>
    </div>
  );
}

export default App; Folder structure: Step 5: Run Your React App Start your React development server to see the app in action: npm start

Using Mobula to Fetch and Display Market Data For Assets

In this article, we would like to demonstrate how to build a small yet powerful scalping application that trades on the leading cryptocurrency exchange – Binance. The bot will be connected to Binance through XTRD FIX API to receive real-time normalized market data and to place/cancel orders. You can reuse this in your projects for free. source code Disclaimer: the bot is not a ready-to-use solution because it lacks risk controls and proper positions management. Although our R&D shows promising performance, do not expect to achieve the same results. Before we dive into the technical part, it’s worth explaining the logic behind the given trading bot. Scalping is a momentum-based trading style where positions hold for minutes or even seconds and then sell for profit (or small loss… a sacrifice to Mr. Market). When performed manually, it requires self-discipline, the ability to handle stress, make quick decisions, and act accordingly. Renko chart is one of the technical analysis tools that help reduce market noise and identify market trends more precisely. One of the authors of this article was introduced to Renko about 15 years ago and fell in love with it. To construct a single brick on a chart we should perform several simple steps: Define a brick size e.g. 10 points Define the price type to track. It can be bids, asks, trades, an average between the bid and ask, etc. Start tracking prices in real-time If the price changed more than 10 points, then form a new Renko brick in the corresponding direction. It is possible that the single price change can form more than one Renko brick. Here is our trading logic: Wait for a new Renko brick to be formed If it is an UP brick, then place a limit order to SELL with a price at the level of UP + 1 brick If it is a DOWN brick, then place a limit order to BUY with a price at the level of DOWN – 1 brick Continue monitoring the market for changing course or for execution If a newly formed brick changed its direction (this means that the price changed at least 2x of a brick size in the reverse direction), we should cancel our existing limit order and place another one with a new price and reversed direction. If the market moved in the direction we predicted, then our order gets executed and we should start over. Simply put, it is the good old “buy low, sell high” principle computerized and applied to crypto markets through XTRD FIX API. The bot itself contains several main components: Market data connector Trading connector Market data processor/Renko generator Simple OMS/EMS syste To make this technical-enough material more fun, we decided to build a small user interface to plot Renkos bricks and executions. Since all high-level details of implementation were discussed, let’s get started with the implementation part. To build Renko charts we need to establish a connection to a service called XTRD MD Feeder. It is responsible for disseminating real-time normalized market data from Binance (and other crypto exchanges) using FIX protocol. In comparison with WebSockets, FIX is faster and more reliable because it runs on top of a pure TCP/IP stack and has no additional intermediary layers. Using FIX protocol, you can easily subscribe to receive updates for one or many trading instruments available on Binance such as BTC/USDT, ETH/USDT, and so on. It is possible to specify what sort of information you’ll need – bids, asks, and/or trades. Another big advantage is that market data itself comes in incremental updates. This means that you receive only actual changes of the entire orders book (like 3-4 levels) but not a full book every time. This is not a big issue with Binance which already streams data as a delta (difference between the previous and current state) but can be extremely helpful with other crypto exchanges XTRD supports. There are three major messages defined by FIX standard and implemented inside XTRD that help manage your crypto market data streams – MarketDataRequest, MarketDataSnapshotFullRefresh, and MarketDataIncrementalRefresh. As it is easy to understand from their names, MarketDataRequest is used to manage your subscription (start or stop data streams), MarketDataSnapshotFullRefresh is used by the server to transmit the entire book, and MarketDataIncrementalRefresh is sent by the server when data (price or side) in the particular orders book changed. The market data management workflow is simple – once the application established a connection to XTRD OEMs over the FIX, it sends MarketDataRequest to subscribe to all updates on BTC/USDT (or another selected symbol) on Binance. If the request was successfully processed, XTRD OEMS for digital assets trading responds with a MarketDataSnapshotFullRefresh message that contains all levels for BTC/USDT orders book. The application uses this data to initiate the book and starts waiting for incoming MarketDataIncrementalRefreshes that carry small (and sometimes not very small) delta changes. These changes have to be applied to the book (delete levels, update sizes on a particular level, add new prices). Once a book is updated, the component responsible for Renko’s generation will check if the conditions to create a new brick are met or if the price is still within the interval. Now, when we have a working market data connection and Renkos charts, it’s time to start trading on Binance using FIX API. FIX specification contains plenty of different messages (commands and responses) that cover pretty much everything in a typical trade lifecycle starting from initiation to ending with trade confirmation and settlement. XTRD OEMS system allows managing orders (get all, place, cancel, replace) and viewing positions through the unified FIX API. When it comes to trading, there are three major messages – NewOrderSingle, OrderCancelRequest, and ExecutionReport. NewOrderSingle is used to initiate an order. The message allows specifying different order characteristics, such as side (e.g. BUY), size, type (e.g. LIMIT), symbol, time in force (e.g. Good Till Cancel), among others. Below is a textual representation of the raw FIX request to buy 0.001 BTC for USDT at Market on the Binance. In many cases, the server interacts with clients over ExecutionReports. This message is used to indicate changes of your orders over time – was it accepted or rejected, canceled, or executed, and if executed, what are the price and size? Each message has clear status, a clear ID, and a timestamp associated with it. Many exchanges have their own workflows. XTRD OEMS for digital assets trading helps normalize these statuses and make them identical across all supported platforms: Our demo application utilizes only two simple commands – NewOrderSingle (to place a new order) and OrderCancelRequest (to cancel an order we don’t need anymore). Another useful command is OrderCancelRequest. It is used to initiate the cancellation of a pending order or the outstanding amount of a partially filled order. Below is a sample of FIX-based OrderCancelRequest to cancel a pending order on Binance: Our demo application will send requests to open an order (using NewOrderSingle) and to cancel it (using OrderCancelRequest) over the FIX to Binance. The server will notify us (using ExecutionReports) in real-time about any status changes of our order(s). In real life, it’s always a good idea to separate business logic that makes decisions about entering or exiting the market from orders management. This component is usually complex and covers a vast array of scenarios of what can happen with orders starting from regular behavior when everything goes as expected and ending with different doomsday scenarios. For the sake of simplicity, in this sample, we decided to use oversimplified orders management which also handles incoming market data-related events (OMS.java). Below is the video of the working system (replayed with 50х speed): Building a successful trading system is a challenging task where you must overcome many obstacles. Our goal is to make sure that the connectivity between your application and target exchange (or exchanges) will not become one of these blocking factors. By using XTRD OEMS for digital assets trading, you can easily build a reliable system that can operate around the clock. Also published here .

Creating a Renko-based Scalper for Binance

“Virality isn’t luck. It’s not magic. And it’s not random. There’s a science behind why people talk and share. A recipe. A formula, even.” — Jonah Berger Do you still wait for the newspaper every day, not just for the news, but to fill up the latest crossword? The prospect of solving that piece of puzzle, one day at a time, gives many a sense of delight. Some people go jittery if they somehow miss a day; it has become part of their routine!! Know what has become a part of millions of people’s routines? It’s called Wordle. As you read, you’ll know what this latest internet sensation is and why it went viral. So, What Is Wordle? Wordle is a daily cryptic word game on the internet. A person needs to guess a five-letter English word in a maximum of six tries. The first try has to be a complete guess without any clues. Every word you guess, the game starts giving you clues for the answer word by changing the colour of the tiles in which the word is written. If a letter from your word exists in the answer word the letter tile turns yellow or green. Yellow indicates that letter present in the answer but it is not in the right position. Green indicates that the letter is present as well as it’s in the same position in the answer word. Image source: Wordle As you keep guessing, you should be able to crack the puzzle in six tries. What’s the Big Deal? Yeah yeah, we know you might be thinking, “what’s the big deal? It’s just a word game!”. Well, look at the number of players who played Wordle in: November 2021 - 90 January 2022 - 300,000 A week later - 2 million The numbers are rising every single day. In recent events, Wordle has been acquired by the New York Times in some undisclosed ‘seven figures’ and is now available to play on their website. Games like Wordle are amongst the key components of NYT’s marketing strategy. People loved Wordle so much, many alternate niche-based versions popped up. There is the very famous ‘Nerdle’ which is for maths lovers, Taylordle for Taylor Swift Fans aka Swifties, ‘Marketdle’ for marketers, and many more. As they say - it’s the best compliment if someone is copying you! The Origination/Love Story Like many great things, Wordle’s origin is connected to love. Josh Wardle (I love the name coincidence!), a Brooklyn-based software engineer, made this game for his partner, Palak Shah who loved cryptic puzzles. In the beginning, the game was available for just the two of them, but they later decided to open it up for their family. The family got hooked instantly and gradually through word-of-mouth many more people got glued to Wordle. What happened after is in front of you. Reasons Why Wordle Went Viral Wordle was not made with an intent to go viral and yet it managed to make a place in people’s hearts. Below are five reasons why Wordle went viral: Feeling of Agency - a principle of game theory Word-of-Mouth publicity Automated sharing of scores on social media especially Twitter FOMO - Fear of Missing Out Element of Scarcity Feeling Of Agency | Agency Expansion From the Game Theory perspective, a ‘Feeling of Agency’ refers to the feeling of control over actions and their consequences. In simpler terms, it is a feeling that drives you to continue making choices based on the positive results of your past actions. Almost all games have this ‘Feeling of Agency’ that drives the players. It is one of the strong reasons that drives people to continue playing any game. This feeling is quite strong in the case of Wordle. While playing the game, the first word is a completely random guess. All the guesses after that are based on the consequences of the previous guess. If a letter turns green, it means it’s in the right place of the answer word and hence you’ll continue placing it on that spot in all the next guesses. If a letter turns yellow, it means it is in the answer word but has to be placed somewhere else. In the next guesses, you’ll place it in different positions. With every guess - you narrow down your choices for the next attempt and get closer to the answer. The ability to get closer to the answer is actually the agency expansion. This sense of achieving something on one’s own, based on their own past actions; gives them a reason to continue playing Wordle. Word-of-Mouth Publicity There’s no better tool of marketing than Word-of-Mouth. Word-of-mouth was the strongest contributor to If someone likes something, they are going to tell it to others one way or the other. Unlike other forms of marketing, word-of-mouth is more credible as it comes from someone who has tried and tested what they are referring to. I heard of Wordle from 3-4 different people - once from our writer, once from a client who created their own version of Wordle called Marketdle, and more. Later I checked with my friends and acquaintances in WhatsApp groups and most recommendations came from friends or community. Hence word-of-mouth validated :) the virality of Squid Game as well. Automated Sharing of Scores Wordle’s score-sharing feature is the biggest reason for it becoming an internet sensation. Once you finish solving a puzzle, Wordle gives you an option to share the achievement with the help of colourful square-shaped grids. Without sharing the actual answer, one could showcase their achievement. These grids tell how the player managed to get the answer and how many tries it took him. Image source: Twitter Social media feeds started being bombarded with these square grids. Other than just solving Wordle daily, people became habitual of sharing their scores on their social media. From Instagram and Facebook stories to tweets, the grids were everywhere. Twitter alone clocked 3 million Wordle tweets just between 23rd December 2021 and 27th January 2022. FOMO - Fear of Missing Out The Feeling of Missing Out aka FOMO is the worst feeling ever. Once those colourful square grids started popping up on everyone’s feed, people who didn’t know anything about it started feeling left out. Not just these colourful score grids but there were memes about Wordle. Companies started using Wordle elements in their social media posts. It was as if everyone was going crazy about these green and yellow grids. That sheer idea drove many people to at least try the game and see for themselves. If they liked it, they kept coming back and spreading the word. Image source: Twitter Element of Scarcity Anything that is scarce is valued. It applies to games too. If you were given unlimited word puzzles to solve in a day, no matter how much you loved them, you'd get bored. But if there was just one puzzle a day, and you had to wait for twenty-four hours to solve the next one, you'd be hooked. That’s why crosswords and sudokus in newspapers are still solved with so much fervour. Wordle leveraged this element of scarcity to its benefit. There is just one puzzle a day that leaves you wanting for more once you finish it. There’s also a ‘streak’ feature that tells people the number of days they have been continuously playing Wordle, which makes them not miss a single day. If they miss, they lose that streak. Wrap Up: Why Did Wordle Go Viral? Wordle’s story is fun, exciting, loving, and inspiring for many disciplines. The feeling of agency inspires game creators to add elements of agency to bring people back again and again to the games. Word-of-mouth is still one of the strongest ways to make things go viral. But it works only if you give people a reason to talk about your creation whether it’s a game like Wordle or a series like Squid Game. Social media marketing can do wonders for your product if leveraged correctly. With this, we leave you to think about how you can make your creation a sensation.

Wordle: How the Latest Internet Sensation Went Viral

How to Build a Directed Acyclic Graph (DAG) - Towards Open Options Chains Part IV

In this post, we develop the essential code for extracting, transforming, and loading options data. We will need to retrieve data from the TD Ameritrade API, transform it, and load the data into the PostgreSQL database we created in . We will also run some checks to ensure that the pipeline works. Part I: Designing the Database The Series This is the second post in my series, : Towards Open Options Chains: A Data Pipeline Solution Database Design Foundational ETL Code Getting Started with Airflow Building the DAG Containerising the Pipeline Pre-requisites Operating system: Linux (I'm using Ubuntu 20.04). If you're on Windows, consider using [1]. Windows Subsystem for Linux Python 3.9 with the following packages/libraries and their dependencies installed: , , , and requests python-dotenv pandas psycopg2 Recap of Use Case The use case for the data is to run backtests of options trading strategies. Therefore, the data pipeline must collect sufficiently fine-grained data for us to do backtests. This means we'll need options prices, volumes, and the options greeks (e.g. delta, theta, and gamma), collected at sufficiently high frequency. Extract The first step in our pipeline involves the data. In our case, we will retrieve data from the . extracting TD Ameritrade (TDA) Option Chains API First, we will obtain credentials for using the API by doing the following: Head on over to the to sign up for a free account. TD Ameritrade developer site Go to and create an app. My Apps Note the , which is used for OAuth 2.0 token-based authentication. Consumer Key Next, we construct requests to the TDA Option Chains API in Python. We define a few parameters: We assume that we have a file ( ) in the same folder containing your API key in a variable . We will load it into Python using . Your API key: .env API_KEY=<your API key here> python-dotenv For now, we'll use Facebook (FB) as an example. Ticker: We need to specify the instrument too. For now, we query the data for puts only. Instrument: This defines the total number of strikes to be returned. We'll go for 50 as a start, but we should decrease this number to the minimum necessary to optimise storage costs. Strike Count: This refers to whether the options are in-the-money (ITM), out-of-the-money (OTM), etc. We'll request all of them. Range: We specify a start date and end date using Python's built-in module. I've chosen to use the current date as the start date and the day 45 days out as the end date. Date range: datetime That gives us the following: # Import modules
import json
import requests
from dotenv import dotenv_values

# Load environment variables - API key is accessible at env['API_KEY']
env = dotenv_values('.env')

# Configure dates
start_date = datetime.today()
end_date = start_date + timedelta(days=45)

# Other params
TICKER = 'FB'

# Configure request
headers = {'Authorization': ''}

params = (
    ('apikey', env['API_KEY']),
    ('symbol', TICKER),
    ('contractType', 'PUT'),
    ('strikeCount', '50'),
    ('range', 'ALL'),
    ('fromDate', start_date),
    ('toDate', end_date),
) We now use the library to send the request with the defined headers and parameters, receiving a JSON response with the options chain if all went well: requests # Get data
response = requests.get(
    'https://api.tdameritrade.com/v1/marketdata/chains',
    headers=headers,
    params=params
)

# Extract data
data = json.loads(response.content) The data is structured as follows: root
└── Puts/Calls
    └── Contract (by expiry date)
        └── Strike
            └── Fields (e.g. prices, greeks) We parse the JSON object using the following code to obtain a Pandas dataframe: # Extract puts data
puts = []
dates = list(data['putExpDateMap'].keys())

for date in dates:

    strikes = data['putExpDateMap'][date]

    for strike in strikes:
        puts += data['putExpDateMap'][date][strike]

# Define columns
columns = ['putCall', 'symbol', 'description', 'exchangeName', 'bid', 'ask',
    'last', 'mark', 'bidSize', 'askSize', 'bidAskSize', 'lastSize',
    'highPrice', 'lowPrice', 'openPrice', 'closePrice', 'totalVolume',
    'tradeDate', 'tradeTimeInLong', 'quoteTimeInLong', 'netChange',
    'volatility', 'delta', 'gamma', 'theta', 'vega', 'rho', 'openInterest',
    'timeValue', 'theoreticalOptionValue', 'theoreticalVolatility',
    'optionDeliverablesList', 'strikePrice', 'expirationDate',
    'daysToExpiration', 'expirationType', 'lastTradingDay', 'multiplier',
    'settlementType', 'deliverableNote', 'isIndexOption', 'percentChange',
    'markChange', 'markPercentChange', 'mini', 'inTheMoney', 'nonStandard']

# Convert to dataframe
puts = pd.DataFrame(puts, columns=columns) Transform The step will convert the data into the final structure/format to be loaded into Postgres. For our use case, it is fairly simple: (1) select the right columns and (2) ensure we have the right data types. transform First, inspecting the data, we identify several fields to keep (below). We will select only these fields for processing. Metadata: putCall, symbol, description, quoteTimeInLong (as unix timestamp) Contract info: openInterest, timeValue, theoreticalOptionalValue, strikePrice, expirationDate (as unix timestamp), daysToExpiration, volatility Trade data: bid, ask, last, bidSize, askSize, lastSize, highPrice, lowPrice, openPrice, closePrice, totalVolume Greeks: delta, gamma, theta, vega, rho Second, we ensure that the data is in the right format. Most of the columns have been parsed by Pandas correctly. Although we could assume that Pandas will continue to parse the data correctly, it may not be wise to do so. Suppose that for the first 6 months, the API has always returned 100% float values for the OHLC prices. One day, it starts to return the string , just like the options greeks data returned today. This results in Pandas now parsing the OHLC prices as types and the data loading step in the pipeline may fail. Hence, we should explicitly format the data. Also, for any data that was coerced to missing values, we fill that in with a placeholder value . nan object -99 The final step is to convert the column names into snake case. This is just a personal preference. The code to do everything we discussed is shown below: # Select columns
puts = puts[['putCall', 'symbol', 'description', 'bid', 'ask', 'last', 'bidSize',
    'askSize', 'lastSize', 'highPrice', 'lowPrice', 'openPrice',
    'closePrice', 'totalVolume', 'quoteTimeInLong', 'volatility', 'delta',
    'gamma', 'theta', 'vega', 'rho', 'openInterest', 'timeValue',
    'theoreticalOptionValue', 'strikePrice', 'expirationDate',
    'daysToExpiration']]

# Convert floats
def conv_num(x):
    return pd.to_numeric(x.astype(str).str.replace('NaN|nan', '', regex=True))

for col in ['bid', 'ask', 'last', 'highPrice', 'lowPrice', 'openPrice',
            'closePrice', 'volatility', 'delta', 'gamma', 'theta', 'vega',
            'rho', 'timeValue', 'theoreticalOptionalValue', 'strikePrice']:
    puts[col] = conv_num(puts[col])

# Specifically for puts delta: make it positive
puts['delta'] = -puts['delta']

# Convert strings
def conv_str(x):
    return x.astype(str)

for col in ['putCall', 'symbol', 'description']:
    puts[col] = conv_str(puts[col])

# Convert integers
def conv_int(x):
    return x.astype(int)

for col in ['bidSize', 'askSize', 'lastSize', 'totalVolume', 'quoteTimeInLong',
            'openInterest', 'expirationDate', 'daysToExpiration']:
    puts[col] = conv_int(puts[col])

# Fill missing values
puts = puts.fillna(-99)

# Rename columns
puts = puts.rename(columns={
    'putCall': 'put_call',
    'bidSize': 'bid_size',
    'askSize': 'ask_size',
    'lastSize': 'last_size',
    'highPrice': 'high_price',
    'lowPrice': 'low_price',
    'openPrice': 'open_price',
    'closePrice': 'close_price',
    'totalVolume': 'total_volume',
    'quoteTimeInLong': 'quote_time',
    'openInterest': 'open_interest',
    'timeValue': 'time_value',
    'theoreticalOptionValue': 'theoretical_value',
    'strikePrice': 'strike_price',
    'expirationDate': 'expiration_date',
    'daysToExpiration': 'dte',
}) Load After extracting the data and transforming it to conform to the defined schema, we will need to load the data into our Postgres database. We use , keeping only the first entry in the event of repeated rows: INSERT ... ON CONFLICT DO NOTHING INSERT INTO FB (<all columns here>) VALUES (<all values here>) ON CONFLICT DO NOTHING; We use the library to load the data from Python into Postgres. We follow the typical process of (1) defining the query (as above), (2) connecting to the database, (3) creating a cursor, (4) executing the query with the parameters, (5) committing the transaction, and then (6) closing the connection. Note that we have placed the database password into the file to avoid hardcoding it. psycopg2 .env import psycopg2 as pg2

col_str = ', '.join(puts.columns.tolist())
query_insert = f"INSERT INTO fb ({col_str}) VALUES %s ON CONFLICT DO NOTHING"

# Connect to database
conn = pg2.connect(
    host='localhost',
    database='optionsdata',
    user='postgres',
    password=env['DB_PASSWORD']
)

# Loop through rows
with conn.cursor() as cursor:
    for t in puts.itertuples(index=False, name=None):
        cursor.execute(query_insert % str(t))
    conn.commit()

# Close connection
conn.close() To inspect the data, we retrieve all records from the table using the following code: # Run select * query
with conn.cursor() as cursor:
    cursor.execute('SELECT * FROM fb;')
    df = pd.DataFrame(cur.fetchall(), columns=...) The first time we run both snippets above, we'll obtain a dataframe ( ) containing data from the latest API query. If we run it again without changing the API data, we should see no change to . df df Summary In this post, we achieved the following: Developed code to retrieve data from the TD Ameritrade Option Chains API Developed code to process the data Developed code to load the data from Python into the PostgreSQL table Checked that the loading worked as intended Putting everything together, we have a one-off script that enables us to extract data from an API, transform it, and load it into a Postgres database. This is similar in functionality to the solutions by [2], [3], and [4], which have data persisted in a database or file as opposed to a Pandas dataframe, putting them one level above the other solutions. Still, this is only a snapshot. We need to run this code repeatedly at different times of the day, and a tool to manage these runs. Kleppen BlackArbs Sauers In the next post, we will set up , a workflow orchestration tool commonly used for managing data pipelines. It will enable us to schedule ETL jobs for automated data collection. Apache Airflow Credits for image: Kevin Ku on Unsplash References D. Littlefield, (2020), The Startup Windows Subsystem for Linux E. Kleppen, (2020), TowardsDataScience Collecting Stock and Options Data Easily using Python and Ally Financial API - 3 Example Queries (2016), Blackarbs Aggregating Free Options Data with Python H. Sauers, (2019), freeCodeCamp How I get options data for free This article was first published here

Towards Open Options Chains Part II: Foundational ETL Code

Python for Data Science: How to Scrape Website Data via the Internet's Top 300 APIs

o-lap.org O-LAP is an open-source community run platform for designers to experiment with parametric furniture design. It is part exploration into a new way in thinking and working with design.Designers create parametric furniture designs as plugins into the framework.Registered designs gets displayed in the .Users can the designs from the gallery and customize it based on the customization enabled by the designer.The framework lets users extract CAD drawings which can be used to fabricate the design using a Computer Numerically Controlled(CNC) cutting machine.The community moderates the design collection.O-LAP is the name for the concept, the framework and the community. gallery view Demo New Way to Design The concept is popular in design and architecture circles. If you Google terms like “ ” or “ ” you should be able to find more examples. This project uses JavaScript to allow designers to create such designs in the browser which anyone can download and fabricate. parametric furniture cnc furniture It is a new way to think about furniture design and experiment with new ideas. We are just as curious to see what can be done. Furniture designs currently have a high entry barrier due to the resources required to manufacture at scale. A designer needs to establish a studio/fabrication infrastructure or align with larger companies to try to bring his/her designs to the market.With our production process, we can enable more upstarts to present their designs and let the community decide. A community curated design collection. The designs are exported as Computer Aided Design (CAD) files by the web app, which can be used for fabrication wherever needed using high precision machines. Sending a chair can mean just emailing the design file to any location. Sending chairs across geographies is like emailing a file. We promote an open licensing system to allow all designs to be replicated and forked by anyone. A design can be copied and morphed in different ways by different people adapting the design for their use. It’s like a natural selection process for designs. A framework for evolving designs. All aspects of the design are open and recorded publicly as the design develops. The designs stay ‘honest’ in concept as the narrative is recorded at every step. The exact contributions of different collaborators is recorded in the process. Public development records log the design narrative as decisions are made. The design, manufacture and supply chain has been a closed loop system owned entirely by individual entities.By breaking apart these aspects we think we can involve more independent participants to contribute and gain from this process while still keeping the whole process sustainable. Wider community participation in the design and production process. Current Stage This is at a proof-of-concept stage. I am excited about the possibilities and exploring who else finds this cool. If you think this is cool, please sign up with us and help us spread the word. o-lap.org Github Amit Nambiar Credit for all icons goes to following awesome designers from Noun Project.I Putu KharasmayadiVectors MarketDanil PolshinEliriconBen DavisAnanthWawan HermawanXinh Studio✦ Shmidt Sergey ✦Bohdan BurmichNicolas Weidinger

MARKETDIAL

marketdial.com

-- employees

Since n.d.

COMPANY RANKING

MARKETDIAL

EVERGREEN INDEX #6938

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

MarketDial WIKI

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

MARKETDIAL

marketdial.com

-- employees

Since n.d.

COMPANY RANKING

MARKETDIAL

EVERGREEN INDEX #6938

RELATED COMPANIESRANK

STORIES ABOUT MARKETDIAL

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

MarketDial WIKI

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