The meaning of KEEP COMPANY WITH is to spend time with (someone) —sometimes used figuratively. How to use keep company with in a sentence.

Keep company with Definition & Meaning - Merriam-Webster

KEEP SOMEONE COMPANY meaning: 1. to stay with someone so that they are not alone: 2. to stay with someone so that they are not…. Learn more.

KEEP SOMEONE COMPANY definition | Cambridge English Dictionary

Costco sells its rotisserie chickens for $4.99 -- making it one of the best buys at the warehouse club. Learn why Costco prices its rotisserie chickens so low.

Here's Why Costco's Rotisserie Chicken Is Still the Best Deal in the Store

There is no actual fountain of youth but is there a way to look younger, naturally? Dr. Tomi Mitchell, a Board-Certified Family Physician with Holistic Wellness Strategies says, "In my career as a physician,

5 Surefire Ways to Look Younger, According to Science, Including Skincare

Lines of people wanting to honor Pope Emeritus Benedict XVI's service to the Catholic church have formed in St. Peter's Square for a second day

Benedict's admirers keep streaming to Vatican to honor him

The Pacers' bench outscored the Raptors' 54-7 on Monday with Bennedict Mathurin, T.J. McConnell and Jalen Smith leading the group.

Insider: Mathurin, McConnell, Smith star as Pacers' 2nd-unit out-scores Raptors’ bench 54-7

Commuters returning to work on Tuesday after the Christmas break were advised not to travel as tens of thousands of British rail workers stage a fresh round of strikes that will disrupt services all week.

UK trains disrupted again as workers stage fresh strikes

If your goal is to retire in 2024, 2023 may function as a countdown year of sorts. At this point, you may just need to coast through your job for another 12 months until you're ready to enjoy the freedom you've worked hard for.

If You Want to Retire in 2024, Spend the Next Year Doing These 3 Things

Hi, it’s Cynthia in New York. For me, the term “resolute” conjures up an image of a person who’s admirably unwavering in their conviction. Yet when I think of the word “resolutions,” I think of empty promises.

Using Science to Help You Keep Your New Year's Resolution

So, how do you cut spending effectively? No matter how you slice it, salaries are the number one cost in any business. I understand. We all want to avoid the discussion of cutting people from the payroll.

How to Cut Your Budget During Tough Economic Times

Keep

keep

Good day! My name is Robert. I work for and today I'm sharing some things I think other people would love to know about the Google Keep app. Zoo Web Designs Take A Voice Memo You can take notes on the app using just your voice! Just tap on the microphone icon to speak your note. Keep will both transcribe and record everything you say so even if Google misses some words, you'll still have your voice recording. Transcribe Photo To Text If you import a photo with text on it, Keep can grab that text. When you tap on the photo, you should see a three-dot menu icon in the top right corner. You can then select "Grab image text". Draw On Photos You can use Keep to highlight, color, and draw on your photos. Either import or take a photo then select the paintbrush icon. All you need to do is select your pen style and draw on your photo without affecting the original file. Sync Your Notes with Docs On Your PC Keep is fully integrated with Google's office suite. If you have a file open in Docs or Slides, tap the Keep logo in the sidebar at the right to see a list of your saved notes. Tap a file top open it. You can then copy, cut, or edit anything that's on it. It will automatically sync! If you want to create a Google document out of a note, hold your finger on the note and select "Copy to Google Docs". Collaborate With A Friend Or Colleague It's pretty easy to invite someone to collaborate. Go to the settings sidebar and enable sharing. When you're in a note, tap on the three-dot menu at the bottom and select "Collaborator". You will then be able to select anyone from your address book to link your note with their app. Whenever someone edits it, the other collaborators get notified. Get The Chrome Extension Downloading Keep's extension on the chrome web store will put a small icon next to your address bar which will provide a direct link to your account. By clicking on it, you can save URLs, photos, text, and even take notes while you're using the browser! Use Labels, Colors, Pins For Organization When you long press a note on Keep, it will bring up a series of options to organize your notes. You can color-code, pin, or label your notes! Set A Time or Location Reminder Did you know you could actually turn your note into a reminder? All you need to do is tap the bell icon and it will allow you to set a reminder for a date and time or a location!

10 Things You Didn't Know You Could Do With Google Keep

Disclaimer: Parts of this article are purely fictional. ZBlockBuilders Inc., its CEO, and all accompanying scenarios are made up to help explain complex blockchain concepts in a fun, relatable way. Any resemblance to real companies or people is purely coincidental. Disclaimer: Parts of this article are purely fictional. ZBlockBuilders Inc., its CEO, and all accompanying scenarios are made up to help explain complex blockchain concepts in a fun, relatable way. Any resemblance to real companies or people is purely coincidental. Disclaimer: Parts of this article are purely fictional. ZBlockBuilders Inc., its CEO, and all accompanying scenarios are made up to help explain complex blockchain concepts in a fun, relatable way. Any resemblance to real companies or people is purely coincidental. Don’t lose the farm. Every CEO and their team needs to understand how blockchain nodes work to keep their revenues and respect secure. Don’t lose the farm. Every CEO and their team needs to understand how blockchain nodes work to keep their revenues and respect secure. Don’t lose the farm. Every CEO and their team needs to understand how blockchain nodes work to keep their revenues and respect secure. Congratulations, Reader. You have just been invited to join the team, as Chief Executive Officer, at ZBlockBuilders Inc., a Web3 technology company looking to extend financial coverage for 1.5 billion financially underserved people across the globe. There are several targets on your mind and, of course, a few concerns about how you’ll accomplish your company’s immediate objective of bringing these into the fold. In other words, you want to democratize the financial system by first educating your potential market.  You’ve been offered a fat paycheck and a tall order so you’ve hired me as your adviser to help with this task. Node is the Codeword Our first marketing campaign is to introduce the idea of nodes to our target market. I’ve come up with an interesting idea: let’s show them how dangerous the current fintech system could get. Bands of bad actors roam the internet, empowered by sophisticated hacking software, snooping on customers, hijacking entire banking apps, and carting off troves of customer data. We develop an ad that shows how we can prevent this cataclysmic conclusion by sharing that our technology depends on independent decentralized computers (known as nodes), all functioning as “checkers-and-balancers” on each other. No transaction is added to the blockchain unless and until all nodes approve that it is valid: a parliament of protocols if you like. So, if they’re out on a beach in Mexico chilling, half-drunk, with a Piña Colada in hand, they can be sure that no unauthorized transactions are added to the blockchain (or approved) until they give the word. This strikes you as really important because you recall that when you were CFO at LibertyWonk Inc., a Web-2 based fintech, some sleazy fellow with passable tech credentials capered away with $ 30 million through a Business Email Compromise scheme, ruining lives and LibertyWonk Inc. itself. You laugh, telling me about a certain Hushpuppi, who commandeered atleast $24 million from his mastery of BEC and other cybercrimes. a parliament of protocols a parliament of protocols Hushpuppi, Hushpuppi Copy That! Now, you’re ensconced in your aubergine-colored leather armchair grinning at me. You’re starting to like this. “Tell me more,” you say. I go on sharing that we’ll introduce a series of social media posts reiterating that each of our nodes stores a copy of the entire node system, allowing anybody to verify the provenance of every transaction. In other words, there’s no hiding behind forged records. I flash a web page from my mobile device in front of you, taking you back on memory lane to remind you of the lessons learned from the investigations of the Bank of Credit and Commerce International (BCCI). Investigations which commenced in 1992 and concluded in 2012, cost $656 million paid to firms of lawyers and accountants and resulted in innumerable heartbreaks in victims of the humongous heist. Bank of Credit and Commerce International (BCCI). Bank of Credit and Commerce International (BCCI) Calling all Computers! Nodes (computers, remember?) are linguistic linkers. In other words, they like to communicate with each other just as humans do. Beneath the humming sounds of their hardware, they are asking each other questions about the state of the blockchain just the same way you, as the CEO, would ring the CFO to make yet another inquiry about the financial health of ZBlockBuilders Inc., on a Friday afternoon as you’re getting set to proceed on vacation. While nodes may not go on holiday, they’re still super concerned about how well records are being kept, and believe me, they’ll ask. Something like “hey, are there any new transactions and blocks on our chain, and what are their details?” They constantly check on each other to see how things are going and this involves a process called the consensus mechanism. This simply means that they use a special mode of confirmation to check the state of the blockchain. I’ll share two types of consensus mechanisms. How do Consensus Mechanisms Function? Proof of Work This is native to the Bitcoin core and what it does is require a block miner to solve some truly complex piece of math to create a new block. Once the enterprising mathematician unlocks a new block, it immediately is broadcast to the entire blockchain (just like when Rafiki proudly held the newborn lion cub for all the jungle to see in The Lion King). It more or less says “A new block is born” but without the drama of lions and other animals involved. Proof of Stake Now, this is native to Ethereum and is somewhat different from how things play out in the Bitcoin core. With the proof of stake mechanism, you’re a validator and not a miner (note the distinction). So you’re not actively mining as such. Instead, you’re expected to stake 32 ETH (thirty-two Ethereum) and have a validator software ready and running in the hopes that you’re selected to propose new blocks to be added to the blockchain. If you act right, you’ll get some rewards for it. If you’re considered irresponsible (acting badly or staying offline for too long: slashing) you’re punished by having to lose some of your ETH (Ethereum). Decentralized and Defended The overwhelming beauty of nodes in the blockchain is that each node is a separate entity of its own, acting independently by itself but unanimously with its peers.  Nodes cannot be compelled to approve transactions or fooled by the witty disguises of questing cybercriminals with suggestive emails, until certain rules are collectively adhered to. There is no central system, as we have in current fintech configurations, that can be manipulated or harassed to relinquish value. Nodes function in a trustless environment. That does not mean that they abhor trust, rather they do not rely on trust or goodwill to function. They are ruthless and reliable executors. In Conclusion Essentially, nodes are the librarians, accountants and security guards of the blockchain. They communicate with each other to keep records of the particulars of the blockchain, ensuring that all transactions are properly accounted for and blocking (no pun intended) any unauthorized interactions. Lunch Break,Chief I see that we’re getting somewhere with my marketing campaign proposals because you’re handing me a glass of orange juice. I’m getting quite hungry too. So, if you like, I’ll come back to offer some more advice after the break. Featured Image courtesy of Lalmch on Pixabay Featured Image courtesy of Lalmch on Pixabay Lalmch on Pixabay

How Blockchain Nodes Keep Your Money and Data Safe

Authors:
(1) Zhenbang Feng, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (jasonfen@usc.edu);
(2) Hardhik Mohanty, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (hmohanty@usc.edu);
(3) Bhaskar Krishnamachari, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (bkrishna@usc.edu). Authors: Authors: (1) Zhenbang Feng, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (jasonfen@usc.edu); (2) Hardhik Mohanty, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (hmohanty@usc.edu); (3) Bhaskar Krishnamachari, Department of Electrical and Computer Engineering, Viterbi School of Engineering, University of Southern, California Los Angeles, CA, USA (bkrishna@usc.edu). Editor’s note: This article is part of a broader study. You’re reading part 3 of 5. Read the rest below. Editor’s note: This article is part of a broader study. You’re reading part 3 of 5. Read the rest below. Editor’s note: This article is part of a broader study. You’re reading part 3 of 5. Read the rest below. Table of Links Abstract and I. Introduction
II. The Mechanism
III. Price-Stabilizing Mechanisms, IV. Simulating DAI & V. Simplified Mathematical Model for DAI
VI. How Collateral Price Impacts Derivative Price
VII. Risk Factors for Stable Derivatives & VIII. Conclusions and References Abstract and I. Introduction Abstract and I. Introduction II. The Mechanism II. The Mechanism III. Price-Stabilizing Mechanisms, IV. Simulating DAI & V. Simplified Mathematical Model for DAI III. Price-Stabilizing Mechanisms, IV. Simulating DAI & V. Simplified Mathematical Model for DAI VI. How Collateral Price Impacts Derivative Price VI. How Collateral Price Impacts Derivative Price VII. Risk Factors for Stable Derivatives & VIII. Conclusions and References VII. Risk Factors for Stable Derivatives & VIII. Conclusions and References III. PRICE-STABILIZING MECHANISMS Synthetic derivatives like Single-Collateral DAI (SAI) aim to mirror a particular asset’s value. In SAI’s case, it seeks to peg its value to the US Dollar. The question then arises: How does it ensure that its value remains stable at 1 USD? In reality, several mechanisms work together to ensure this stability. A. Emergency Shutdown A. Emergency Shutdown Emergency shutdown is a mechanism designed for extreme circumstances. This process can be triggered during events like security breaches or huge market volatility. It allows DAI holders to directly redeem its value for $1 of collateral at the point in time when the Emergency Shutdown is initiated, essentially enforcing the 1:1 USD soft peg. B. DAI Savings Rate or Stability Fees B. DAI Savings Rate or Stability Fees Another significant mechanism to ensure price stability is the DAI Savings Rate. When market dynamics push the DAI price away from the target, this savings rate is adjusted. If DAI’s market price goes above 1 USD, the savings rate decreases, reducing demand and pushing the price towards 1 USD. Conversely, if DAI’s price falls below 1 USD, the savings rate rises, increasing demand and nudging the price upwards. In the Single-Collateral DAI, there isn’t a DAI Savings Rate; instead, stability Fees on CDPs are adjusted directly to balance the demand and supply. C. Keepers C. Keepers Keepers play an invaluable role in maintaining DAI’s stability. These are typically automated agents incentivized by profit. They actively participate in Debt and Collateral Auctions during CDP liquidations. More crucially, they trade DAI around its target price, selling when the price is high and buying when it’s low, banking on the long-term convergence towards the target price, thereby helping in maintaining the price stability. Individuals or entities are often motivated to operate keepers due to the potential for profit. This profit expectation relies on their belief that the price of DAI will remain stable around 1 USD. D. Narrative or Belief D. Narrative or Belief An often underestimated element in the mechanism of stability is the narrative or the shared belief of its participants. While tangible mechanisms like target prices, keepers, and oracles play vital roles, the intangible narrative equally underpins the stability of such systems. For example, the shared belief in DAI(SAI) is that it will stay aligned with the US dollar. This belief is propagated and reinforced through consistent communication, historical performance, community trust, and governance transparency. When participants uniformly believe in the 1:1 pegging, they act in ways that naturally enforce this peg further. For instance, if the price of SAI drifts slightly above 1 USD, the narrative would drive participants who are believing to sell, thereby pushing the price back to the peg. Conversely, if SAI dips below 1 USD, the narrative would deem it undervalued, triggering buys and bringing the price back to one dollar. This shared narrative isn’t solely built on blind faith. When the system consistently demonstrates its ability to maintain the peg through various market conditions, it reinforces the narrative. In the following sections, we will delve deeper into the role of this narrative by simulating the effects of shared belief. Role of Belief on DAI price dynamics: Let’s consider the DAI to be solely influenced by “belief” (when b is high). It becomes apparent that a shared consensus on price among the majority of investors creates a situation where an individual investor with a different view is likely to experience a negative expected return. Thus, an investor without extra information would tend to follow the majority, which again reinforces the consensus. Let’s consider two illustrative scenarios: Role of Belief on DAI price dynamics: Let’s consider the DAI to be solely influenced by “belief” (when b is high). It becomes apparent that a shared consensus on price among the majority of investors creates a situation where an individual investor with a different view is likely to experience a negative expected return. Thus, an investor without extra information would tend to follow the majority, which again reinforces the consensus. Let’s consider two illustrative scenarios: • First, suppose the current price of DAI is 1.2 USD. If investor Bob believes that the price will rise to 1.5 USD, he would purchase or take a long position in DAI, while the majority, anticipating a price decline, would sell or short DAI. • Second, consider a situation where the price of DAI is 0.8 USD. If Bob expects the price to drop further to 0.5 USD, he would choose to sell or short DAI. However, if the majority believes the price will increase, they would be looking to buy or go long on DAI. In essence, any given price could theoretically serve as a Nash Equilibrium. However, the mechanism of over-collateralization, Emergency Shutdown, and narrative set by MakerDAO suggest that the Schelling point is anchored at 1 USD. IV. SIMULATING DAI A. DAISIM A. DAISIM DAISIM [12] presents a detailed computational simulation of the single-collateral DAI stablecoin, which was initiated by the MakerDAO project in 2017. This study places a significant emphasis on modeling the behavior of cryptocurrency investors, who are characterized by a range of risk tolerances and are considered rational in their portfolio optimization strategies. A key feature of this simulator is its incorporation of automated mechanisms for both order matching and updating prices, which are critical for determining the market price of DAI. The primary aim of this research is to investigate how the price of single-collateral DAI and the allocation of investment portfolios vary among a group of investors. This variation is analyzed in the context of exogenous parameters such as the price of ETH, as well as several internal system parameters, including the stability rate and transaction fees. B. Updated objective function B. Updated objective function However, the simulated price of the DAI driven by this objective function displayed significant deviation from the desired 1 USD peg. Such consistent deviations suggest that external factors, potentially rooted in market beliefs about DAI’s stability were absent from the model’s considerations. Therefore, we introduce “belief factor” (β) to better encapsulate market sentiment regarding DAI’s valuation. Incorporating this belief factor accounts for the dual nature of market reactions to DAI’s price fluctuations. When the price of DAI falls below $1, the positive β terms stimulate an increase in demand and a decrease in supply, aiming to correct the price towards its intended $1 peg. Conversely, when DAI’s price exceeds $1, these terms adjust to increase supply and reduce demand, facilitating a return to the pegged price. When integrated into the model dynamics, these adjustment mechanisms highlight the investor’s expectation that DAI should maintain a value of $1. Hence, the refined objective function to be maximized can be written in the following manner: V. SIMPLIFIED MATHEMATICAL MODEL FOR DAI Here we present a simple theoretical model of DAI price. This model is presented primarily as an explanatory tool - we do not claim that this is the “correct” model of reality. However, this model allows us to explain two phenomena: 1) how belief influences the price being close to 1, reflected in a high demand for DAI at price below that value and a low demand beyond that price, and 2) how dependence of supply and demand for DAI on the price of ETH might impact the relationship between ETH price and the valuation of DAI. This model could potentially serve as a baseline for further investigation and development by the research community. To determine the price, we equate these two as follows: This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv

DAI Doesn’t Stay at $1 by Accident—Here’s the System That Keeps It There

Keep your happy path flowing, not nesting Keep your happy path flowing, not nesting TL;DR: Arrange your code so the main logic flows along the left margin, handling edge cases early with guard clauses. TL;DR: Arrange your code so the main logic flows along the left margin, handling edge cases early with guard clauses. Problems 😔 Cognitive overhead
Readability
Excessive indentation
Maintainability
Control flow confusion
Stairs Code Cognitive overhead Readability Excessive indentation indentation Maintainability Control flow confusion Stairs Code Stairs Code Solutions 😃 Use early returns
Apply guard clauses
Handle errors first
Keep the main flow to the left
Minimize nesting depth Use early returns Apply guard clauses Handle errors first Keep the main flow to the left Minimize nesting depth Context 💬 When you write code with deeply nested conditional structures, you create "arrow code" or "pyramid of doom." arrow code This makes your program's primary flow hard to follow as it zigzags deeper into indentation levels. Your main logic (the "happy path") gets buried under layers of conditions, making the code harder to read, understand, and maintain. conditions This becomes even more problematic when dealing with internationalization and localization. Nested conditionals often create fragmented contexts for strings, making accurate translations difficult because translators lose the surrounding context needed for proper translation. Sample Code 📖 Wrong ❌ function processUserOrder(user, items) {
  if (user) {
    if (user.isActive()) {
      if (items.length > 0) {
        if (user.hasEnoughCredit()) {
          // The actual business logic is buried 4 levels deep
          let order = createOrder(user, items);
          notifyUser(user, 
            `Your order has been processed`);
          return order;
        } else {
          throw new Error("Insufficient credit");
        }
      } else {
        throw new Error("No items in cart");
      }
    } else {
      throw new Error("Your account is inactive");
    }
  } else {
    throw new Error("No user provided");
  }
} function processUserOrder(user, items) {
  if (user) {
    if (user.isActive()) {
      if (items.length > 0) {
        if (user.hasEnoughCredit()) {
          // The actual business logic is buried 4 levels deep
          let order = createOrder(user, items);
          notifyUser(user, 
            `Your order has been processed`);
          return order;
        } else {
          throw new Error("Insufficient credit");
        }
      } else {
        throw new Error("No items in cart");
      }
    } else {
      throw new Error("Your account is inactive");
    }
  } else {
    throw new Error("No user provided");
  }
} Right 👉 function processUserOrder(user, items) {
  if (!user) throw new Error("No user provided");
  if (!user.isActive()) throw new Error("Your account is inactive");
  if (items.length === 0) throw new Error("No items in cart");
  if (!user.hasEnoughCredit()) throw new Error("Insufficient credit");

  const order = createOrder(user, items);
  notifyUser(user,
    `Your order has been processed`);
  return order;
}

// This is even more readable

function assertValidOrder(user, items) {
  if (!user) throw new Error("No user provided");
  if (!user.isActive()) throw new Error("Your account is inactive");
  if (items.length === 0) throw new Error("No items in cart");
  if (!user.hasEnoughCredit()) throw new Error("Insufficient credit");
}

function processUserOrder(user, items) {
  assertValidOrder(user, items);
  const order = createOrder(user, items);
  notifyUser(user,
    `Your order has been processed`);
  return order;
} function processUserOrder(user, items) {
  if (!user) throw new Error("No user provided");
  if (!user.isActive()) throw new Error("Your account is inactive");
  if (items.length === 0) throw new Error("No items in cart");
  if (!user.hasEnoughCredit()) throw new Error("Insufficient credit");

  const order = createOrder(user, items);
  notifyUser(user,
    `Your order has been processed`);
  return order;
}

// This is even more readable

function assertValidOrder(user, items) {
  if (!user) throw new Error("No user provided");
  if (!user.isActive()) throw new Error("Your account is inactive");
  if (items.length === 0) throw new Error("No items in cart");
  if (!user.hasEnoughCredit()) throw new Error("Insufficient credit");
}

function processUserOrder(user, items) {
  assertValidOrder(user, items);
  const order = createOrder(user, items);
  notifyUser(user,
    `Your order has been processed`);
  return order;
} Detection 🔍 Semi-Automatic Semi-Automatic You can detect this smell by looking for multiple indentation levels (more than 2 or 3). You can also analyse ASTs with advanced linters. Tags 🏷️ IFs IFs Level 🔋 Beginner Beginner Why the Bijection Is Important 🗺️ When you write code with deep nesting, you break the clean Bijection between the logical flow of your business rules and their representation in code. Bijection The real-world business process likely follows a series of validations followed by a main action, but deeply nested code obscures this natural sequence. This one-to-one correspondence breaks down because the primary operation (what the function is supposed to do) gets buried deep in indentation layers. The logical sequence of validations isn't separated from the main action. By keeping your happy path to the left, you create a natural bijection between the actual process flow and the code structure, making it easier to reason about and modify in the future. AI Generation 🤖 AI code generators often create nested conditional structures, especially when generating code from prompts that don't explicitly request early returns or guard clauses. Many AI systems mimic common patterns they observe in training data, where deeply nested conditions are unfortunately prevalent. AI Detection 🥃 Most AI code assistants can identify and fix this code smell with proper instructions. If you ask an AI to refactor code to "use early returns" or "apply guard clauses" or "keep the happy path to the left," it can typically transform nested conditionals into flatter structures. You can also prompt the AI to "reduce nesting in this function" or "refactor this code to avoid deep indentation," and set it as a meta-prompt following your style preferences. Try Them! 🛠 Remember: AI Assistants make lots of mistakes Remember: AI Assistants make lots of mistakes Suggested Prompt: Remove the deep nesting Suggested Prompt: Remove the deep nesting Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Qwen

Qwen Without Proper Instructions

With Specific Instructions



ChatGPT

ChatGPT



Claude

Claude



Perplexity

Perplexity



Copilot

Copilot



Gemini

Gemini



DeepSeek

DeepSeek



Meta AI

Meta AI



Qwen

Qwen Without Proper Instructions

With Specific Instructions Without Proper Instructions Without Proper Instructions With Specific Instructions With Specific Instructions ChatGPT

ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT ChatGPT Claude

Claude Claude Claude Claude Claude Claude Claude Perplexity

Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Perplexity Copilot

Copilot Copilot Copilot Copilot Copilot Copilot Copilot Gemini

Gemini Gemini Gemini Gemini Gemini Gemini Gemini DeepSeek

DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek DeepSeek Meta AI

Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Meta AI Qwen

Qwen Qwen Qwen Qwen Qwen Qwen Qwen Conclusion 🏁 Keep your happy path to the left by using early returns and guard clauses, you will create more readable, maintainable code. You communicate business logic more clearly, reduce cognitive load for other developers (including your future self), and create more resilient code to change. Remember to handle the special cases early, and let your main logic flow naturally along the left margin. Your colleagues (and future you) will thank you. Relations 👩‍❤️‍💋‍👨 Code Smell 102 - Arrow Code Code Smell 102 - Arrow Code https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxiv?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxiv?embedable=true https://maximilianocontieri.com/code-smell-294-implicit-return?embedable=true https://maximilianocontieri.com/code-smell-294-implicit-return?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvii?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvii?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxiii?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxiii?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxi?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxi?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvii https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-xxxvii Disclaimer 📘 Code Smells are my opinion. opinion Credits 🙏 Photo by Alexander Hipp on Unsplash Alexander Hipp Unsplash A function should follow the "arrow shape" of reading naturally from top to bottom, not wander into deeper nesting like a poorly designed maze. A function should follow the "arrow shape" of reading naturally from top to bottom, not wander into deeper nesting like a poorly designed maze. Venkat Subramaniam Software Engineering Great Quotes Software Engineering Great Quotes This article is part of the CodeSmell Series. https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true https://hackernoon.com/how-to-find-the-stinky-parts-of-your-code-part-i-xqz3evd?embedable=true

Keep Your Happy Path Flowing, Not Nesting

AI and Human Creativity Can Totally Coexist—if AI Doesn’t End up Eating the Thing Keeping it Alive

La IA y la creatividad humana pueden coexistir totalmente si la IA no termina comiendo la cosa manteniéndola viva

AI ak kreyativite imen ka totalman koexiste - si AI pa fini manje bagay la kenbe li viv

AIと人間の創造性は完全に共存できる - AIが生き残るものを食べない場合

AI un cilvēka radošums var pilnībā līdzāspastāvēt - ja AI galu galā neēd lietu, kas to saglabā dzīvu

Ny AI sy ny fahaiza-manaon'ny olombelona dia afaka miara-miaina tanteraka - raha tsy mihinana ny zava-drehetra ny AI

AI dan kreativiti manusia boleh bersatu sama sekali - jika AI tidak berakhir makan perkara yang mengekalkan hidupnya

AI i ljudska kreativnost mogu u potpunosti da koegzistiraju – ako AI ne završi da jede stvar koja ga održava živom

AI และความคิดสร้างสรรค์ของมนุษย์สามารถมีอยู่ร่วมกันอย่างสมบูรณ์หาก AI ไม่สิ้นสุดกินสิ่งที่จะทําให้มันมีชีวิตอยู่

AI і людська творчість можуть повністю співіснувати, якщо AI не з'їсть речі, що тримають їх живими

AI və Human Creativity o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z o‘z

I-AI ne-Human Creativity Ingatholakala Kuhle - Uma I-AI Ayikwazanga Ukuthatha I-Thing Yenza Emuva

Why Your Privacy Fears Keep Feeding The Data Machine

Today, we are excited to announce the support of continuous updates for long-running pipelines in CocoIndex. This powerful feature automatically applies incremental source changes to keep your index up-to-date with minimal latency. With continuous updates, your indexes remain synchronized with your source data in real time, ensuring that your applications always have access to the most current information without the performance overhead of full reindexing. If you like our work, it would mean a lot to us if you could support Cocoindex on Github with a star. Thank you so much with a warm coconut hug 🥥🤗. Cocoindex on Github When to use it? It fits into situations that you need to access the fresh target data continuously in most of the time. How does it work? It continuously captures changes from the source data and updates the target data accordingly. It's long-running and only stops when being aborted explicitly. A data source may enable one or multiple change capture mechanisms: CocoIndex supports two main categories of change detection mechanisms: General Mechanism:

Refresh Interval: A universal approach applicable to all data sources, allowing periodic checks for changes by scanning and comparing the current state with the previous state.


Source-Specific Mechanisms:

Push Change Notification: Many data sources offer built-in mechanisms for real-time change notification which CocoIndex can subscribe to (coming soon!)
Recent Changes Poll: Some data sources provide APIs for tracking recently modified entries, allowing efficient detection of changes; for example, Google Drive. General Mechanism:

Refresh Interval: A universal approach applicable to all data sources, allowing periodic checks for changes by scanning and comparing the current state with the previous state. General Mechanism Refresh Interval: A universal approach applicable to all data sources, allowing periodic checks for changes by scanning and comparing the current state with the previous state. Refresh Interval: A universal approach applicable to all data sources, allowing periodic checks for changes by scanning and comparing the current state with the previous state. Refresh Interval Source-Specific Mechanisms:

Push Change Notification: Many data sources offer built-in mechanisms for real-time change notification which CocoIndex can subscribe to (coming soon!)
Recent Changes Poll: Some data sources provide APIs for tracking recently modified entries, allowing efficient detection of changes; for example, Google Drive. Source-Specific Mechanisms Push Change Notification: Many data sources offer built-in mechanisms for real-time change notification which CocoIndex can subscribe to (coming soon!)
Recent Changes Poll: Some data sources provide APIs for tracking recently modified entries, allowing efficient detection of changes; for example, Google Drive. Push Change Notification: Many data sources offer built-in mechanisms for real-time change notification which CocoIndex can subscribe to (coming soon!) Push Change Notification Recent Changes Poll: Some data sources provide APIs for tracking recently modified entries, allowing efficient detection of changes; for example, Google Drive. Recent Changes Poll These mechanisms work together to ensure CocoIndex can detect and process changes as they happen, maintaining your index in perfect sync with source data with minimal latency and resource usage. Under the hood, after the change is detected, CocoIndex will use its incremental processing mechanism to update the target data. incremental processing mechanism How to enable continuous updates? Here is an example of how to enable continuous updates for Google Drive. It is pretty simple: example 1. Configure the change capture mechanisms for the source @cocoindex.flow_def(name="GoogleDriveIndex")
def my_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope):
    data_scope["documents"] = flow_builder.add_source(
        cocoindex.sources.GoogleDrive(
            service_account_credential_path=credential_path,
            root_folder_ids=root_folder_ids,
            recent_changes_poll_interval=datetime.timedelta(seconds=10)),
        refresh_interval=datetime.timedelta(minutes=1)) @cocoindex.flow_def(name="GoogleDriveIndex")
def my_flow(flow_builder: cocoindex.FlowBuilder, data_scope: cocoindex.DataScope):
    data_scope["documents"] = flow_builder.add_source(
        cocoindex.sources.GoogleDrive(
            service_account_credential_path=credential_path,
            root_folder_ids=root_folder_ids,
            recent_changes_poll_interval=datetime.timedelta(seconds=10)),
        refresh_interval=datetime.timedelta(minutes=1)) In this example, we've configured two change detection mechanisms: recent_changes_poll_interval=datetime.timedelta(seconds=10): This is a Google Drive-specific mechanism that uses the Drive API's changes endpoint to efficiently detect modifications every 10 seconds. This is effecient fast scan to capture all latest modified files, and we could set it to a short interval to get fresher data. It doesn't capture file deletions, so we need the fallback mechanism to ensure all changes are eventually captured.


refresh_interval=datetime.timedelta(minutes=1): This is the universal fallback mechanism that performs a complete scan of the data source every minute. This is to scan all the files, to ensure all the changes - including the deleted files, are captured.
The refresh_interval parameter is particularly important as it serves as a safety net to ensure all changes are eventually captured, even if source-specific mechanisms miss something. It works by:

Periodically scanning the list of entries (e.g. file list with metadata like last modified time) at the specified interval
Comparing the current list with the previously known list
Identifying any differences (additions, modifications, deletions)
Triggering updates only for the changed items recent_changes_poll_interval=datetime.timedelta(seconds=10): This is a Google Drive-specific mechanism that uses the Drive API's changes endpoint to efficiently detect modifications every 10 seconds. This is effecient fast scan to capture all latest modified files, and we could set it to a short interval to get fresher data. It doesn't capture file deletions, so we need the fallback mechanism to ensure all changes are eventually captured. recent_changes_poll_interval=datetime.timedelta(seconds=10): This is a Google Drive-specific mechanism that uses the Drive API's changes endpoint to efficiently detect modifications every 10 seconds. This is effecient fast scan to capture all latest modified files, and we could set it to a short interval to get fresher data. It doesn't capture file deletions, so we need the fallback mechanism to ensure all changes are eventually captured. recent_changes_poll_interval=datetime.timedelta(seconds=10) refresh_interval=datetime.timedelta(minutes=1): This is the universal fallback mechanism that performs a complete scan of the data source every minute. This is to scan all the files, to ensure all the changes - including the deleted files, are captured.
The refresh_interval parameter is particularly important as it serves as a safety net to ensure all changes are eventually captured, even if source-specific mechanisms miss something. It works by:

Periodically scanning the list of entries (e.g. file list with metadata like last modified time) at the specified interval
Comparing the current list with the previously known list
Identifying any differences (additions, modifications, deletions)
Triggering updates only for the changed items refresh_interval=datetime.timedelta(minutes=1): This is the universal fallback mechanism that performs a complete scan of the data source every minute. This is to scan all the files, to ensure all the changes - including the deleted files, are captured. refresh_interval=datetime.timedelta(minutes=1) The refresh_interval parameter is particularly important as it serves as a safety net to ensure all changes are eventually captured, even if source-specific mechanisms miss something. It works by: refresh_interval Periodically scanning the list of entries (e.g. file list with metadata like last modified time) at the specified interval
Comparing the current list with the previously known list
Identifying any differences (additions, modifications, deletions)
Triggering updates only for the changed items Periodically scanning the list of entries (e.g. file list with metadata like last modified time) at the specified interval Comparing the current list with the previously known list Identifying any differences (additions, modifications, deletions) Triggering updates only for the changed items While source-specific mechanisms like recent_changes_poll_interval are more efficient for near real-time updates, the refresh_interval provides comprehensive coverage. We recommend setting it to a reasonable value based on your freshness requirements and resource constraints - shorter intervals provide fresher data but consume more resources. recent_changes_poll_interval refresh_interval You can read the full documentation: for source specific change detection mechanisms here. Different sources have different mechanisms supported.
for the universal fallback mechanism here. for source specific change detection mechanisms here. Different sources have different mechanisms supported. here for the universal fallback mechanism here. here 2. Run the flow in live update mode Option 1: CLI Add a @cocoindex.main_fn() decorator to your main function, so CocoIndex CLI will take over the control (when cocoindex is the first command line argument). @cocoindex.main_fn() @cocoindex.main_fn()
def main():
    pass

if __name__ == "__main__":
  main() @cocoindex.main_fn()
def main():
    pass

if __name__ == "__main__":
  main() To run the CLI with live update mode, you can use the following command: python main.py cocoindex update -L python main.py cocoindex update -L This will start the flow in live update mode, which will continuously capture changes from the source and update the target data accordingly. Option 2: Python API You can create cocoindex.FlowLiveUpdater. For example, cocoindex.FlowLiveUpdater @cocoindex.main_fn()
async def main():
    my_updater = cocoindex.FlowLiveUpdater(demo_flow)
    await my_updater.wait()
    ...

if __name__ == "__main__":
    asyncio.run(main()) @cocoindex.main_fn()
async def main():
    my_updater = cocoindex.FlowLiveUpdater(demo_flow)
    await my_updater.wait()
    ...

if __name__ == "__main__":
    asyncio.run(main()) And you run with the flow with python main.py python main.py You can also use the updater as a context manager. It will abort and wait for the updater to finish automatically when the context is exited. See full documentation here. here Now you are all set! It is super simple to get started and have continuous updates for your data. Get started now quickstart guide 🚀 quickstart guide It would mean a lot to us if you could support Cocoindex on Github with a star if you like our work. Thank you so much with a warm coconut hug 🥥🤗. Cocoindex on Github

Keep Your Indexes Fresh With This Real-time Pipeline

CocoIndex https://github.com/cocoindex-io/cocoindex is a ETL framework that helps you to turn your data ready for AI in realtime. https://github.com/cocoindex-io/cocoindex The essential part for supporting robust and efficient update is because of incremental update. In CocoIndex, users declare the transformation, and don't need to worry about the work to keep index and source in sync.  In this blog we would like to share how we handled the incremental update. If you like our work, it would mean a lot if you could support us ❤️ with a github star! https://github.com/cocoindex-io/cocoindex https://github.com/cocoindex-io/cocoindex CocoIndex creates & maintains an index, and keeps the derived index up to date based on source update, with minimal computation and changes. That makes it suitable for ETL/RAG or any transformation tasks stays low latency between source and index updates, and also minimizes the computation cost. What is Incremental Updates? Figuring out what exactly need to be updated, and only update that without having to recompute everything throughout. How does it work? You don't really need to do anything special, just focus on define the transformation need. CocoIndex automatically tracks the lineage of your data and maintains a cache of computation results. When you update your source data, CocoIndex will: Identify which parts of the data have changed


Only recompute transformations for the changed data


Reuse cached results for unchanged data


Update the index with minimal changes Identify which parts of the data have changed Identify which parts of the data have changed Only recompute transformations for the changed data Only recompute transformations for the changed data Reuse cached results for unchanged data Reuse cached results for unchanged data Update the index with minimal changes Update the index with minimal changes And CocoIndex will handle the incremental updates for you. CocoIndex provide two modes with pipeline with simple configuration: batch mode - for one time update.
live update mode - long running pipeline, with live update. Both modes runs with incremental updates. batch mode - for one time update. live update mode - long running pipeline, with live update. Both modes runs with incremental updates. Who needs Incremental Updates? Many people may think incremental updates is only beneficial for large scale data, thinking carefully, it really depends on the cost and requirement for data freshness. Google processed large scale data, and google has huge resources for it. Your data scale is much less than Google, but your resource provision is also much less than Google. Real condition for incremental update needs is: high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data.
transformation cost is significant higher than retrieval itself high freshness requirement, for example, you client has GDPR compliance, you need to update the index with the latest data. transformation cost is significant higher than retrieval itself Overall, say T is your most acceptable staleness, if you don't want to recompute the whole thing repeatedly every T, then you need incremental more or less. What exactly is incremental updates, with examples Well, we could take a look at a few examples to understand how it works. Example 1: Update a document Consider this scenario: I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After it's updated. 3 of them are exactly same as previous; others have changed I have a document. Initially, it's split into 5 chunks, resulting in 5 rows with their embeddings in the index. After it's updated. 3 of them are exactly same as previous; others have changed So we need to keep 3 rows, remove 2 previously existing rows, and add 2 new rows. These need to happen behind the scene: Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused.
Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. Ideally, we only recompute embeddings for the 4 new rows, and reuse it for 3 unchanged chunks. This can save computation cost especially when the embedding API charge by usage. CocoIndex achieves this by maintaining a cache for heavy steps like embedding, and on the input for a transformation step isn't changed, the output will be reused. Besides, we also maintain a lineage tracking in the internal storage. It keeps track of which rows in the index are derived from the previous version of this document, to make sure stale versions are properly removed. CocoIndex takes care of this. Example 2: Delete a document Contining with the same example. If we delete the document later, we need to delete all 7 rows derived from the document. Again, this needs to be based on the lineage tracking maintained by CocoIndex. Example 3: Change of the transformation flow The transformation flow may also be changed, for example, the chunking logic is upgraded, or a parameter passed to the chunker is adjusted. This may result in the following scenario: Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index.
After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. Before the change, the document is split into 5 chunks, resulting in 5 rows with their embeddings in the index. After the change, they become 6 chunks: 4 of previous chunks remain unchanged, the remaining 1 is split into 2 smaller chunks. This falls into a similar situation as document update (example 1), and CocoIndex will take care of it. The approach is similar, while this involves some additional considerations: We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key.
To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. We can still safely reuse embeddings for 4 unchanged chunks by the caching mechanism: this needs an prequisite that the logic and spec for embedding is unchanged. If the changed part is the embedding logic or spec, we will recompute the embeddings for everything. CocoIndex is able to see if the logic or spec for a operation step is changed from the cached version, by putting these additional information in the cache key. To remove stale rows in the target index, the lineage tracking works well again. Note that some other systems handle stale output deletions on source update/deletion by replaying the transformation logic on the previous version of input: this only works well when transformation is fully deterministic and never upgraded. CocoIndex's lineage tracking based approach doesn't have this limitation: it's robust to transformation logic non-determinism and changes. Example 4: Multiple inputs involved: Merge / Lookup / Clustering All examples above are simple cases: each single input row (e.g. a document) is involved independently during each specific transformation. CocoIndex is a highly customizable framework, not only limited to simple chunking and embedding. It allows users for more complex advanced transformations, such as: Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources.
Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed.
Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Merge. For example, you're bulding an index for "all AI products", and you want to combine information from multiple sources, some product exists in one source and some in multiple. For each product, you want to combine information from different sources. Merge Lookup. For example, you also have a data source about company information. During you transformation for each product, you want to enrich it with information of the company building the product, so a lookup for the company information is needed. Lookup Clustering. For example, you want to cluster different products into scenarios, and create cluster-level summaries based on information of products in the cluster. Clustering The common theme is that during transformation, multiple input rows (coming from single or multiple sources) need to be involved at the same time. Once a single input row is updated or deleted, CocoIndex will need to fetch other related rows from the the same or other sources. Here which other rows are needed is based on which are involved in the transformations. CocoIndex keeps track of such relationships, and will fetch related rows and trigger necessary reprocessings incrementally. Change Data Capture (CDC) 1. When source supports push change Some source connectors support push change. For example, Google Drive supports drive-level changelog and send change notifications to your public URL, which is applicable for team drive and personal drive (only by OAuth, service account not supported). When a file is created, updated, or deleted, CocoIndex could compute based on the diff. 2. Metadata-based, last modified only Some source connectors don't support push change, but provide metadata and file system operations that list most recent changed files. For example, Google Drive with service account. CocoIndex could monitor the change based on last modified vs last poll time, periodic trigger to check modified. However this cannot capture full change, for example a file has been deleted. 3. Metadata-based, Fullscan Some source connectors have limited capabilities with listing files, but provide metadata that list all files. For example, with local files, we'd need to traverse all files in all directories and subdirectories recursively to get the full list. When the number of files is large, it's expensive to traverse all files. Cache In CocoIndex, every piece of the lego block in the pipeline can be cached. Custom functions can take a paramter cache. When True, the executor will cache the result of the function for reuse during reprocessing. We recommend to set this to True for any function that is computationally intensive. Output will be reused if all these unchanged: spec (if exists), input data, behavior of the function. For this purpose, a behavior_version needs to be provided, and should increase on behavior changes. For example, this enables cache for a standalone function, see full code example here: @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ... @cocoindex.op.executor_class(gpu=True, cache=True, behavior_version=1)
class PdfToMarkdownExecutor:
    """Executor for PdfToMarkdown."""
      ...

Why Recompute Everything When You Can Use This Solution to Keep Your AI Index Fresh Automatically

Table of Links Abstract and 1 Introduction Abstract and 1 Introduction 1.1 Related literature 1.1 Related literature Types of Metrics and Their Hypothesis and 2.1 Types of metrics
2.2 Hypotheses for different types of metrics


Type I and Type II Error Rates for Decision Rules including Superiority and Non-Inferiority Tests
3.1 The composite hypotheses of superiority and non-inferiority tests
3.2 Bounding the type I and type II error rates for UI and IU testing
3.3 Bounding the error rates for a decision rule including both success and guardrail metrics
3.4 Power corrections for non-inferiority testing


Extending the Decision Rule with Deterioration and Quality Metrics


Monte Carlo Simulation Study
5.1 Results


Discussion and Conclusions Types of Metrics and Their Hypothesis and 2.1 Types of metrics
2.2 Hypotheses for different types of metrics Types of Metrics and Their Hypothesis and 2.1 Types of metrics Types of Metrics and Their Hypothesis and 2.1 Types of metrics 2.2 Hypotheses for different types of metrics 2.2 Hypotheses for different types of metrics Type I and Type II Error Rates for Decision Rules including Superiority and Non-Inferiority Tests
3.1 The composite hypotheses of superiority and non-inferiority tests
3.2 Bounding the type I and type II error rates for UI and IU testing
3.3 Bounding the error rates for a decision rule including both success and guardrail metrics
3.4 Power corrections for non-inferiority testing Type I and Type II Error Rates for Decision Rules including Superiority and Non-Inferiority Tests Type I and Type II Error Rates for Decision Rules including Superiority and Non-Inferiority Tests 3.1 The composite hypotheses of superiority and non-inferiority tests 3.1 The composite hypotheses of superiority and non-inferiority tests 3.2 Bounding the type I and type II error rates for UI and IU testing 3.2 Bounding the type I and type II error rates for UI and IU testing 3.3 Bounding the error rates for a decision rule including both success and guardrail metrics 3.3 Bounding the error rates for a decision rule including both success and guardrail metrics 3.4 Power corrections for non-inferiority testing 3.4 Power corrections for non-inferiority testing Extending the Decision Rule with Deterioration and Quality Metrics Extending the Decision Rule with Deterioration and Quality Metrics Extending the Decision Rule with Deterioration and Quality Metrics Monte Carlo Simulation Study
5.1 Results Monte Carlo Simulation Study Monte Carlo Simulation Study 5.1 Results 5.1 Results Discussion and Conclusions Discussion and Conclusions Discussion and Conclusions APPENDIX A: IMPROVING THE EFFICIENCY OF PROPOSITION 4.1 WITH ADDITIONAL ASSUMPTIONS APPENDIX A: APPENDIX A: IMPROVING THE EFFICIENCY OF PROPOSITION 4.1 WITH ADDITIONAL ASSUMPTIONS APPENDIX B: EXAMPLES OF GLOBAL FALSE AND TRUE POSITIVE RATES APPENDIX B: APPENDIX B: EXAMPLES OF GLOBAL FALSE AND TRUE POSITIVE RATES APPENDIX C: A NOTE ON SEQUENTIAL TESTING OF DETERIORATION APPENDIX C: APPENDIX C: A NOTE ON SEQUENTIAL TESTING OF DETERIORATION APPENDIX D: USING NYHOLT’S METHOD OF EFFICIENT NUMBER OF INDEPENDENT TESTS APPENDIX D: APPENDIX D: USING NYHOLT’S METHOD OF EFFICIENT NUMBER OF INDEPENDENT TESTS Acknowledgments and References Acknowledgments and References 4. EXTENDING THE DECISION RULE WITH DETERIORATION AND QUALITY METRICS Deterioration tests are inferiority tests that aim to capture regressions in metrics. They can be applied to metrics already present as a success or a guardrail metric, or to metrics that are only included in this category as deterioration metrics. The test checks if the metric is significantly deteriorating. That is, if the treatment group is significantly inferior to the control group with respect to the metric of interest. Deterioration tests for success and guardrail metrics attempt to identify significant regressions, which would, if they exist, speak against the success of the experiment. Neither the superiority test used for success metrics or the non-inferiority test used for guardrail metrics would on its own indicate a regression. Knowing when regressions occur is essential when running experiments. In practice, in addition to success, guardrail and detrioriation metrics, also experiment-quality metrics are used. For example, at Spotify, we include a set of tests and metrics that evaluate the quality of the experiment. These include a test for balanced traffic through a sample ratio mismatch test, and a test for pre-exposure bias. By including deterioration and quality tests in the decision rule, the complexity to manage the risks of an incorrect decision increases. Decision Rule 2 formalizes the complete decision rule that is used at Spotify. DECISION RULE 2. Ship the change if and only if: at least one success metric is significantly superior


all guardrail metrics are significantly non-inferior


none of the success, guardrail or deterioration metrics are significantly inferior


none of the quality tests are significantly rejecting quality at least one success metric is significantly superior at least one success metric is significantly superior all guardrail metrics are significantly non-inferior all guardrail metrics are significantly non-inferior none of the success, guardrail or deterioration metrics are significantly inferior none of the success, guardrail or deterioration metrics are significantly inferior none of the quality tests are significantly rejecting quality none of the quality tests are significantly rejecting quality That is, ship if and only if the global superiority/noninferiority null hypothesis is rejected in favor of the alternative hypothesis, the inferiority null hypothesis is not rejected for any metric, and no quality test is significant. Proposition 4.1 displays the corresponding correction, to bound the error rates of Decision Rule 2. This directly implies that In other words, the effect of the deterioration tests can only make the false positive rate lower than α. This concludes the first part of the proof. Plugging this into the above yield To find the corrected β for achieving the intended type II error rate, we solve The condition that α_ < β should be interpreted as that is only possible to correct the false negative rate (and thus ensuring the intended power) for decision rules that include deterioration and/or quality tests as long as the intended false negative rate for the decision is larger than the intended false positive rate for those tests. This is quite natural, if we add a large enough chance of rejecting no deterioration or quality, even when there is no deteriration or problem with the quality, this will at some point (for some α_) limit our ability to find a positive decision, regardless of the sample size. For success and guardrail metrics, there is a dependency between the rejection of the deterioration test and the superiority or non-inferiority test for any given metric, respectively. That is, if the superiority or non-inferiority test is rejected, this affects the probability of the deterioration test to be rejected too. It is possible to utilize this dependency to improve the efficiency of Proposition 4.1 slightly by making additional assumptions about the relation between α, α_, and β. See Appendix A for details. Authors:
(1) Mårten Schultzberg, Experimentation Platform team, Spotify, Stockholm, Sweden;
(2) Sebastian Ankargren, Experimentation Platform team, Spotify, Stockholm, Sweden;
(3) Mattias Frånberg, Experimentation Platform team, Spotify, Stockholm, Sweden. Authors: Authors: (1) Mårten Schultzberg, Experimentation Platform team, Spotify, Stockholm, Sweden; (2) Sebastian Ankargren, Experimentation Platform team, Spotify, Stockholm, Sweden; (3) Mattias Frånberg, Experimentation Platform team, Spotify, Stockholm, Sweden. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv available on arxiv

How Companies Decide Which Product Changes to Keep or Scrap

In recent years, artificial intelligence (AI) has become an essential part of many industries, with health care being no exception. Its ability to enhance practices, streamline processes and provide real-time insights is reshaping the way care facilities operate. But how does AI improve patient safety in hospitals? Enhancing Surgical Precision with AI Enhancing Surgical Precision with AI Enhancing Surgical Precision with AI All surgical procedures require an incredibly high level of precision because even the smallest error can lead to complications. Although surgeons are highly trained professionals, they can benefit from technological assistance to enhance their accuracy and decision-making during difficult surgeries. AI video analytics is emerging as a vital tool in improving surgeries. Automated video systems can analyze live feeds of the surgical area, offering guidance to the surgical team throughout the procedure. By using advanced image recognition and machine learning algorithms, these systems can highlight critical areas of focus like tissue differentiation and even surgical tool positioning. live feeds of the surgical area live feeds of the surgical area AI can also track the team’s movements, identifying any deviations from optimal techniques or patterns. This feedback loop can help them correct any potential mistakes before they escalate, enhancing the overall precision of the operation. can also track the team’s movements can also track the team’s movements In high-stakes surgeries, AI video analytics offers an extra layer of support, providing objective analysis and real-time feedback to ensure only the most favorable outcomes. This boosts patient safety and may offer shorter recovery times and better overall outcomes. The Role of AI Video in Monitoring Sedation Levels The Role of AI Video in Monitoring Sedation Levels The Role of AI Video in Monitoring Sedation Levels The Role of AI Video in Monitoring Sedation Levels Both over- and under-sedation can lead to serious complications, including respiratory distress or waking up during surgery. Monitoring the medication’s delivery is critical for operations that require general anesthesia. Not only does it come with more risks, but it’s necessary for more intensive procedures, and waking up during these can be very dangerous. can lead to serious complications can lead to serious complications Traditionally, clinicians rely on various tools and their own observations to assess a patient’s sedation status. However, these methods can sometimes be subjective or prone to human error. AI-powered video monitoring is making waves in this area. By tracking subtle facial cues like blink rate, pupil dilation and facial muscle movement, AI systems can provide data on a patient’s sedation. They analyze video feeds and use algorithms to detect signs of over- or under-sedation. For instance, a decrease in blink rate could indicate a patient is too deeply sedated, while rapid blinking or facial tension may signal insufficient sedation. can provide data on can provide data on If the system detects irregularities in sedation, alerts can be sent to the medical team so they’re able to correct the issue. This makes it possible for clinicians to adjust sedation levels quickly and reduce the risk of complications. AI in Post-Surgery and Recovery AI in Post-Surgery and Recovery AI in Post-Surgery and Recovery AI in Post-Surgery and Recovery The period following surgery is essential for a patient’s recovery because it involves careful monitoring to ensure no complications occur. It is also important to ensure the healing process goes smoothly. Traditionally, post-surgery recovery relies on routine check-ups and patient self-reporting, but AI video analytics is now making this process more efficient and accurate. AI systems can now monitor patients during recovery by tracking their movements, alertness and overall well-being. For instance, video analysis can detect if a patient is attempting to get out of bed too early, which could lead to falls or injury. By analyzing facial expressions and body language, the system can also identify signs of pain or discomfort that might otherwise go unnoticed, which allows medical staff to respond more quickly to a patient’s needs. Automation technology can also monitor key recovery indicators like respiratory patterns or heart rate through video feeds. These can alert the medical team to irregularities like changes in breathing or excessive movement, which might indicate the need for intervention. can also monitor key recovery indicators can also monitor key recovery indicators AI-powered video can help track post-surgical physical therapy progress. For example, it can ensure patients are following the prescribed rehabilitation exercises, providing feedback to both them and clinicians. It can also measure the range of motion or symmetry in movements to support recovery efforts and prevent setbacks. Using AI in post-surgery care can help hospitals ensure faster, more accurate recovery monitoring, reducing complications and improving overall patient outcomes. are following the prescribed rehabilitation exercises are following the prescribed rehabilitation exercises Reducing Human Error and Improving Patient Care Reducing Human Error and Improving Patient Care Reducing Human Error and Improving Patient Care Reducing Human Error and Improving Patient Care Even the most skilled professionals are susceptible to human error, especially when exposed to high-stress environments like operating theatres. Fatigue, distractions, and the volume of patients can lead to mistakes in monitoring, medication administration and patient assessments. AI video analytics help reduce these errors by providing an extra layer of oversight and alerts that support decision-making. One of the largest areas where AI minimizes human error is in medication management. Automated systems can monitor whether the correct dosages and types of medication are being administered to ensure nurses or pharmacists follow proper protocols. This can be particularly useful in preventing dosage miscalculations. correct dosages and types of medication correct dosages and types of medication AI video also enhances patient safety by ensuring compliance with hospital hygiene protocols. Hand hygiene is one of the simplest factors in preventing further medical issues. AI-driven video monitoring can track whether health care workers sanitize their hands before and after patient interactions, reducing the risk of hospital-acquired infections. sanitize their hands before and after sanitize their hands before and after Strengthening Hospital Security Strengthening Hospital Security Strengthening Hospital Security Strengthening Hospital Security Hospitals are high-traffic environments where security challenges are constant. From unauthorized access to missing medical equipment, maintaining a safe and secure facility is essential for both patients and staff. Traditional security measures like CCTV cameras and on-site security personnel have limitations. AI-powered video surveillance enhances hospital security by providing real-time monitoring, automated alerts and predictive threat detection. by providing real-time monitoring by providing real-time monitoring One of the biggest advantages of AI-driven security is its ability to detect unusual behavior before it escalates into a security threat. Video analytics can identify loitering, unauthorized access or even the presence of concealed weapons. Unlike traditional security cameras, it analyzes video feeds continuously, flagging potential threats instantly so hospital security teams can respond faster. AI vision can also improve access control by integrating facial recognition and badge verification systems. This ensures only authorized personnel enter restricted zones like operating rooms, ICUs and pharmaceutical storage areas. It can also track visitors, logging their movements to prevent security breaches or unauthorized patient interactions. by integrating facial recognition by integrating facial recognition Another critical security challenge in hospitals is asset protection. Expensive medical equipment can get misplaced or stolen in the field, either through innocent or malicious means. AI-powered surveillance can track these assets using object recognition, ensuring essential tools are always available when necessary. can get misplaced or stolen can get misplaced or stolen Such video systems also play a role in emergency response. If a patient or visitor collapses, AI can instantly detect the fall and alert nearby medical staff. In cases of violence or distress, AI-driven cameras can identify escalating situations and notify security before they get out of control. Using automation for video surveillance can significantly enhance hospitals’ security infrastructure, ensuring a safer environment for patients, staff and visitors. How Does AI Improve Patient Safety in Hospitals? AI-powered video monitoring is transforming hospital safety in once-unimaginable ways. From ensuring patients receive the right level of sedation to enhancing surgical precision, supporting post-op recovery and tightening hospital security, AI is proving to be an invaluable tool in modern health care. As hospitals continue to evolve, automation-driven video technology will play an even greater role in keeping patients safe, streamlining operations and preventing potential crises before they unfold. In an environment where every second counts, having an extra set of “eyes” that never blink can make all the difference.

Stories, News & Mentions about KEEP

Categories

Trending Topics

Stories, News & Mentions about KEEP

Keep’s Stories on HackerNoon

Keep's News & Mentions

Categories

Trending Topics