Claudia Oshry’s DMs have been more hateful than ever as she speaks out against Hamas’ brutal Oct. 7 terrorist attack on Israeli civilians.  “They definitely feel different now,” the Girl With No Job influencer,

Claudia Oshry says antisemitic DMs are on ‘a new level’ after Hamas attack: ‘They’re talking about Hitler’

Jennifer Lawrence admitted to Seth Meyers that she had a crush on him when she hosted 'Saturday Night Live' in 2013 — a revelation Meyers jokingly told Howard Stern on Monday made his wife, Alexi Ashe,

Seth Meyers Jokes His Wife Was ‘So Happy’ to Hear Jennifer Lawrence Had Crush on Him

Travis Kelce has been very open about his food preferences, from his game day “lucky breakfast” of French toast and strawberries to his regular visits to Kansas City BBQ joints to revealing on the New Heights podcast, that he hosts with his brother Jason, his favorite foods that include those from Waffle House and Burger King.

Travis Kelce Partners With Walmart To Bring His Favorite BBQ Products To Fans

Travis Kelce Loves BBQ : Teams Up With Walmart To Convince The Rest of Us To Love It.

Marcus Jordan wants his dad, Michael Jordan, to do more than give a toast at his eventual wedding to girlfriend Larsa Pippen. “I was the best man at his wedding and the best man at my brother’s wedding. And so, obviously, we’ll keep that tradition ...

Marcus Jordan Wants Dad Michael Jordan as His Best Man at Future Larsa Pippen Wedding

Larsa Pippen, Marcus Jordan, and Michael Jordan. Getty Images (2) Marcus Jordan wants his dad, Michael Jordan, to do more than give a toast at his eventual wedding to girlfriend Larsa Pippen. “I was the best man at his wedding and the best man at my brother’s wedding.

Marcus Jordan Wants Dad Michael as His Best Man at Larsa Pippen Wedding

When sisters-in-law Ayesha Curry and Sydel Curry-Lee joined forces to launch their wine brand Domaine Curry in 2018, they struggled to get industry gatekeepers to take them seriously. Less than five years later, the brand has been acquired for an undisclosed amount by the fifth largest wine company in the U.S.

EXCLUSIVE: Ayesha Curry & Sydel Curry-Lee Talk Relaunching Their Wine Brand After Its Acquisition: "This Is A Toast To Powerful Women"

Over 100 curated items from small business owners are on the holiday gifts list, including women-owned, Black-owned and other minority-owned businesses from around the country. And what’s great is you can shop for all of these gifts from Oprah’s Favorite Things gift guide on Amazon.

10 of our favorite products from Oprah’s Favorite Things list of 2023

The Miami Dolphins are playing the equally high-powered Kansas City Chiefs in Frankfurt, Germany, on Sunday at 9:30 a.m. Is that too early for a watch party with a 34-ounce beer or a pound of crab

Where to brunch and watch Miami Dolphins vs. Kansas City Chiefs on Sunday morning

Breakfast has been widely regarded as the most important meal of the day — and we happen to agree. Especially when it’s washed down with a big cup of coffee and a couple of mimosas on a lazy Sunday morning.

Best Breakfast Foods in the U.S., Ranked

Toast

toast

If you’re working with large databases in , this story will sound familiar. As your Postgres database keeps growing, your performance starts to decline, and you begin to worry about storage space—or, to be precise, how much you’ll pay for it. You love PostgreSQL, but there’s something you wish you had: a highly effective data compression mechanism. Postgres does have somewhat of a compression mechanism: 🍞. In this post, we’ll walk you through how Postgres TOAST works and the different TOASTing strategies. As much as we enjoy a good TOAST, we’ll discuss why this is not the kind of compression feature you need for reducing the storage footprint of modern large databases—and how, as the PostgreSQL enthusiasts that we are here at Timescale, we decided to build a more suitable compression mechanism for PostgreSQL, inspired by the columnar design of NoSQL databases. PostgreSQL TOAST What Is Postgres TOAST? Even if it might reduce the size of datasets, TOAST (The Oversized Attribute Storage Technique) is not your traditional data compression mechanism. To understand what TOAST is, we have to start by talking about . how data is stored in PostgreSQL Postgres’ units of storage are called pages, and these have a fixed size (8 kB by default). Having a fixed page size gives Postgres many advantages, namely its data management simplicity, efficiency, and consistency, but it comes with a downside: some data values might not fit within that page. This is where TOAST comes in. TOAST refers to the automatic mechanism that PostgreSQL uses to efficiently store and manage values in Postgres that do not fit within a page. To handle such values, Postgres TOAST will, by default, compress them using an internal algorithm. If, after compression, the values are still too large, Postgres will move them to a separate table (called the TOAST table), leaving pointers in the original table. As we’ll see later in this article, you can actually modify this strategy as a user, for example, by telling Postgres to avoid compressing data in a particular column. TOAST-able Data Types The data types that might be subjected to TOAST are primarily variable-length ones that have the potential to exceed the size limits of a standard PostgreSQL page. On the other hand, fixed-length data types, like , , or , are not subjected to TOAST since they fit comfortably within a page. integer float timestamp Some examples of data types that might be subjected to TOAST are: and json jsonb Large strings text and (If the length specified in is small enough, then values of that column might always stay below the TOAST threshold.) varchar varchar(n) varchar(n) storing binary data bytea Geometric data like and and PostGIS types like or path polygon geometry geography How Does Postgres TOAST Work? Understanding TOAST not only relates to the concept of page size but also to another Postgres storage concept: tuples. Tuples are rows in a PostgreSQL table. Typically, the TOAST mechanism kicks in if all fields within a tuple have a total size of over 2 kB approx. If you’ve been paying attention, you might be wondering, “Wait, but the page size is around 8 kB—why this overhead?” That’s because PostgreSQL likes to ensure it can store multiple tuples on a single page: if tuples are too large, fewer tuples fit on each page, leading to increased I/O operations and reduced performance. Postgres also needs to keep free space to fit additional operational data: each page stores not just the tuple data but also additional information for managing the data, such as item identifiers, headers, and transaction information. So, when the combined size of all fields in a tuple exceeds approximately 2 kB (or the TOAST threshold parameter, as we’ll see later), PostgreSQL takes action to ensure that the data is stored efficiently. TOAST handles this in two primary ways: PostgreSQL can compress the large field values within the tuple to reduce their size using a compression algorithm that we’ll cover later in this article. By default, if compression is sufficient to bring the tuple's total size below the threshold, the data will remain in the main table, albeit in a compressed format. Compression. If compression alone isn't effective enough to reduce the size of the large field values, Postgres moves them to a separate TOAST table. This process is known as "out-of-line" storage because the original tuple in the main table doesn’t hold the large field values anymore. Instead, it contains a "pointer" or reference to the location of the large data in the TOAST table. Out-of-line storage. We’re simplifying things slightly for this article— read the PostgreSQL documentation for a full detailed view. The Postgres Compression Algorithm: pglz We’ve mentioned that TOAST can compress large values in PostgreSQL. But which compression algorithm is PostgreSQL using, and how effective is it? The (PostgreSQL Lempel-Ziv) is the default internal compression algorithm used by PostgreSQL specifically tailored for TOAST. pglz Here’s how it works in very simple terms: tries to avoid repeated data. When it sees repeated data, instead of writing the same thing again, it just points back to where it wrote it before. This "avoiding repetition" helps in saving space. pglz As reads through data, it remembers a bit of the recent data it has seen. This recent memory is referred to as the "sliding window." pglz As new data comes in, checks if it has seen this data recently (within its sliding window). If yes, it writes a short reference instead of repeating the data. pglz If the data is new or not repeated enough times to make a reference shorter than the actual data, just writes it down as it is. pglz When it's time to read the compressed data, uses its references to fetch the original data. This process is quite direct, as it looks up the referred data and places it where it belongs. pglz doesn't need separate storage for its memory (the sliding window); it builds it on the go while compressing and does the same when decompressing. pglz This implementation is designed to offer a balance between compression efficiency and speed within the TOAST mechanism. In terms of compression rate, the effectiveness of will largely depend on the nature of the data. pglz For example, highly repetitive data will compress much better than high entropy data (like random data). You might see compression ratios in the range of 25 to 50 percent, but this is a very general estimate—results will vary widely based on the exact nature of the data. Configuring TOAST TOAST strategies By default, PostgreSQL will go through the TOAST mechanism according to the procedure explained earlier (compression first and out-of-line storage next, if compression is not enough). Still, there might be scenarios where you might want to fine-tune this behavior on a per-column basis. PostgreSQL allows you to do this by using the TOAST strategies , , , and . PLAIN EXTERNAL EXTENDED MAIN : This is the default strategy. It implies the data will be stored out of line in a separate TOAST table if it’s too large for a regular table page. Before moving the data to the TOAST table, it will be compressed to save space. EXTENDED : This strategy tells PostgreSQL to store the data for this column out of line if the data is too large to fit in a regular table page, and we’re asking PostgreSQL not to compress the data—the value will just be moved to the TOAST table as-is. EXTERNAL : This strategy is a middle ground. It tries to keep data in line in the main table through compression; if the data is definitely too large, it'll move the data to the TOAST table to avoid an error, but PostgreSQL won't move the compressed data. Instead, it’ll store the value in the TOAST table in its original form. MAIN : Using in a column tells PostgreSQL to always store the column's data in line in the main table, ensuring it isn't moved to an out-of-line TOAST table. Take into account that if the data grows beyond the page size, the will fail because the data won’t fit. PLAIN PLAIN INSERT If you want to inspect the current strategies of a particular table, you can run the following: \d+ your_table_name You'll get an output like this: => \d+ example_table
                     Table "public.example_table"
 Column  |       Data Type   | Modifiers | Storage  | Stats target | Description 
---------+------------------+-----------+----------+--------------+-------------
  bar    | varchar(100000)  |           | extended |              | If you wish to modify the storage setting, you can do so using the following command: -- Sets EXTENDED as the TOAST strategy for bar_column 
ALTER TABLE example_blob ALTER COLUMN bar_column SET STORAGE EXTENDED; Key parameters Apart from the strategies above, these two parameters are also important to control TOAST behavior: TOAST_TUPLE_THRESHOLD This is the parameter that sets the size threshold for when TOASTing operations (compression and out-of-line storage) are considered for oversized tuples. As we’ve mentioned previously, by default, is set to approximately 2 kB. TOAST_TUPLE_THRESHOLD TOAST_COMPRESSION_THRESHOLD This is the parameter that specifies the minimum size of a value before Postgres considers compressing it during the TOASTing process. If a value surpasses this threshold, PostgreSQL will attempt to compress it. However, just because a value is above the compression threshold, it doesn't automatically mean it will be compressed: the TOAST strategies will guide PostgreSQL on how to handle the data based on whether it was compressed and its resultant size relative to the tuple and page limits, as we’ll see in the next section. Bringing it all together is the trigger point. When the size of a tuple's data fields combined exceeds this threshold, PostgreSQL will evaluate how to manage it based on the set TOAST strategy for its columns, considering compression and out-of-line storage. The exact actions taken will also depend on whether column data surpasses the : TOAST_TUPLE_THRESHOLD TOAST_COMPRESSION_THRESHOLD (default strategy): If a tuple's size exceeds , PostgreSQL will first attempt to compress the oversized columns if they also exceed . If compression brings the tuple size under the threshold, it will remain in the main table. If it doesn't, the data will be moved to an out-of-line TOAST table, and the main table will contain pointers to this external data. EXTENDED TOAST_TUPLE_THRESHOLD TOAST_COMPRESSION_THRESHOLD : If the tuple size surpasses the , PostgreSQL will try to compress the oversized columns (provided they're over the ). If compression allows the tuple to fit within the main table's tuple, it remains there. If not, the data is moved to the TOAST table in its uncompressed form. MAIN TOAST_TUPLE_THRESHOLD TOAST_COMPRESSION_THRESHOLD : PostgreSQL skips compression, regardless of the . If the tuple's size is beyond the , the oversized columns will be stored out-of-line in the TOAST table. EXTERNAL TOAST_COMPRESSION_THRESHOLD TOAST_TUPLE_THRESHOLD : Data is always stored in the main table. If a tuple's size exceeds the page size (due to having very large columns), an error is raised. PLAIN Strategy Compress if tuple > TOAST_COMPRESSION_THRESHOLD Store out-of-line if tuple > TOAST_TUPLE_THRESHOLD Description EXTENDED Yes Yes Default strategy. Compresses first, then checks if out-of-line storage is needed. MAIN Yes Only in uncompressed form Compresses first, and if still oversized, moves to TOAST table without compression. EXTERNAL No Yes Always moves to TOAST if oversized, without compression. PLAIN No No Data always stays in the main table. If a tuple exceeds the page size, an error occurs. Why TOAST Isn't Enough as a Data Compression Mechanism in PostgreSQL By now, you’ll probably understand why TOAST is not the data compression mechanism you wish you had in PostgreSQL. Modern applications imply large volumes of data ingested daily, meaning databases (over)grow quickly. Such a problem was not as prominent when our beloved Postgres was built decades ago, but today’s developers need compression solutions for reducing the storage footprint of their datasets. While TOAST incorporates compression as one of its techniques, it's crucial to understand that its primary role isn't to serve as a database compression mechanism in the traditional sense. TOAST is mainly a solution to one problem: managing large values within the structural confines of a Postgres page. While this approach can lead to some storage space savings due to the compression of specific large values, its primary purpose is not to optimize storage space across the board. For example, if you have a 5 TB database made up of small tuples, TOAST won’t help you turn those 5 TB into 1 TB. While there are parameters within TOAST that can be adjusted, this won't transform TOAST into a generalized storage-saving solution. And there are other inherent problems with using TOAST as a traditional compression mechanism in PostgreSQL, for example: Accessing TOASTed data can add overhead, especially when the data is stored out of line. This becomes more evident when many large text or other TOAST-able data types are frequently accessed. TOAST lacks a high-level, user-friendly mechanism for dictating compression policies. It’s not built to optimize storage costs or facilitate storage management. TOAST's compression is not designed to provide especially high compression ratios. It only uses one algorithm ( ) with compression rates varying typically from 25-50 percent. pglz Adding Columnar Compression to PostgreSQL With Timescale , PostgreSQL users have a better alternative. Inspired by the compression design of NoSQL databases, . This transformative approach transcends PostgreSQL’s conventional row-based storage paradigm, introducing the efficiency and performance of columnar storage. Via the TimescaleDB extension we added columnar compression functionality to PostgreSQL By adding a compression policy to your large tables, . you can reduce your PostgreSQL database size by up to 10x (achieving +90 percent compression rates) By defining a time-based compression policy, you indicate when data should be compressed. For instance, you might choose to compress data older than seven (7) days automatically: -- Compress data older than 7 days
SELECT add_compression_policy('my_hypertable', INTERVAL '7 days'); Via this compression policy, Timescale will transform the table ( ) into a columnar format behind the scenes, combining many rows (1,000) into an array. To boost compressibility, Timescale will apply different compression algorithms depending on the data type: partitions which in Timescale are also created automatically Gorilla compression for floats Delta-of-delta + with compression for timestamps and other integer-like types Simple-8b run-length encoding Whole-row dictionary compression for columns with a few repeating values (+ LZ compression on top) LZ-based array compression for all other types This columnar compression design offers an efficient and scalable solution to the problem of large datasets in PostgreSQL. It allows you to use less storage to store more data without hurting your query performance (it improves it). And in the latest versions of TimescaleDB, you can also , , and directly over compressed data. INSERT DELETE UPDATE Wrap-Up We hope this article helped you understand that while TOAST is a well-thought-out mechanism to manage large values within a PostgreSQL page, it’s not effective for optimizing database storage use within the realm of modern applications. If you’re looking for effective data compression that can move the needle on your storage savings, give Timescale a go. You can try our cloud platform that propels PostgreSQL to new performance heights, making it faster and fiercer— —or you can add to your self-hosted PostgreSQL database. it’s free, and no credit card is required the TimescaleDB extension Written by . Carlota Soto

Postgres TOAST: Understanding the Data Compression Mechanism and Its Limitations 

পোস্টগ্রেস টোস্ট: ডেটা কম্প্রেশন মেকানিজম এবং এর সীমাবদ্ধতা বোঝা

Postgres TOAST: Den Datenkomprimierungsmechanismus und seine Einschränkungen verstehen

Postgres TOAST: comprensión del mecanismo de compresión de datos y sus limitaciones

Postgres TOAST : Comprendre le mécanisme de compression des données et ses limites

पोस्टग्रेस टोस्ट: डेटा संपीड़न तंत्र और इसकी सीमाओं को समझना

Postgres TOAST: データ圧縮メカニズムとその制限について理解する

Postgres TOAST: 데이터 압축 메커니즘 및 한계 이해

Postgres TOAST: Compreendendo o mecanismo de compactação de dados e suas limitações

Postgres TOAST: понимание механизма сжатия данных и его ограничений

Postgres TOAST: Veri Sıkıştırma Mekanizmasını ve Sınırlamalarını Anlamak

Postgres TOAST: Tìm hiểu cơ chế nén dữ liệu và những hạn chế của nó

Postgres TOAST：了解数据压缩机制及其局限性

Introduction Toasts are very useful for showing users some information. It has a wide variety of uses from displaying success messages for successful actions, showing error messages in case something goes wrong, and much more. Today we are going to build a simple toast with HTML and CSS. We are going to be using some javascript to add some interactivity. We are going to be making a toast that shows up when a button is clicked. It can also be closed, which is hidden away, by clicking a close button. Codepen - https://codepen.io/anishde12020/pen/JjrYMrW Basic CSS to make a toast To make a toast animate in or out, we need to make the toast first. For this example, I am going to add a simple icon and some text in a box and that is going to be our toast. So, in the markup, let us start by adding a for out toast - div <div class="toast" id="toast"></div> Now, we need to add an icon. I am going to grab a simple information icon from and put in the SVG HeroIcons <div class="toast" id="toast">
  <svg xmlns="http://www.w3.org/2000/svg" fill="none" class="icon" viewBox="0 0 24 24" stroke="currentColor">
    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
  </svg>
</div> Let us also add a text <div class="toast" id="toast">
  <svg xmlns="http://www.w3.org/2000/svg" fill="none" class="icon" viewBox="0 0 24 24" stroke="currentColor">
    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
  </svg>
  <p class="text">Some Information</p>
</div> This is what our page should look like The icon is so big that it doesn't even fit in the view. Let us fix this design with some CSS and then style it. First, we are going to style the icon by defining a width and a height - .icon {
  height: 2rem;
  width: 2rem;
} Let us now make our toast a flexbox and add some margin on the icon. I am also going to position the toast on the top-right using an absolute position. .icon {
  height: 2rem;
  width: 2rem;
  margin-right: 1rem;
}

.toast {
  display: flex;
  align-items: center;
  position: absolute;
  top: 50px;
  right: 80px;
} Everything looks good except for the styling. Let us add some colors and other styles: .icon {
  height: 2rem;
  width: 2rem;
  margin-right: 1rem;
  color: white;
}

.text {
  color: white;
}

.toast {
  display: flex;
  align-items: center;
  position: absolute;
  top: 50px;
  right: 80px;
  background-color: black;
  border-radius: 12px;
  padding: 0.5rem 1rem;
  border: 5px solid #029c91;
} We have changed the background color of the toast, added a border to it, added some border-radius, and changed the colors of the icon and the text so that they are visible on the black background. This is what our toast should now look like: Let us also add a button that will trigger the animation, that is, show the toast - <div class="toast" id="toast">
  <svg xmlns="http://www.w3.org/2000/svg" fill="none" class="icon" viewBox="0 0 24 24" stroke="currentColor">
    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
  </svg>
  <p class="text">Some Information</p>
  
</div>

<button id="show-toast" class="show-toast">Show Toast</button> Let us also style this button as it looks quite ugly now .show-toast {
  background-color: black;
  color: white;
  border-radius: 8px;
  padding: 8px;
  cursor: pointer;
} Let us also disable any overflow: html,
body {
  overflow: hidden;
} This is how everything should look like now: Adding animations Now that we have the toast and a button to trigger the animations, it is time to add the animations. First of all, we are going to give the toast a starting point by putting it outside the view. So let us edit the CSS for the toast: .toast {
  display: flex;
  align-items: center;
  position: absolute;
  top: 50px;
  right: -500px;
  background-color: black;
  border-radius: 12px;
  padding: 0.5rem 1rem;
  border: 5px solid #029c91;
  opacity: 0%;
} Now let us make a new class called that will get added to the toast whenever the button is clicked: toast-active .toast-active {
  right: 80px;
  opacity: 100%;
} Notice that we are also changing the opacity during the transition. This just makes it look a little better. Now let us write some javascript to add this class to the toast whenever the button is clicked - let toast = document.getElementById("toast");
document.getElementById("show-toast").addEventListener("click", function () {
  toast.classList.add("toast-active")
}); Here, whenever the button is clicked, the class is being added to the toast. Right now the animation is instant, which doesn't look good. Let us add a transition: toast-active .toast {
  display: flex;
  align-items: center;
  position: absolute;
  top: 50px;
  right: -500px;
  background-color: black;
  border-radius: 12px;
  padding: 0.5rem 1rem;
  border: 5px solid #029c91;
  opacity: 0%;
  transition: all 0.25s ease-out;
} Here the transition goes on for a quarter of a second and we have also eased it out so it isn't harsh. Adding a Close Button to the Toast We would like to give the user a close button that they can click to close the toast. First of all, we need to add a button to the toast in our markup: <div class="toast" id="toast">
  <svg xmlns="http://www.w3.org/2000/svg" fill="none" class="icon" viewBox="0 0 24 24" stroke="currentColor">
    <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z" />
  </svg>
  <p class="text">Some Information</p>
  <button id="close-button" class="close-button">
    &#10005;
  </button>
</div>

<button id="show-toast" class="show-toast">Show Toast</button> Let us also style it so that it is visible .close-button {
  background-color: black;
  color: white;
  border: none;
  cursor: pointer;
} Now, when this button is clicked, it will just do the reverse of what the show toast button did, that is, remove the class. toast-active document.getElementById("close-button").addEventListener("click", function () {
  toast.classList.remove("toast-active");
}) Now, clicking the cross symbol (close button) in the toast should take it away from the screen with a transition. Conclusion If everything has worked out well so far, give yourself a pat on the back because you have just built a toast with nothing but HTML, CSS, and JS!!! Links Codepen for this project - https://codepen.io/anishde12020/pen/JjrYMrW HeroIcons - https://heroicons.com/ My Twitter - https://twitter.com/AnishDe12020 First Published here

Build Your Own Toast With HTML, CSS and JS

Using ReactJS and Context API to Build a Custom Toast Notification Component 

In a web application, toast notifications are an easy and efficient way to give consumers feedback. They can be utilized to notify users of successful or unsuccessful tasks, mistakes, or just to convey a general message. We'll examine utilizing the package to implement toast notifications in a React application. In this article I will show you how to use to add some stylish design elements. react-toastify Tailwind Prerequisites Before getting started with this tutorial, you should have the following: Knowledge of React and Tailwind. or installed as a package manager yarn npm Install the Library You must first install the library before you can proceed. Run the following command in your terminal to accomplish this: react-toastify npm install react-toastify or yarn add react-toastify Import the Library Before you can import the library, you must first create a folder, then a folder, and finally a file, which I will name . Make a file called in the folder. src component FormPage.js App.js src Once the library is installed, you'll need to import it into your . You can do this by adding the following line of code at the top of your component file: FormPage.js import { toast } from 'react-toastify' Next, create the function in your . This function will be responsible for displaying the toast notification. Inside the function, use the toast function to display the notification. handleSumit FormPage.js const handleSubmit = (event) => {
  event.preventDefault();
  toast.success("You have registered");
}; The function is typically used to prevent the default behavior of a form submission event.
When a form is submitted, the default behavior is to send a request to the server, which can result in the current page being reloaded.
When the form is submitted, the function is called and the object is passed as an argument.
The object is given a call to the method, which stops the form from being sent to the server.
The is a function that is used to display a success message, or "toast," to the user in a web application. preventDefault handleSubmit event event preventDefault toast.success Create your form Now, you need to bind the function to an event in your component. This could be a button click, a form submission, or any other type of event. For example, to display the toast notification when a form is submitted, you could do the following on the : handleSumit FormPage.js const FormPage = () => {
  return (
    <div className="flex justify-center items-center h-screen">
      <div className="block p-6 rounded-lg shadow-lg bg-white max-w-sm">
        <form onSubmit={handleSubmit}>
          <div className="form-group mb-6">
            <input
              type="text"
              className="form-control block w-full px-3 py-1.5 text-gray-700
              bg-white bg-clip-padding border border-solid border-gray-300
              rounded transition ease-in-out m-0 focus:text-gray-700 
              focus:bg-white focus:border-blue-600 focus:outline-none"
              id="exampleInput90"
              placeholder="Name"
            />
          </div>
          <div className="form-group mb-6">
            <input
              type="email"
              className="form-control block w-full px-3 py-1.5 
              text-gray-700 bg-white bg-clip-padding border border-gray-300 
              rounded transition ease-in-out
              m-0 focus:text-gray-700 focus:bg-white focus:border-blue-600 
              focus:outline-none"
              id="exampleInput91"
              placeholder="Email address"
            />
          </div>
          <div className="form-group form-check text-center mb-6">
            <input
              type="checkbox"
              className="form-check-input appearance-none h-4 w-4 border 
              border-gray-300 rounded-sm bg-white checked:bg-blue-600          
              checked:border-blue-600 focus:outline-none transition duration-200
              mt-1 align-top bg-no-repeat bg-center bg-contain mr-2 cursor-pointer"
              id="exampleCheck96"
              checked
            />
            <label
              className="form-check-label inline-block text-gray-800"
              for="exampleCheck96"
            >
              I have read and agreed to the terms.
            </label>
          </div>
          <button
            type="submit"
            className="w-full px-6 py-2.5 bg-blue-600 text-white 
            font-medium text-xs leading-tight uppercase rounded 
            shadow-md hover:bg-blue-700 hover:shadow-lg focus:bg-blue-700
            focus:shadow-lg focus:outline-none focus:ring-0 active:bg-blue-800 
            active:shadow-lg transition duration-150 ease-in-out"
          >
            Subscribe
          </button>
        </form>
      </div>
    </div>
  );
}; Here is how your form would look on the browser. Customizing the Toast Notification You can customize the appearance and behavior of your toast notifications by passing options as arguments to the . The can be used on . Import the from the library. ToastContainer ToastContainer App.js ToastContainer react-toastify import { ToastContainer } from "react-toastify" Some of the options you can use include: : Specifies the position on the screen where the notification should be displayed (e.g. top-right, bottom-left). **position** : Specifies the duration (in milliseconds) for which the notification should be displayed before it is automatically closed, in ( 1000 = 1sec). **autoClose** autoClose : Hides the progress bar that appears at the bottom of the notification. **hideProgressBar** : This property determines the order in which toasts are displayed. **newestOnTop** boolean : Closes the notification when the user clicks on it. **closeOnClick** : Which stands for "right-to-left, is a property that determines the direction in which toasts are displayed within the toast container. **rtl** boolean : Makes the notification draggable by the user. **draggable** : Pauses the auto-close timer when the user hovers over the notification. **pauseOnHover** Here's is how example of how  you can use some of these options in the : ToastContainer <ToastContainer 
        position="top-center"
        autoClose={5000}
        hideProgressBar={false}
        newestOnTop={false}
        closeOnClick
        rtl={false}
        pauseOnFocusLoss
        draggable
        pauseOnHover
      /> This will display a success notification that will be displayed for 5 seconds, dragged around by the user, closed when clicked, and has a visible progress bar. Conclusion Finally, React Toast Notification is a useful tool for displaying temporary messages to the user in a visually appealing and customizable manner. Following the steps outlined in this article, you should now have a solid understanding of how to use React Toast Notification in your own projects. Whether you want to notify the user of a success or error message, or simply alert them to new information, React Toast Notification can help you do so in a professional and user-friendly manner. To access my repository, simply follow this link . https://github.com/Uhiene/Form.git Resources . Tailwind Forms component . React Toastify GitHub page . React Toastify documentation

How to Create Toast Notifications in React Applications

Toast Notifications are yet another way to provide feedback to the user. They usually contain brief messages and sometimes get accompanied by CTAs as well. This article aims to explain how we could use and to create some beautiful-looking toast messages 😉 react-hot-toast styled-components Project Initialisation npx create-react-app toast-notification Install Dependencies for getting the toast notification functionality react-hot-toast for styling needs styled-components yarn add react-hot-toast styled-components Constants Default Title, Default Description & variants enum is stored in this file. // path: src/components/toast-notification/data.js

export const variants = {
  SUCCESS: "Success",
  WARNING: "Warning",
  QUESTION: "Question",
  FAIL: "Fail",
};

export const DEFAULT_TITLE = {
  Success: "Well done!",
  Warning: "Warning!",
  Question: "Hi there!",
  Fail: "Oh snap!",
};

export const DEFAULT_DESCRIPTION = {
  Success: "You successfully read this important message.",
  Warning: "Sorry! There was a problem with your request.",
  Question: "Do you have a problem? Just use this contact form.",
  Fail: "Change a few things up and try submitting again.",
}; App Component & component is called inside App component. Form Toaster // path: src/App.js

// External
import { Toaster } from "react-hot-toast";

// Components
import Form from "./components/form";

// Styles
import { AppStyles } from "./styles";

const App = () => {
  return (
    <AppStyles>
      <Form />
      <Toaster position="bottom-left" gutter={56} />
    </AppStyles>
  );
};

export default App; Toast Notification Component Toast Notification Component contains the styles for Toast Notification. // path: src/components/toast-notification/index.js

import React from "react";

// External
import toast from "react-hot-toast";

// Components
import CustomIcon from "../CustomIcon";

// Styles
import {
  NotificationCard,
  NotificationImage,
  NotificationImageWrapper,
  NotificationContent,
  NotificationTitle,
  NotificationDescription,
  NotificationIconButton,
  BubblesImage,
} from "../../styles";

const ToastNotification = ({
  t,
  bgColor,
  icon,
  bubbleImage,
  title,
  message,
}) => {
  // handlers
  const handleDismiss = () => {
    toast.dismiss(t.id);
  };

  return (
    <>
      <NotificationImageWrapper>
        <NotificationImage src={icon} alt="" role="presentation" />
      </NotificationImageWrapper>
      <NotificationCard bgColor={bgColor}>
        <BubblesImage src={bubbleImage} alt="" role="presentation" />
        <NotificationContent>
          <NotificationTitle>{title}</NotificationTitle>
          <NotificationDescription>{message}</NotificationDescription>
        </NotificationContent>
        <NotificationIconButton onClick={handleDismiss}>
          <CustomIcon icon="times" />
        </NotificationIconButton>
      </NotificationCard>
    </>
  );
};

export default ToastNotification; Form Component This component contains the inputs used for testing out the component. //path: src/components/form/index.js

import React, { useState, useEffect } from "react";

// External
import toast from "react-hot-toast";

// Components
import ToastNotification from "../toast-notification";

// Styles
import {
  Button,
  RadioButtonContainer,
  RadioButtonInput,
  OptionsContainer,
  Container,
} from "../../styles";

// Image
import questionImage from "../../images/question.png";
import successImage from "../../images/success.png";
import warningImage from "../../images/warning.png";
import failImage from "../../images/fail.png";
import greenBubbles from "../../images/green-bubbles.png";
import redBubbles from "../../images/red-bubbles.png";
import blueBubbles from "../../images/blue-bubbles.png";
import yellowBubbles from "../../images/yellow-bubbles.png";

// Constants
import {
  variants,
  DEFAULT_TITLE,
  DEFAULT_DESCRIPTION,
} from "../ToastNotification/data";

const Form = () => {
  const [currentVariant, setCurrentVariant] = useState(variants.SUCCESS);
  const [title, setTitle] = useState(DEFAULT_TITLE.SUCCESS);
  const [message, setMessage] = useState(DEFAULT_DESCRIPTION.SUCCESS);

  // change title and message when notification variant changes
  useEffect(() => {
    setTitle(DEFAULT_TITLE[currentVariant]);
    setMessage(DEFAULT_DESCRIPTION[currentVariant]);
  }, [currentVariant]);

  // show appropriate toast notification as per the variant
  const showToastNotification = () => {
    if (currentVariant === variants.SUCCESS) {
      toast.custom(t => (
        <ToastNotification
          t={t}
          icon={successImage}
          bubbleImage={greenBubbles}
          bgColor="#76bf4c"
          title={title}
          message={message}
        />
      ));
    }

    if (currentVariant === variants.QUESTION) {
      toast.custom(t => (
        <ToastNotification
          t={t}
          icon={questionImage}
          bubbleImage={blueBubbles}
          bgColor="#B8B5FF"
          title={title}
          message={message}
        />
      ));
    }

    if (currentVariant === variants.WARNING) {
      toast.custom(t => (
        <ToastNotification
          t={t}
          icon={warningImage}
          bubbleImage={yellowBubbles}
          bgColor="#FCA652"
          title={title}
          message={message}
        />
      ));
    }
    if (currentVariant === variants.FAIL) {
      toast.custom(t => (
        <ToastNotification
          t={t}
          icon={failImage}
          bubbleImage={redBubbles}
          bgColor="#F05454"
          title={title}
          message={message}
        />
      ));
    }
  };

  // handlers
  const handleVariantChange = e => {
    setCurrentVariant(e.target.name);
  };

  const handleTitleChange = e => {
    setTitle(e.target.value);
  };

  const handleMessageChange = e => {
    setMessage(e.target.value);
  };

  return (
    <>
      <OptionsContainer>
        {Object.values(variants).map(variant => (
          <RadioButtonContainer key={variant}>
            <RadioButtonInput
              type="radio"
              id={variant}
              name={variant}
              checked={currentVariant === variant}
              onChange={handleVariantChange}
            />
            <label htmlFor={variant}>{variant}</label>
          </RadioButtonContainer>
        ))}
      </OptionsContainer>
      <br />
      <Container>
        <label htmlFor="title-field">Title</label>
        <input
          id="title-field"
          type="text"
          value={title}
          onChange={handleTitleChange}
        />
        <label htmlFor="message-field">Message</label>
        <textarea
          id="message-field"
          rows="6"
          value={message}
          onChange={handleMessageChange}
        ></textarea>
      </Container>
      <Button
        isSelected={!(!title || !message)}
        onClick={showToastNotification}
      >
        Show Toast!
      </Button>
    </>
  );
};

export default Form; Conclusion And there we have it, we have got elegant-looking alert notification implemented. The is available on Github. Would love to hear your valuable feedback in the comments down below. Code See you guys 👋🏻  in the next article of this Component series! Happy coding & Stay safe! ✨ Follow me on & for more! Twitter Instagram This article can also be read on my . website

Build a Toast Message Component via React and Styled Components with Ease

We are excited to announce the availability of Courier’s newest provider, ! We have released Inbox and Toast; two open-source React components that exemplify the potential future applications of this feature. With Toast, you can send your user a notification within your web application, and Inbox allows you to create an embeddable notification repository so that your user can access all past in-app notifications. Courier Push Most importantly, Courier Push allows us the flexibility and customization to do app-to-user communication right. As software users ourselves, we are bombarded with messages constantly, which can...really suck. Yet, notifications are necessary to communicate with users. With Courier Toast and Inbox, developers can support custom notifications for their users’ specificities and communicate through multiple wide-ranging channels while maintaining a single in-app notifications repository. We are particularly excited about all the potential future applications of Courier Push in addition to Toast and Inbox and are looking forward to expanding its uses. Here at Courier, we want to improve the integration experience for you, the developer, and the notification experience for your customers. We’ve done this with Courier Toast and Inbox. Courier Toast and Inbox What is Toast One of the major tenets of Courier’s product offerings is sending notifications. Receiving them and displaying them in your application is game-changing. The ease of implementation makes your job as a developer simple and enables you to build real-time web applications that provide a better user experience for your customers. Your end-users can see customized notifications pop up in your web application through a modular system you can easily customize. What is Inbox Alongside Toast messages is a customizable inbox, which is essentially a notification history. This takes the pressure off users to respond immediately, lessening the anxiety around the experience in general. Inside Inbox, a user can: Read their messages Mark messages as read or unread Delete messages How to Integrate Toast and Inbox in a React App Let’s walk through how you can integrate Courier Toast and Inbox React Components in a React app. Check out the Courier React Components repository on . GitHub Install CourierProvider Step 1: @trycourier/react-provider ...to handle all of the authentication and integration with the backend. yarn add @trycourier/react-provider or npm i @trycourier/react-provider At the top level in your React tree, add something that resembles the following code. The Client Key can be found and the User Id is the identifier for identifying your user. Note that it will be used later in the API call to Courier. Step 2: here import { CourierProvider } from "@trycourier/react-provider";
import { Toast } from "@trycourier/react-toast";

const MyApp = ({ children }) => {
  return (
    <CourierProvider clientKey={CLIENT_KEY} userId={USER_ID}>
      <Toast />
      {children}
    </CourierProvider>
  );
}; N/B: You can add Toast to the frontend anywhere as long as it’s a child of the CourierProvider. Inbox should be added in the application as a child of CourierProvider, but where you want the Bell icon to display. For this example, we will just put it right next to Toast. Step 3: <code>yarn add @trycourier/react-inbox</code> or <code>npm i @trycourier/react-inbox</code> import { CourierProvider } from "@trycourier/react-provider";
import { Toast } from "@trycourier/react-toast";
import { Inbox } from "@trycourier/react-inbox";

const MyApp = ({ children }) => {
  return (
    <CourierProvider clientKey={CLIENT_KEY} userId={USER_ID}>
      <Toast />
      <Inbox />
      {children}
    </CourierProvider>
  );
}; How to Customize Toast and Inbox There are two ways to customize your Inbox and Toast.  First, you can use the to customize your application, and the components will automatically update when the brand is published. studio Second, you can pass properties right into each component.  Each component supports a theme and also supports . Here’s the code for props: render properties interface InboxProps = {
  //Icon Class Name
  className?: string;

  // Default Icon to use if no Icon is present in Message
  defaultIcon?: false | string;

  // Placement of the Bell relative to the Inbox
  placement?: "top" | "left" | "right" | "bottom";

  // Render Props for Custom Rendering
  renderTabs?: React.FunctionComponent<{
    currentTab?: ITab;
    tabs?: ITab[];
  }>;
  renderFooter?: React.FunctionComponent;
  renderHeader?: React.FunctionComponent;
  renderIcon?: React.FunctionComponent<{
    unreadMessageCount?: number;
  }>;
  renderMessage?: React.FunctionComponent<IMessage>;
  renderNoMessages?: React.FunctionComponent;

  // Tab Overrides
  tabs?: Array<ITab>;
  theme?: ThemeObject;

  // Inbox Title Override
  title?: string;
  trigger?: "click" | "hover";
} Conclusion Courier Push opens the doors to perfecting app-to-human communication with its flexibility and potential for customization. Communication is a two-way street that requires good messaging and a channel and style that works uniquely for a specific type of user using a specific app. With Toast and Inbox, developers can create an effective notifications system that reaches end-users when they want, how they want, and the way they want. To learn more, check out the . documentation We believe that providing contextual notifications from within your app is an opportunity to provide better, more intuitive, and more interesting user experiences. We also believe that if done right, these can take us a long way towards accomplishing our goal of making computer-to-human communication delightful. Of course, this is just the beginning of our investment in solving this problem, so please stay tuned for more. Inbox and Toast, and let us know what you think! Your feedback helps us improve continuously. Check out

Notifications That Don’t Suck: React Inbox and React Toast Components

01/12/2019 Welcome to Console, a technology, business, and financial markets newsletter with an emphasis on rationality. If you’d like to sign up, you can do so . here Japanese Pizza Toast The more I analyze and partake in business and economics, the more introspective I’ve become in the direction of history and culture. Business is inherently cultural because it is an inherently human endeavor. Food is the perfect blend of culture and business, and Craig’s writing about Japanese Pizza Toast exemplifies this so well. Tesla Marketcap Surpasses GM and Ford Combined Two words: irrational exuberance. Toyota’s CES2020 Announcement I’m happy to see Toyota innovating, but this kind of seems like an executive’s pet project more than anything else. Raising Minimum Wage May Prevent Suicide I’ve that I’ve always been fascinated with how economic conditions affect health and well-being. said in previous newsletters The problem is, I’m also a fan of Nassim Nicholas Taleb, and have seen him eviscerate studies like these, so I’m always wary of the statistics used. It looks like this particular study uses a Poisson regression, which likely means a lot of information is lost between reality and the model.* They found a p-value of .013, which is better than the often used p-value of .05. However, . It seems the paper this article is written about is a case of the all too pervasive p-value hacking that’s found in the soft sciences today. Taleb has shown p-values to be a flimsy indication of statistical correlation One of the projects in one of my statistics courses back in college was to collect a news story on a research paper similar to this one and analyze both the news story and the statistics used in the research paper. The news organizations are incentivized to create content, particularly content with eye-grabbing headlines for SEO purposes. Because of this, what they’ll often do is find a research paper and interpret the results. The more extreme the result they interpret the better the headline, so they’re biased in that they would like their interpretation to align with the best outcome for the news organization’s revenue. This involves a bastardization of the results of the research, which itself is already on faulty grounds due to its use of p-values and regression models. Often the news story is incorrect in what the research paper is asserting, and often the research paper itself is p-value hacking to get a paper into a journal. It’s turtles all the way down. *I would say that about any model by the way, but that’s a discussion for another newsletter. This week’s newsletter not your cup of tea? Check out some of the more popular weeks below! Console #13: The Next Phase of the Internet GitHub Acquires Semmle, Vitalik’s Time Machine, and Condolences to the Facebook Engineer The $1 Billion Bitcoin Whale, A $243,000 Deepfake, Pre-Mature Optimization, and The Yandhi Leak Don’t forget to follow me on Twitter , add me on Facebook or subscribe to the Console newsletter to get the newsletter directly in your email . I post a review of topics I find interesting every week. I’m always looking for new topics to cover, so if you have anything you find interesting and would like to discuss please reach out!

Console #17: Japanese Pizza Toast and Turtles

The Last Toast Library you’ll Ever Need Introducing 3.0 Notyf In this post, I’ll introduce the new features and highlights that comes in the last version of . Notyf What The heck is Notyf? Notyf is a dependency-free, modern and elegant toast library for 2019. It’s well known that there are dozens, if not hundreds, of JavaScript toast libraries out there. is yet another one. Nevertheless, I consider most of these libraries to be missing some important points that are needed in today’s frontend development. In this post, I’ll introduce Notyf 3.0 and will show how it stands out of the crowd to make it a good fit for your project today. Notyf Notyf is a dependency-free, modern, elegant toast library for 2019 Plug it anywhere, play it everywhere It’s no secret that frontend frameworks play a big role in frontend development nowadays. It’s almost pointless to build a UI library which still relies on jQuery or on registering globals in the browser. Notyf deals with this by exposing 3 types of bundles: ES6, CommonJS and vanilla IIFE. Module bundlers like Webpack will grab the ES6 module and work with it. Also, those of us who still maintain legacy codebases with server-side rendering and <scripts> all over the place, are still able to use Notyf by using the IIFE minified bundle. Framework-specific recipes . Notyf has been well tested in React, Vue, and Angular. The recipes are written on top of best practices specific for each framework (Context API for React, provide/inject for Vue, injection token for Angular). are available in the repository Typings everywhere Version 3.0.0 has been rewritten from scratch in TypeScript. That means you get typings for free, no need to install . It’s also a great win for the project in terms of scalability and maintainability. @types/notyf Fully E2E tested Few of the do e2e or unit testing. This is one of the winning points of Notyf as it’s tested with what I consider the best end-to-end testing framework as of today, . This allows Notyf not only to be tested on its public API but also on its actual UI rendering performance. best toast libraries out there Cypress body[data-twttr-rendered="true"] {background-color: transparent;}.twitter-tweet {margin: auto !important;} Testing with is a breeze. It's the definition of "e2e testing that just works and makes sense", like literally. Using it for the next version of Notyf (3.0.0), best decision ever. @Cypress_io https://t.co/VriLfQMLep https://t.co/MoRjzs0iHM — @caroso1222 function notifyResize(height) {height = height ? height : document.documentElement.offsetHeight; var resized = false; if (window.donkey && donkey.resize) {donkey.resize(height); resized = true;}if (parent && parent._resizeIframe) {var obj = {iframe: window.frameElement, height: height}; parent._resizeIframe(obj); resized = true;}if (window.location && window.location.hash === "#amp=1" && window.parent && window.parent.postMessage) {window.parent.postMessage({sentinel: "amp", type: "embed-size", height: height}, "*");}if (window.webkit && window.webkit.messageHandlers && window.webkit.messageHandlers.resize) {window.webkit.messageHandlers.resize.postMessage(height); resized = true;}return resized;}twttr.events.bind('rendered', function (event) {notifyResize();}); twttr.events.bind('resize', function (event) {notifyResize();});if (parent && parent._resizeIframe) {var maxWidth = parseInt(window.frameElement.getAttribute("width")); if ( 500 < maxWidth) {window.frameElement.setAttribute("width", "500");}} A11y matters. Like, a lot. After analyzing some of the , I came to realize that very few of them actually care for visually impaired users who rely on screen readers to browse the web. Notyf takes care of this by giving full a11y support which makes toasts to be immediately read by the screen reader. It relies on the and the use of some aria properties. curated notification libraries announcer technique On perf and stuff All of the toasts you see on the web normally reveal using the good ol’ fade-in opacity animation. Notyf, on the contrary, reveals itself using a ripple-like effect which (personal opinion) makes it look modern and elegant. It does all this while still achieving top performance by avoiding reflow and animating only transform props. You can see in the performance profiling below how the animations run in 60 fps. Performance profiling Help wanted I personally consider this to be a good project to get started into open source, if you still haven’t. The codebase is not daunting and relatively easy to understand. Also, there are still features to be added and some issues to be addressed. I also need help in refining the recipes for React and Vue as I’m not an expert in these frameworks. Head over to the guide and give me a hand to make this the best toast library out there! contributing caroso1222/notyf Shameless self-promotion I normally write about web dev or whatever comes to my mind related to software. You might want to read about or on . If you like what you read then I appreciate you subscribing to my content or head over to twitter and say hi! my experience as a remote worker how I deploy my frontend applications in the most overkill way @caroso1222

The last toast library you’ll ever need

Appliance manufacturers are betting big on digital, but European authorities are ill prepared to police the brave new world. Early morning US East Coast time on 21 October and internet giants Amazon and Twitter start to notice mischief traffic on their sites. The flow soon grows to a torrent so intense that within hours, the titans of internet traffic spin out of control and go black. Tumblr, Reddit, Spotify and Netflix were brought to their knees the same day. The attack was different not just because of the size of the scalps claimed by hackers, but because they had weaponised a vast drone army of toasters, video cameras, washing machines and other ‘internet of things’ home appliances with little or no defences. ran an experiment shortly afterwards, setting up a wifi toaster and watching it come under attack within just an hour of being turned on. The Atlantic Hackers made toast out of internet giants last month. Manufacturers are betting big on digital, yet European authorities are not up to speed. Other than the bean counters at Amazon, nobody was hurt in the attack. But it is easy to think of far more serious targets in our connected world. The situation illustrates both the ambition of the manufacturing sector to embrace a digital future and its naivety. It is now charging headlong into digital, according to its . That future that holds a lot of promise, but also huge unseen vulnerabilities that go beyond hacking. 10 year European plan **Brave new world**Gadgets that understand us can serve us better. Picture the Jetson family washing machine of tomorrow — it might see the price of electricity coming down during the night, sense a load with a particular type of soiling and kick into action to an extent precisely tuned to its load. Great stuff. Before the October attack, the chief downside of connected home appliances seemed to be the threat from over eager coffee machines annoying their owners with status updates. That ‘always online, always ready’ setting is a lot of energy and CO2 unnecessarily. But it goes deeper and darker than that. already wasting Machines armed with sensors and computerised controls are enhancing the capability of our tools like never before. But Volkswagen’s hugely damaging dieselgate debacle revealed the considerable potential for crafty software to dodge official energy tests. Many more car firms are now in or near the dock. Today, the humble domestic fridge can come equipped with thousands of lines of code, complexity that leaves a lot of scope for… optimising performance, let’s say, during official tests. European government agencies have been flagging to the European Commission in TVs and fridges and Coolproducts this September announced a into potential software abuse in home appliances. suspicious behaviour €400,000 investigation Finding software cheats is a cat and mouse game stacked heavily in favour of the bad guys. The best safeguard are well-resourced and proactive state agencies enforcing a clear set of rules and imposing eye-watering penalties that deter misbehaviour in the first place. Sadly, just like in automotive, the opposite is true in Europe. Green and consumer NGOs reached out to public authorities charged with upholding the law as part of a three year project called . They found that most were critically under-resourced and focused on physical safety of products rather than energy efficiency and software. If they did find fishy software, they may have to sit on their hands, since European law has failed to keep up and explicitly prohibit it. The European Commission unit responsible is also badly under-resourced. Thankfully, a measure explicitly ruling out VW like behaviour in the appliance sector is entering the final stages of legal approval in Brussels. MarketWatch **The net effect**With the legal regime unable to head off a potential Great Crash of 2017 or #fridgegate scandal of the future, our best hope is probably industry itself. For it to reap the tantilising benefits of digital while avoiding its pitfalls, it has to gain maturity, fast. The October hack represented an unnecessarily steep learning curve. Firms need to do a better job of distinguishing between ‘can’ and ‘should’, as well as think through the consequences. Not all will, so regulators need to get their act together to safeguard the public interest. Miltonite fantasists like , who argue that the market will look after itself, should be politely ignored. Daniel Hannan MEP wrongly Coolproducts is an NGO campaign to make appliances better for people and the planet

The biggest threat to the web today: toasters?

We held a team offsite in New York last month. If you know any of us at Spark, you’d guess that we spent most of the time debating with each other, like a family where everyone argues passionately but loves each other at the end of the day. (I‘m guessing most of us at Spark grew up in a family like that. I certainly did.) While we were all together, one topic we spent a lot of time discussing was how digital startups can build long-term competitive barriers. My partner Jeremy Philips led the conversation, and you can read more about his thoughts in a piece he published in the New York Times in August ( ). here A couple of us also applied the thinking that came out of our offsite discussion to hardware. The main thing we all agree on: hardware startups build true competitive barriers, but they have to be careful to avoid simply creating a “toaster.” can When we say a toaster, we mean a product that the market demands, but where margins get eaten away over time due to low barriers to entry and fierce competition. This analogy was popularized by Professor Bruce Greenwald at Columbia Business School (and mentioned by Jeremy in the New York Times article linked above). It’s worth pausing for a minute on this. Some people think that highly-differentiated products will give a company a long-term competitive advantage. But without barriers, we’ve seen that all useful differentiation gets copied in the long-term. Today, intellectual property creates a true barrier in hardware, where copycats emerge out of thin air after a funding announcement. Highly differentiated product ideas are what drive initial customer interest in hardware startups, but competitive barriers are necessary to build a valuable business in the long-run. rarely This subject is important to us at Spark, where we invest very actively in hardware startups. We led Series A rounds for Oculus, Cruise, Thalmic Labs, Superpedestrian, Freight Farms, and many more. We’re strong believers in the potential for hardware startups to create magical new product experiences, make a big impact on society, and generate venture scale returns for their investors in the process. So: for a high-growth hardware , how do you create competitive barriers and not end up as a toaster company? startup From our experience at Spark, the best hardware companies use superior hardware execution as a trojan horse for building a long-term relationship with their customers . Here are three successful strategies we’ve seen. through software and data-driven experiences Oculus built a strong developer community early on in its journey to developing a commercial VR headset, giving the company a meaningful head start against competitors in terms of available content, games, and other applications. The company would never have gotten to where it did without thousands of developers building demos, experimenting, and proselytizing for the brand. The iPhone is a beautiful piece of hardware, but consumers are initially drawn to the platform and ultimately become locked-in because of iOS applications. Similarly, developers are drawn to the Apple customer-base and choose to create applications for iOS. As a consumer, switching from iOS to Android is more than buying a new phone — it’s also starting from scratch on your applications. As a developer, once you have a meaningful customer base on iOS, you will continue building for the platform for a long time. Build a vibrant developer community/ecosystem. . Cruise Automation built an incredibly sophisticated brain for an autonomous vehicle, connecting external sensors (e.g. LIDAR, cameras) and a variety of other data sources to the mechanical automobile drive-train. More importantly, they built machine learning technology to recognize a wide variety of different objects and events. This dataset and the self-training model they developed to improve accuracy over time with use will be very difficult for competitors to replicate, especially since Cruise had a head start. 23andMe built the first direct-to-consumer brand in genetic testing. In my opinion, the real value doesn’t lie in their elegant spit cup design and the core IP around their genetic testing technology. The magic is in the dataset, which 23andMe can continuously mine and leverage on behalf of their growing user-base for medical and genealogical applications. Create a data moat/network effect . Freight Farms launched its flagship Leafy Green Machine product a few years ago, providing customers a hardware platform for hydroponic plant growing. As the company matures, they continue to release software products through their mobile app Farmhand to help farmers manage every facet of their business: from business planning and sales, to yield measurement and management, to purchasing consumables like seeds and nutrients, to sharing recipes with other growers on the platform. This keeps current customers highly engaged on their platform. Square started with a simple headphone-jack attachment to allow SMB merchants to accept credit card payments from a mobile device. Over time, Square launched a variety of other software products into that existing install-base, like merchant analytics, payroll, and streamlined lending, creating a much stickier business than a pure-play PoS and payment processing company. Release sticky software tools to your hardware users Early-stage isn’t all about focusing on the creation of long-term competitive barriers. First and foremost, we invest in products we love and teams that inspire us. Sometimes it’s not clear how a market will develop or how a business will mature on the startup roller-coaster journey, and that’s just fine. venture capital On the other hand, it’s important for us to invest in companies that have a clear vision for the future and the role they will play in it. So we get especially excited when we encounter a hardware team that’s not only maniacally focused on their product and customers, but also thinking proactively about how to protect their company from competitors in the long-run. We love both investing in hardware startups and talking about them. Please let me know what you think about this piece, and give me a shout at john@sparkcapital.com. Thanks to Ryan Shmeizer , Nabeel Hyatt , and Rachael Horwitz for their useful feedback.

Stories, News & Mentions about TOAST

Toast’s Stories on HackerNoon

Toast's News & Mentions