Dushyant Chautala, the friend-turned-foe of the BJP who is out to fell the government, should police his party, sources have indicated.

Amid Haryana Crisis, 4 MLAs Of Dushyant Chautala Meet BJP's ML Khattar

Donald Trump is heading into the most perilous phase of his hush money trial aside from the moment when the jury retires to consider its verdict.

Analysis: Critical days of Trump trial will test whether he can exercise discipline and restraint | CNN Politics

Predicted victory for nationalist VMRO-DPMNE may stir tensions with EU neighbours Greece and Bulgaria.

North Macedonia’s opposition set for big election wins | Elections News | Al Jazeera

OTTAWA — The federal government will test its capacity to issue emergency alerts today. That means Canadians in most provinces and territories will receive a test alert on their cellphones, as well as through TV and radio broadcasts. The sole exception is Ontario, where the test will take ...

Most of Canada to receive emergency alert test today

Canada&#x27;s national public alert system is running tests on television, radio and compatible wireless devices across most of the country on May 8.

There's a test of the national emergency alert system in most of Canada Wednesday | CBC News

The City of Montreal is slated to test out its annual warning siren test Wednesday.

Montreal to carry out annual warning siren test | CTV News

The federal government will test its capacity to issue emergency alerts today, with the exception of Ontario, where the test will take place on May 15.

Cellphone emergency alert system testing in Canada | CTV News

Mastercard Inc. is joining with some of the largest US banks to test shared-ledger technology that would allow the common settlement of tokenized assets such as commercial-bank money as well as Treasury and investment-grade debt securities.

Mastercard, Citi, JPMorgan Test Ledger for Settling Bank Money - BNN Bloomberg

Montreal will test population alert sirens between 9 a.m. and 3 p.m. on Wednesday, the city says in a news release. The exercise aims to raise awareness among residents who live near 10 factories that could have a toxic leak of some kind.

Montreal to test alert sirens throughout the day | CBC News

Here is a roundup of stories from The Canadian Press designed to bring you up to speed on what you need to know today… Most of Canada to receive emergency alert test The federal government will test its capacity to issue emergency alerts today. That means Canadians in most provinces and ...

In the news today: Emergency alert test, Drake shooting investigation

2TEST

2test

Hello Amazon aspirants!! I have recently cleared all interviews for the QAE II position at Amazon. I would like to share about the interview process, expectations, preparation tips and the resources I referred to during my preparation. Most of the information is already present on Web/YouTube. I am giving links to all resources here. Note: I am not giving any questions from my interview as I have signed disclosure not to share. About process Before jumping into preparation, first you need to understand the hiring process. After applying, I got a call from a recruiter. He explained me the process as below - Online Assessment — Link will be shared to us, and we will have around 1 week to finish that.
Phone Interview — This is 1 hour round, in which questions will be asked on 3 aspects: 1. Test cases ; 2. Coding; 3. Leadership Principles (Preparation is same as explained for Main interview)
Main Interview — 5 different rounds — 1 hr each (Total 5hrs). Here we have option to have all rounds on same day (there will be lunch break 1hr) OR we can divide them for 2 different days Below are those 5 rounds. Not necessarily in the same order. Online test: About testing process, behavioral and situation based questions. Objective type. 1. Coding 2. Test case Enumeration & Test data preparation 3. Test Planning / Strategy 4. Debugging round 5. Leadership Principles After completion of all the above interviews, the panel will meet and decide on your candidature. Within a week, the recruiter can provide you with feedback. Apart from this, go through the previous QA interview experiences from the Leetcode discussions section. *Important — One of the rounds in the process is “Leadership Principles”, where you will be asked certain situational based questions which you need to answer based on the examples in your experience. Similar leadership principles questions, 1–2 will be asked on other 4 rounds also. Around 30% of the other 4 rounds will be focussed on leadership principles questions and remaining 70% will be actual interviews about that round (Coding, Debugging, Testcases, TestPlanning). So, Leadership Principles questions are very important when you are preparing for an Amazon interview. Preparation: 1. Coding - First I started preparing for the Coding round. I got a Leetcode subscription. The difference with Leetcode subscription is, we will have more questions and we will have company tag names to the coding questions. I filtered all “Amazon” + “Easy” programs. In that, I have excluded questions related to Trees, graph related questions. Of the remaining challenges, I started solving them daily. Most of these challenges are based on Arrays, Strings, Collections. Initially, when I had no clue on the approach, I used to see the answer on the web and tried to understand(many YouTube videos are there for each question). In that way, I have improved and could solve new problems on my own. That way I did practice around 60 easy problems from Leetcode(There are around 200+ Amazon+Easy problems in Leetcode, related to Arrays, Strings, Collections). Apart from this, I have read past Amazon QAE interview experiences on Leetcode and different websites and collected some questions(around 15) and solved them too. In Total, I have solved around 75 problems. I repeated solving them 3–4 times. It doesn’t mean that we get interview questions from leetcode / previous questions. It only gives confidence to you to solve similar questions. I have focussed only on basic concepts — Arrays, Stings, Collections(HashMaps mostly) related programs. Also, refer this video - https://www.youtube.com/watch?v=cdeoqgEUSvE&embedable=true 2. Test case Enumeration & Test data preparation Here, you may be asked to list test cases for any given scenario. Do follow the video below for the tips on how to answer. These tips are very important. https://www.youtube.com/watch?v=Xz2oHPpz2hM&embedable=true Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last) 3. Test Planning & Test Strategy Be prepared to write TestPlan / TestStrategy for any given scenario. You may be given any scenario, and will be asked to write / explain the test plan for it. Always, ask clarifying questions. https://www.guru99.com/how-to-create-test-strategy-document.html Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last). 4. Debugging round In this round, you will be given an issue / bug and you will be asked to debug it. Basically, you need to explain the steps / checks you perform to isolate the issue. This video is helpful - https://www.youtube.com/watch?v=65_8WUtwDnE&embedable=true There are some sample questions here. Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last). 5. Leadership Principles This is a very important area. Amazon has 14 leadership principles. You need to study and understand these principles. In the call with the recruiter, you will be informed if any of the 14 principles are not applicable to your role(QA). In my case, 2 are excluded. It means I need to prepare another 12 leadership principles. You will be given any situation based question and you need to answer it based on any related example in your past. Be prepared to explain it in detail with the background of the situation, what you did, how you did and results and learnings out of it. In many blogs and other experiences, it is recommended to have atleast 2 unique examples for each principle as the question may be repeated across the rounds and you should not repeat the same example/answer. Below is the great website, which helped me in understanding them, and know different types of questions based on each principle with sample answers. Take that as reference and build your own answers. https://interviewgenie.com/resources In the above page, go to this section - “The 16 Leadership Principles with Sample Questions and Answers That Get Results” That’s it for now! Please let me know if you have any doubts. Wish you all the best!! Hello Amazon aspirants!! I have recently cleared all interviews for the QAE II position at Amazon. I would like to share about the interview process, expectations, preparation tips and the resources I referred to during my preparation. Most of the information is already present on Web/YouTube. I am giving links to all resources here. Note: I am not giving any questions from my interview as I have signed disclosure not to share. About process About process Before jumping into preparation, first you need to understand the hiring process. After applying, I got a call from a recruiter. He explained me the process as below - Online Assessment — Link will be shared to us, and we will have around 1 week to finish that. Phone Interview — This is 1 hour round, in which questions will be asked on 3 aspects: 1. Test cases ; 2. Coding; 3. Leadership Principles (Preparation is same as explained for Main interview) Main Interview — 5 different rounds — 1 hr each (Total 5hrs). Here we have option to have all rounds on same day (there will be lunch break 1hr) OR we can divide them for 2 different days Online Assessment — Link will be shared to us, and we will have around 1 week to finish that. Phone Interview — This is 1 hour round, in which questions will be asked on 3 aspects: 1. Test cases ; 2. Coding; 3. Leadership Principles (Preparation is same as explained for Main interview) Main Interview — 5 different rounds — 1 hr each (Total 5hrs). Here we have option to have all rounds on same day (there will be lunch break 1hr) OR we can divide them for 2 different days Below are those 5 rounds. Not necessarily in the same order. Online test: Online test: About testing process, behavioral and situation based questions. Objective type. 1. Coding 1. Coding 2. Test case Enumeration & Test data preparation 2. Test case Enumeration & Test data preparation 3. Test Planning / Strategy 3. Test Planning / Strategy 4. Debugging round 4. Debugging round 5. Leadership Principles 5. Leadership Principles After completion of all the above interviews, the panel will meet and decide on your candidature. Within a week, the recruiter can provide you with feedback. Apart from this, go through the previous QA interview experiences from the Leetcode discussions section. *Important — One of the rounds in the process is “Leadership Principles”, where you will be asked certain situational based questions which you need to answer based on the examples in your experience. Similar leadership principles questions, 1–2 will be asked on other 4 rounds also. Around 30% of the other 4 rounds will be focussed on leadership principles questions and remaining 70% will be actual interviews about that round (Coding, Debugging, Testcases, TestPlanning). So, Leadership Principles questions are very important when you are preparing for an Amazon interview. So, Leadership Principles questions are very important when you are preparing for an Amazon interview. Preparation: Preparation: 1. Coding - 1. Coding - 1. Coding - First I started preparing for the Coding round. I got a Leetcode subscription. The difference with Leetcode subscription is, we will have more questions and we will have company tag names to the coding questions. I filtered all “Amazon” + “Easy” programs. In that, I have excluded questions related to Trees, graph related questions. Of the remaining challenges, I started solving them daily. Most of these challenges are based on Arrays, Strings, Collections. Initially, when I had no clue on the approach, I used to see the answer on the web and tried to understand(many YouTube videos are there for each question). In that way, I have improved and could solve new problems on my own. That way I did practice around 60 easy problems from Leetcode(There are around 200+ Amazon+Easy problems in Leetcode, related to Arrays, Strings, Collections). Apart from this, I have read past Amazon QAE interview experiences on Leetcode and different websites and collected some questions(around 15) and solved them too. In Total, I have solved around 75 problems. I repeated solving them 3–4 times. It doesn’t mean that we get interview questions from leetcode / previous questions. It only gives confidence to you to solve similar questions. I have focussed only on basic concepts — Arrays, Stings, Collections(HashMaps mostly) related programs. Also, refer this video - https://www.youtube.com/watch?v=cdeoqgEUSvE&embedable=true https://www.youtube.com/watch?v=cdeoqgEUSvE&embedable=true 2. Test case Enumeration & Test data preparation 2. Test case Enumeration & Test data preparation 2. Test case Enumeration & Test data preparation Here, you may be asked to list test cases for any given scenario. Do follow the video below for the tips on how to answer. These tips are very important. https://www.youtube.com/watch?v=Xz2oHPpz2hM&embedable=true https://www.youtube.com/watch?v=Xz2oHPpz2hM&embedable=true Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last) 3. Test Planning & Test Strategy 3. Test Planning & Test Strategy 3. Test Planning & Test Strategy Be prepared to write TestPlan / TestStrategy for any given scenario. You may be given any scenario, and will be asked to write / explain the test plan for it. Always, ask clarifying questions. https://www.guru99.com/how-to-create-test-strategy-document.html https://www.guru99.com/how-to-create-test-strategy-document.html Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last). 4. Debugging round 4. Debugging round 4. Debugging round In this round, you will be given an issue / bug and you will be asked to debug it. Basically, you need to explain the steps / checks you perform to isolate the issue. This video is helpful - https://www.youtube.com/watch?v=65_8WUtwDnE&embedable=true https://www.youtube.com/watch?v=65_8WUtwDnE&embedable=true There are some sample questions here . here Be prepared for 1–2 questions on leadership principles (mentioned on this topic at last). 5. Leadership Principles 5. Leadership Principles 5. Leadership Principles This is a very important area. Amazon has 14 leadership principles. 14 You need to study and understand these principles. In the call with the recruiter, you will be informed if any of the 14 principles are not applicable to your role(QA). In my case, 2 are excluded. It means I need to prepare another 12 leadership principles. You will be given any situation based question and you need to answer it based on any related example in your past. Be prepared to explain it in detail with the background of the situation, what you did, how you did and results and learnings out of it. In many blogs and other experiences, it is recommended to have atleast 2 unique examples for each principle as the question may be repeated across the rounds and you should not repeat the same example/answer. Below is the great website, which helped me in understanding them, and know different types of questions based on each principle with sample answers. Take that as reference and build your own answers. https://interviewgenie.com/resources https://interviewgenie.com/resources In the above page, go to this section - “The 16 Leadership Principles with Sample Questions and Answers That Get Results” “The 16 Leadership Principles with Sample Questions and Answers That Get Results” That’s it for now! Please let me know if you have any doubts. Wish you all the best!!

How I Cracked the Amazon QAE II Interview

Introduction If you’re a Mac user and have ever wanted to run a Python script automatically at a specific time, MacOS has a built-in tool called crontab that lets you schedule tasks to run at specified intervals. This article will guide you through the steps to set up and use crontab to schedule your Python scripts. Step 1: Edit the Crontab File To edit the crontab file, run the following command in Terminal: crontab -e Step 2: Schedule Your Python Script In the crontab file, you’ll need to add a new line that specifies when and how often your script should run. The basic syntax for a crontab entry is: * * * * * /path/to/python /path/to/your/script.py Here’s what each * represents (from left to right): Minute (0-59)
Hour (0-23)
Day of the month (1-31)
Month (1-12)
Day of the week (0-7, where 0 and 7 represent Sunday) For example, if you want your script to run every day at 7:30 AM, you would write: 30 7 * * * /usr/bin/python3 /Users/yourusername/example.py Replace /usr/bin/python3 with the actual path to your Python interpreter from running which python3 in Terminal and /Users/yourusername/example.py with the path to your script. It’s important to note that the paths don’t need to be enclosed in quotation marks. Step 3: Save and Exit After you’ve added the line to schedule your script, save the file and exit the editor. If you’re using the default editor, you can save your changes by pressing Ctrl + O, then hit Enter to confirm. Finally, press Ctrl + X to exit the editor. Verifying Your Crontab Setup If you’re new to crontab, a simple way to check if it’s working correctly is by creating a Python script that logs the current time every time it runs. Here’s how you can do it: Step 1: Create a Simple Python Script Create a script called log_test.py that writes the current date and time to a log file: import datetime

# Define the log file path
log_file_path = "/path/to/your/log_file.txt"

# Get the current time
current_time = datetime.datetime.now()

# Write the current time to the log file
with open(log_file_path, "a") as log_file:
    log_file.write(f"Script ran at: {current_time}\n") Replace "/path/to/your/log_file.txt" with the path where you want the log file to be saved. Step 2:  Test Your Script in the Terminal Before scheduling the script with crontab, it’s important to ensure that it runs correctly in the terminal. Open the Terminal and execute the following command: /usr/bin/python3 /path/to/your/log_test.py Replace /usr/bin/python3 with the path to your Python interpreter and /path/to/your/log_test.py with the path to your script. If the command runs without errors and you see a new entry in your log file, your script is ready to be scheduled. Step 3: Update and Save Your Crontab To schedule the script to run every minute, add this line to your crontab: * * * * * /usr/bin/python3 /path/to/your/log_test.py Replace /usr/bin/python3 and /path/to/your/log_test.py with the correct paths on your system. Step 4: Check the Log File After a few minutes, check the log file. If you see new timestamps, your crontab job is working! Conclusion Congratulations! You’ve now set up a Python script to run automatically on your Mac using crontab. This is a powerful way to automate tasks, from running backups to generating reports. With crontab, you can ensure your Python scripts run exactly when you need them to, without any manual intervention. Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on LinkedIn. Happy exploring!👋 Introduction If you’re a Mac user and have ever wanted to run a Python script automatically at a specific time, MacOS has a built-in tool called crontab that lets you schedule tasks to run at specified intervals. This article will guide you through the steps to set up and use crontab to schedule your Python scripts. crontab Step 1: Edit the Crontab File To edit the crontab file, run the following command in Terminal: crontab -e crontab -e Step 2: Schedule Your Python Script In the crontab file, you’ll need to add a new line that specifies when and how often your script should run. The basic syntax for a crontab entry is: * * * * * /path/to/python /path/to/your/script.py * * * * * /path/to/python /path/to/your/script.py Here’s what each * represents (from left to right): Minute (0-59) Hour (0-23) Day of the month (1-31) Month (1-12) Day of the week (0-7, where 0 and 7 represent Sunday) Minute (0-59) Minute Hour (0-23) Hour Day of the month (1-31) Day of the month Month (1-12) Month Day of the week (0-7, where 0 and 7 represent Sunday) Day of the week For example, if you want your script to run every day at 7:30 AM, you would write: 30 7 * * * /usr/bin/python3 /Users/yourusername/example.py 30 7 * * * /usr/bin/python3 /Users/yourusername/example.py Replace /usr/bin/python3 with the actual path to your Python interpreter from running which python3 in Terminal and /Users/yourusername/example.py with the path to your script. /usr/bin/python3 which python3 /Users/yourusername/example.py It’s important to note that the paths don’t need to be enclosed in quotation marks. Step 3: Save and Exit After you’ve added the line to schedule your script, save the file and exit the editor. If you’re using the default editor, you can save your changes by pressing Ctrl + O , then hit Enter to confirm. Finally, press Ctrl + X to exit the editor. Ctrl + O Enter Ctrl + X Verifying Your Crontab Setup If you’re new to crontab, a simple way to check if it’s working correctly is by creating a Python script that logs the current time every time it runs. Here’s how you can do it: Step 1: Create a Simple Python Script Create a script called log_test.py that writes the current date and time to a log file: log_test.py import datetime

# Define the log file path
log_file_path = "/path/to/your/log_file.txt"

# Get the current time
current_time = datetime.datetime.now()

# Write the current time to the log file
with open(log_file_path, "a") as log_file:
    log_file.write(f"Script ran at: {current_time}\n") import datetime

# Define the log file path
log_file_path = "/path/to/your/log_file.txt"

# Get the current time
current_time = datetime.datetime.now()

# Write the current time to the log file
with open(log_file_path, "a") as log_file:
    log_file.write(f"Script ran at: {current_time}\n") Replace "/path/to/your/log_file.txt" with the path where you want the log file to be saved. Step 2:  Test Your Script in the Terminal Before scheduling the script with crontab, it’s important to ensure that it runs correctly in the terminal. Open the Terminal and execute the following command: /usr/bin/python3 /path/to/your/log_test.py /usr/bin/python3 /path/to/your/log_test.py Replace /usr/bin/python3 with the path to your Python interpreter and /path/to/your/log_test.py with the path to your script. If the command runs without errors and you see a new entry in your log file, your script is ready to be scheduled. Step 3: Update and Save Your Crontab To schedule the script to run every minute, add this line to your crontab: * * * * * /usr/bin/python3 /path/to/your/log_test.py * * * * * /usr/bin/python3 /path/to/your/log_test.py Replace /usr/bin/python3 and /path/to/your/log_test.py with the correct paths on your system. Step 4: Check the Log File After a few minutes, check the log file. If you see new timestamps, your crontab job is working! Conclusion Congratulations! You’ve now set up a Python script to run automatically on your Mac using crontab. This is a powerful way to automate tasks, from running backups to generating reports. With crontab, you can ensure your Python scripts run exactly when you need them to, without any manual intervention. Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on LinkedIn . Happy exploring!👋 LinkedIn

Automate Python Scripts on Mac: A Step-by-Step Guide to Scheduling with Crontab

Isha Varshney with Rosette Belesi, Product Marketing Director at Opera, at OpenFi discussing "Building, Scaling & Enhancing MiniPay to Onboard African Users to Web3." Photo by Benjamin Arthur, courtesy of IdOS. During EthCC, I had a chance to catch up with Isha Varshney, Head of Ecosystem at the Celo Foundation, who has extensive experience in decentralized finance and global financial inclusion initiatives. Given the main criticism around EthCC that “there are more side events than dApps,” we focused our conversation on building for the real world and MiniPay, a Celo-based app that has seen significant success in Africa with over 3 million wallet activations across Nigeria, Ghana, Kenya, and South Africa. Isha, how are you enjoying EthCC? Any key themes you’re noticing? EthCC has been incredible. Some of the major themes revolve around Layer 2 solutions. Last Sunday, core contributors cLabs launched the Celo Layer 2testnet, Dango. It's exciting to see the momentum as Celo migrates to join the OP Stack, a modular blockchain architecture. We also participated in several events with Superchain and the OP Stack team, bringing together incredible builders. It's thrilling to see so many talented teams and individuals joining this ecosystem. What are the biggest challenges in bringing Web3 to the mainstream? Is there still a big gap? Yes and no. We're still in the early stages of Web3 and crypto. Much of the technology is highly technical and not immediately relevant to the everyday person—like my mom or friends who might not understand concepts like intents. However, these building blocks are crucial for the technology's development and interoperability. The work we're doing now is laying the foundation for the future. In about five years, we hope to abstract crypto away from everyday users, making it seamlessly integrated into their lives. We're at an exciting juncture where we're building the infrastructure that will soon bring Web3 to the mainstream. Building for users’ current needs and behaviors is a crucial component of this—and that means building for mobile devices. With roughly ¾ of the world’s population owning smartphones, far more than the population that has access to a computer, and financial activity increasingly being conducted by mobile devices, it’s necessary that we build mobile-first. This is what excites me about so many projects in the Celo ecosystem that are developing solutions to everyday challenges that users can incorporate into their daily lives. What are the key elements needed to build the next great decentralized application (dApp)? We're not thinking enough about everyday usability in this space. Interacting with crypto can be complicated and intimidating. For example, using most crypto wallets involves signing transactions and dealing with private keys, public keys, and wallet addresses, which are not exactly user-friendly. One solution to address this is SocialConnect, a primitive developed for Celo that allows users to leverage their phone numbers as their wallet addresses. This kind of simplicity is crucial. We need more technology like that to onboard the next billion users. For crypto and Web3 to go mainstream, it has to be easy and intuitive for users. When you talk to people who aren't in Web3, they often find it speculative and scary. What we need next is to remove these frictions and make it easy to understand. We're working on it and making progress in this space. MiniPay has seen amazing growth. Can you share its journey and what it does? The collaboration between Celo and Opera is fascinating. Opera, a browser with 100 million users across Africa, is pre-installed on every Android device. In Africa, Android devices are ubiquitous, and people primarily interact with technology through their phones. Opera initially gained popularity by providing some free data, which is costly in many African regions, enabling anyone to browse the internet for one or two hours daily, opening up access for many users. Celo’s ecosystem has always focused on real-world applications in these markets, so partnering with Opera was a natural fit. With their extensive distribution network, we integrated a wallet into the existing mobile Android browser used by millions, making it simple and accessible. We launched this wallet in September last year, rolling it out country by country. Starting in Nigeria, we now operate in Kenya, Ghana, Nigeria, and South Africa. We now have over 3 million users, onboarding a massive number of new users daily. The wallet is designed with a stablecoin-only interface and a user-friendly UI/UX, allowing users to sign in with their Google account, making it incredibly easy to use. Why is the stablecoin aspect important? Are stablecoins the perfect gateway to Web3? Absolutely. Stablecoins are vital because they offer a consistent value in contrast to the often volatile nature of other cryptocurrencies. In emerging economies, where local currencies can be deflationary, people are familiar with and trust the value of the US dollar. Stablecoins provide this reliability, making them an ideal entry point into Web3. They give users confidence that their money will hold its value, which is crucial in markets where per-wallet volumes aren't large and financial security is paramount. We started with the Celo Dollar (cUSD) in the wallet and recently expanded to include USDC from Circle and Tether’s USDT. The wallet's Pockets feature displays USDC, USDT, and cUSD in a simple, clean interface. Users can easily swap between these stablecoins by dragging and swapping from asset to asset—one of the only 1:1 stablecoin swap features on the market. The ease of use enhances accessibility while also bringing the experience of transacting with multiple stables to users who might be unfamiliar. What advice do you have for builders trying to create for the people? My experience with the Opera team has been incredible. They execute like no other team. They have over 1,000 ambassadors on the ground across all these markets and are constantly engaging with their ambassador network. This network helps onboard and troubleshoot with users, ensuring a smooth experience. Opera takes feedback and builds on it really well. For example, we started with only cUSD, and the feedback was that users were familiar with other stablecoins and wanted to be able to use them in MiniPay. So, we added those to the product, meeting users where they are. That's my message to builders: meet people where they are. If they're familiar with something, leverage that. It's already challenging enough, so let's not reinvent the wheel. With Celo, from day one, we've built for real-world use cases. Every step of the way, we've focused on building for practical applications, like microcredit in emerging markets with EthicHub or Haraka. We're committed to meeting users where they are and will continue to do so with MiniPay and all other projects. What’s one app you’d really like to see built next? Hmm, that’s a good one! I would love to see an all-in-one app similar to WeChat in China, which covers everything from payments to utilities. MiniPay is moving towards that vision for Africa with the inclusion of a Discover Page for the growing roster of integrated dApps. Imagine a single platform where you can handle all your needs using stablecoins or a corporate-backed currency. For instance, as frequent travelers, we constantly switch SIM cards. What if we could abstract that concept, not just for SIM cards but for all forms of payment? It would be fantastic to have a seamless payment experience, no matter where you are. If I’m in Brussels and from New York, I should be able to pay for everything with the same app. It would make managing finances and daily activities so much simpler and more convenient. Isha Varshney with Rosette Belesi, Product Marketing Director at Opera, at OpenFi discussing "Building, Scaling & Enhancing MiniPay to Onboard African Users to Web3." Photo by Benjamin Arthur, courtesy of IdOS. Isha Varshney with Rosette Belesi, Product Marketing Director at Opera, at OpenFi discussing "Building, Scaling & Enhancing MiniPay to Onboard African Users to Web3." Photo by Benjamin Arthur , courtesy of IdOS. Benjamin Arthur During EthCC, I had a chance to catch up with Isha Varshney, Head of Ecosystem at the Celo Foundation, who has extensive experience in decentralized finance and global financial inclusion initiatives. Given the main criticism around EthCC that “there are more side events than dApps,” we focused our conversation on building for the real world and MiniPay, a Celo-based app that has seen significant success in Africa with over 3 million wallet activations across Nigeria, Ghana, Kenya, and South Africa. During EthCC, I had a chance to catch up with Isha Varshney, Head of Ecosystem at the Celo Foundation, who has extensive experience in decentralized finance and global financial inclusion initiatives. Given the main criticism around EthCC that “there are more side events than dApps,” we focused our conversation on building for the real world and MiniPay, a Celo-based app that has seen significant success in Africa with over 3 million wallet activations across Nigeria, Ghana, Kenya, and South Africa. During EthCC, I had a chance to catch up with Isha Varshney , Head of Ecosystem at the Celo Foundation , who has extensive experience in decentralized finance and global financial inclusion initiatives. Given the main criticism around EthCC that “there are more side events than dApps,” we focused our conversation on building for the real world and MiniPay , a Celo-based app that has seen significant success in Africa with over 3 million wallet activations across Nigeria, Ghana, Kenya, and South Africa. Isha Varshney Isha Varshney Celo Foundation Celo Foundation MiniPay MiniPay over 3 million wallet activations over 3 million wallet activations Isha, how are you enjoying EthCC? Any key themes you’re noticing? Isha, how are you enjoying EthCC? Any key themes you’re noticing? EthCC has been incredible. Some of the major themes revolve around Layer 2 solutions. Last Sunday, core contributors cLabs launched the Celo Layer 2testnet, Dango. It's exciting to see the momentum as Celo migrates to join the OP Stack, a modular blockchain architecture. We also participated in several events with Superchain and the OP Stack team, bringing together incredible builders. It's thrilling to see so many talented teams and individuals joining this ecosystem. What are the biggest challenges in bringing Web3 to the mainstream? Is there still a big gap? Yes and no. We're still in the early stages of Web3 and crypto. Much of the technology is highly technical and not immediately relevant to the everyday person—like my mom or friends who might not understand concepts like intents. However, these building blocks are crucial for the technology's development and interoperability. The work we're doing now is laying the foundation for the future. In about five years, we hope to abstract crypto away from everyday users, making it seamlessly integrated into their lives. We're at an exciting juncture where we're building the infrastructure that will soon bring Web3 to the mainstream. Building for users’ current needs and behaviors is a crucial component of this—and that means building for mobile devices. With roughly ¾ of the world’s population owning smartphones, far more than the population that has access to a computer, and financial activity increasingly being conducted by mobile devices, it’s necessary that we build mobile-first. This is what excites me about so many projects in the Celo ecosystem that are developing solutions to everyday challenges that users can incorporate into their daily lives. What are the key elements needed to build the next great decentralized application (dApp)? We're not thinking enough about everyday usability in this space. Interacting with crypto can be complicated and intimidating. For example, using most crypto wallets involves signing transactions and dealing with private keys, public keys, and wallet addresses, which are not exactly user-friendly. One solution to address this is SocialConnect, a primitive developed for Celo that allows users to leverage their phone numbers as their wallet addresses. This kind of simplicity is crucial. We need more technology like that to onboard the next billion users. For crypto and Web3 to go mainstream, it has to be easy and intuitive for users. When you talk to people who aren't in Web3, they often find it speculative and scary. What we need next is to remove these frictions and make it easy to understand. We're working on it and making progress in this space. MiniPay has seen amazing growth. Can you share its journey and what it does? The collaboration between Celo and Opera is fascinating. Opera, a browser with 100 million users across Africa, is pre-installed on every Android device. In Africa, Android devices are ubiquitous, and people primarily interact with technology through their phones. Opera initially gained popularity by providing some free data, which is costly in many African regions, enabling anyone to browse the internet for one or two hours daily, opening up access for many users. Celo’s ecosystem has always focused on real-world applications in these markets, so partnering with Opera was a natural fit. With their extensive distribution network, we integrated a wallet into the existing mobile Android browser used by millions, making it simple and accessible. We launched this wallet in September last year, rolling it out country by country. Starting in Nigeria, we now operate in Kenya, Ghana, Nigeria, and South Africa. We now have over 3 million users, onboarding a massive number of new users daily. The wallet is designed with a stablecoin-only interface and a user-friendly UI/UX, allowing users to sign in with their Google account, making it incredibly easy to use. Why is the stablecoin aspect important? Are stablecoins the perfect gateway to Web3? Absolutely. Stablecoins are vital because they offer a consistent value in contrast to the often volatile nature of other cryptocurrencies. In emerging economies, where local currencies can be deflationary, people are familiar with and trust the value of the US dollar. Stablecoins provide this reliability, making them an ideal entry point into Web3. They give users confidence that their money will hold its value, which is crucial in markets where per-wallet volumes aren't large and financial security is paramount. We started with the Celo Dollar (cUSD) in the wallet and recently expanded to include USDC from Circle and Tether’s USDT. The wallet's Pockets feature displays USDC, USDT, and cUSD in a simple, clean interface. Users can easily swap between these stablecoins by dragging and swapping from asset to asset—one of the only 1:1 stablecoin swap features on the market. The ease of use enhances accessibility while also bringing the experience of transacting with multiple stables to users who might be unfamiliar. Pockets feature Pockets feature What advice do you have for builders trying to create for the people? My experience with the Opera team has been incredible. They execute like no other team. They have over 1,000 ambassadors on the ground across all these markets and are constantly engaging with their ambassador network. This network helps onboard and troubleshoot with users, ensuring a smooth experience. Opera takes feedback and builds on it really well. For example, we started with only cUSD, and the feedback was that users were familiar with other stablecoins and wanted to be able to use them in MiniPay. So, we added those to the product, meeting users where they are. That's my message to builders: meet people where they are. If they're familiar with something, leverage that. It's already challenging enough, so let's not reinvent the wheel. With Celo, from day one, we've built for real-world use cases. Every step of the way, we've focused on building for practical applications, like microcredit in emerging markets with EthicHub or Haraka . We're committed to meeting users where they are and will continue to do so with MiniPay and all other projects. EthicHub EthicHub Haraka Haraka What’s one app you’d really like to see built next? Hmm, that’s a good one! I would love to see an all-in-one app similar to WeChat in China, which covers everything from payments to utilities. MiniPay is moving towards that vision for Africa with the inclusion of a Discover Page for the growing roster of integrated dApps. Imagine a single platform where you can handle all your needs using stablecoins or a corporate-backed currency. For instance, as frequent travelers, we constantly switch SIM cards. What if we could abstract that concept, not just for SIM cards but for all forms of payment? It would be fantastic to have a seamless payment experience, no matter where you are. If I’m in Brussels and from New York, I should be able to pay for everything with the same app. It would make managing finances and daily activities so much simpler and more convenient.

Successful dApps Make Web3 Invisible to Users, Says Celo’s Isha Varshney

সফল dApps Web3 ব্যবহারকারীদের কাছে অদৃশ্য করে তোলে, সেলোর ইশা ভার্শনি বলেছেন

Erfolgreiche dApps machen Web3 für Benutzer unsichtbar, sagt Isha Varshney von Celo

Las dApps exitosas hacen que Web3 sea invisible para los usuarios, dice Isha Varshney de Celo

Les dApps réussies rendent le Web3 invisible pour les utilisateurs, déclare Isha Varshney de Celo

सेलो की ईशा वार्ष्णेय का कहना है कि सफल dApps वेब3 को उपयोगकर्ताओं के लिए अदृश्य बना देते हैं

CeloのIsha Varshney氏は、成功したdAppsはWeb3をユーザーから見えなくする、と語る

Celo의 Isha Varshney는 성공적인 dApp으로 인해 Web3가 사용자에게 보이지 않게 된다고 말합니다.

DApps bem-sucedidos tornam a Web3 invisível para os usuários, afirma Isha Varshney da Celo

Успешные dApps делают Web3 невидимым для пользователей, говорит Иша Варшни из Celo

Celo'dan Isha Varshney, Başarılı dApp'lerin Web3'ü Kullanıcılara Görünmez Hale Getirdiğini Söyledi

Isha Varshney của Celo cho biết các dApp thành công khiến Web3 trở nên vô hình đối với người dùng

Celo 的 Isha Varshney 表示，成功的 dApp 让 Web3 对用户来说变得不可见

Deep Neural Networks to Detect and Quantify Lymphoma Lesions: Results

ডিপ নিউরাল নেটওয়ার্ক লিম্ফোমা ক্ষত সনাক্ত এবং পরিমাপ করতে: ফলাফল

Tiefe neuronale Netzwerke zur Erkennung und Quantifizierung von Lymphomläsionen: Ergebnisse

Redes neuronales profundas para detectar y cuantificar lesiones de linfoma: resultados

Réseaux de neurones profonds pour détecter et quantifier les lésions de lymphome : résultats

लिम्फोमा घावों का पता लगाने और मात्रा निर्धारित करने के लिए डीप न्यूरल नेटवर्क: परिणाम

リンパ腫病変を検出し定量化するディープニューラルネットワーク：結果

림프종 병변을 탐지하고 정량화하기 위한 심층 신경망: 결과

Redes Neurais Profundas para Detectar e Quantificar Lesões de Linfoma: Resultados

Глубокие нейронные сети для обнаружения и количественной оценки поражений лимфомой: результаты

Lenfoma Lezyonlarını Tespit Etmek ve Ölçmek İçin Derin Sinir Ağları: Sonuçlar

Mạng lưới thần kinh sâu để phát hiện và định lượng tổn thương ung thư hạch: Kết quả

深度神经网络检测和量化淋巴瘤病变：结果

"How Many Colors Can the Human Eye See?": The Application

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com;
(2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com;
(3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction
Problem Setup and Related Work
HyperTransformer
Experiments
Conclusion and References
A Example of a Self-Attention Mechanism For Supervised Learning
B Model Parameters
C Additional Supervised Experiments
D Dependence On Parameters and Ablation Studies
E Attention Maps of Learned Transformer Models
F Visualization of The Generated CNN Weights
G Additional Tables and Figures C ADDITIONAL SUPERVISED EXPERIMENTS While the advantage of decoupling parameters of the weight generator and the generated CNN model is expected to vanish with the growing CNN model size, we compared our approach to two other methods, LGM-Net (Li et al., 2019b) and LEO (Rusu et al., 2019), to verify that our approach can match their performance on sufficiently large models. For our comparison with the LGM-Net method, we used the same image augmentation technique that was used in Li et al. (2019b) where it was applied both at the training and the evaluation stages (Ma, 2019). We also used the same CNN architecture with 4 learned 64-channel convolutional layers followed by two generated convolutional layers and the final logits layer. In our weight generator, we used 2-layer transformers with local feature extractors that relied on 48-channel convolutional layers and did not use any global features. We trained our model in the end-to-end fashion on the MINIIMAGENET 1-shot-5-way task and obtained a test accuracy of 69.3% ± 0.3% almost identical to the 69.1% accuracy reported in Li et al. (2019b). We also carried out a comparison with LEO by using our method to generate a fully-connected layer on top of the TIEREDIMAGENET embeddings pre-computed with a WideResNet-28 model employed by Rusu et al. (2019). For our experiments, we used a simpler 1-layer transformer model with 2 heads that did not have the final fully-connected layer and nonlinearity. We also used L2 regularization of the generated fully-connected weights setting the regularization weight to 10−3. As a result of training this model, we obtained 66.2% ± 0.2% and 81.6% ± 0.2% test accuracies on the 1-shot-5-way and 5-shot-5-way TIEREDIMAGENET tasks correspondingly. These results are almost identical to 66.3% and 81.4% accuracies reported in Rusu et al. (2019). This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. This paper is available on arxiv under CC 4.0 license. Authors: (1) Andrey Zhmoginov, Google Research & {azhmogin,sandler,mxv}@google.com; (2) Mark Sandler, Google Research & {azhmogin,sandler,mxv}@google.com; (3) Max Vladymyrov, Google Research & {azhmogin,sandler,mxv}@google.com. Table of Links Abstract and Introduction Problem Setup and Related Work HyperTransformer Experiments Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights G Additional Tables and Figures Abstract and Introduction Abstract and Introduction Problem Setup and Related Work Problem Setup and Related Work HyperTransformer HyperTransformer Experiments Experiments Conclusion and References Conclusion and References A Example of a Self-Attention Mechanism For Supervised Learning A Example of a Self-Attention Mechanism For Supervised Learning B Model Parameters B Model Parameters C Additional Supervised Experiments C Additional Supervised Experiments D Dependence On Parameters and Ablation Studies D Dependence On Parameters and Ablation Studies E Attention Maps of Learned Transformer Models E Attention Maps of Learned Transformer Models F Visualization of The Generated CNN Weights F Visualization of The Generated CNN Weights G Additional Tables and Figures G Additional Tables and Figures C ADDITIONAL SUPERVISED EXPERIMENTS While the advantage of decoupling parameters of the weight generator and the generated CNN model is expected to vanish with the growing CNN model size, we compared our approach to two other methods, LGM-Net (Li et al., 2019b) and LEO (Rusu et al., 2019), to verify that our approach can match their performance on sufficiently large models. For our comparison with the LGM-Net method, we used the same image augmentation technique that was used in Li et al. (2019b) where it was applied both at the training and the evaluation stages (Ma, 2019). We also used the same CNN architecture with 4 learned 64-channel convolutional layers followed by two generated convolutional layers and the final logits layer. In our weight generator, we used 2-layer transformers with local feature extractors that relied on 48-channel convolutional layers and did not use any global features. We trained our model in the end-to-end fashion on the MINIIMAGENET 1-shot-5-way task and obtained a test accuracy of 69.3% ± 0.3% almost identical to the 69.1% accuracy reported in Li et al. (2019b). We also carried out a comparison with LEO by using our method to generate a fully-connected layer on top of the TIEREDIMAGENET embeddings pre-computed with a WideResNet-28 model employed by Rusu et al. (2019). For our experiments, we used a simpler 1-layer transformer model with 2 heads that did not have the final fully-connected layer and nonlinearity. We also used L2 regularization of the generated fully-connected weights setting the regularization weight to 10−3. As a result of training this model, we obtained 66.2% ± 0.2% and 81.6% ± 0.2% test accuracies on the 1-shot-5-way and 5-shot-5-way TIEREDIMAGENET tasks correspondingly. These results are almost identical to 66.3% and 81.4% accuracies reported in Rusu et al. (2019).

HyperTransformer: C Additional Supervised Experiments

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. Table of Links Abstract & Introduction Abstraction and Reasoning Corpus (ARC) Related Work Object-centric Models for ARC Grids MDL-based Model Learning Evaluation Conclusion and Perspectives, References & Supplementary Materials 2 Abstraction and Reasoning Corpus (ARC) ARC is a collection of tasks3 , where each task is made of training examples (3.3 on average) and test examples (1 in general). Each example is made of an input grid and an output grid. Each grid is a 2D array (with size up to 30x30) filled with integers coding for colors (10 distinct colors). For a given task, the size of grids can vary from one example to another, and between the input and the output. Each task is a machine learning problem, whose goal is to learn a model that can generate the output grid from the input grid, and so from a few training examples only. Prediction is successful only if the predicted output grid is strictly equal to the expected grid for all test examples, there is no partial success. However, three trials are allowed for each test example to compensate for potential ambiguities in the training examples. Figure 1 shows two ARC tasks (with the expected test output grid missing). The first is used as a running example in this paper. We now more formally define grids, examples, and tasks. ARC tasks have 3.3 training examples on average, and 1 or 2 test examples (most often 1). As illustrated by Figure 1, the different input grids of a task need not have the same size, nor use the same colors. The same applies to test grids. ARC is composed of 1000 tasks in total: 400 “training tasks”4 , 400 evaluation tasks, and 200 secret tasks for independent evaluation. Figure 1 shows two of the 400 training tasks. Developers should only look at the training tasks, not at the evaluation tasks. The latter should only be used to evaluate the broad generalization capability of the developed systems. This paper is available on Arxiv under CC 4.0 license. This paper is available on arxiv under CC 4.0 license. Authors: (1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Sebastien Ferr ´e, Univ Rennes, CNRS, Inria, IRISA Campus de Beaulieu, 35042 Rennes, France and ferre@irisa.fr. Table of Links Abstract & Introduction Abstract & Introduction Abstraction and Reasoning Corpus (ARC) Abstraction and Reasoning Corpus (ARC) Related Work Related Work Object-centric Models for ARC Grids Object-centric Models for ARC Grids MDL-based Model Learning MDL-based Model Learning Evaluation Evaluation Conclusion and Perspectives, References & Supplementary Materials Conclusion and Perspectives, References & Supplementary Materials 2 Abstraction and Reasoning Corpus (ARC) ARC is a collection of tasks3 , where each task is made of training examples (3.3 on average) and test examples (1 in general). Each example is made of an input grid and an output grid. Each grid is a 2D array (with size up to 30x30) filled with integers coding for colors (10 distinct colors). For a given task, the size of grids can vary from one example to another, and between the input and the output. Each task is a machine learning problem, whose goal is to learn a model that can generate the output grid from the input grid, and so from a few training examples only. Prediction is successful only if the predicted output grid is strictly equal to the expected grid for all test examples, there is no partial success. However, three trials are allowed for each test example to compensate for potential ambiguities in the training examples. Figure 1 shows two ARC tasks (with the expected test output grid missing). The first is used as a running example in this paper. We now more formally define grids, examples, and tasks. ARC tasks have 3.3 training examples on average, and 1 or 2 test examples (most often 1). As illustrated by Figure 1, the different input grids of a task need not have the same size, nor use the same colors. The same applies to test grids. ARC is composed of 1000 tasks in total: 400 “training tasks”4 , 400 evaluation tasks, and 200 secret tasks for independent evaluation. Figure 1 shows two of the 400 training tasks. Developers should only look at the training tasks, not at the evaluation tasks. The latter should only be used to evaluate the broad generalization capability of the developed systems. This paper is available on Arxiv under CC 4.0 license. Arxiv Arxiv

The Definition of Abstraction and Reasoning Corpus (ARC): A Beginner's Lesson

Designed for developers familiar with Azure and generative AI, the guide walks you through the process of harnessing the power of the gpt turbo model for code generation. Introduction The Microsoft team has recently launched an challenge in which a developer can learn how to build Azure AI solutions and apps. Open AI Prerequisite Experience working with Azure and Azure portals. An understanding of generative AI. Experience in one high-level programming language like C# or Python Steps to Create Open AI Service on Azure with “Dall-E” model deployed. Day 1 — Azure Open AI Challenge If you would like to explore image generation, follow this link Day 2 — Azure Open AI Challenge: Image Generation Getting Started Considering Azure Open AI Service is running on the Azure portal and the gpt-turbo model is deployed successfully. Step 1: Create a console application To test image generation, create a console application in Visual Studio or Visual Studio Code. dotnet new console Step 2: Read the configuration Read the configuration from appsettings.json file // Build a config object and retrieve user settings.
    IConfiguration config = new ConfigurationBuilder()
        .AddJsonFile("appsettings.json")
        .Build();
    string? oaiEndpoint = config["AzureOAIEndpoint"];
    string? oaiKey = config["AzureOAIKey"];
    string? oaiDeploymentName = config["AzureOAIDeploymentName"]; Step 3: Add sample code Create a file under the console application project as follows: sample-code> function > function.cs namespace Function
    {
        class Program
        {
            int AbsoluteSquare(int num1, int num2)
            {
                int result = Math.Abs(num1 - num2);
                result *= result;
                return result;
            }
        }
    } Another file as sample-code > go-fish > go-fish.cs => Reference file Step 3: Prepare Console Menu The next step is to prepare a menu on the console application using digits. If the console message is “quit” the console application is exited. If the console input is 1 or 2, then the sample file function.cs is used If the console input is 3, then the sample file go-fish.cs is used Else it will return a console message saying invalid input do
    {
        Console.WriteLine("\n1: Add comments to my function\n" +
        "2: Write unit tests for my function\n" +
        "3: Fix my Go Fish game\n" +
        "\"quit\" to exit the program\n\n" +
        "Enter a number to select a task:");
    
        command = Console.ReadLine() ?? "";
    
        if (command == "quit")
        {
            Console.WriteLine("Exiting program...");
            break;
        }
    
        Console.WriteLine("\nEnter a prompt: ");
        string userPrompt = Console.ReadLine() ?? "";
        string codeFile = "";
    
        if (command == "1" || command == "2")
            codeFile = System.IO.File.ReadAllText($@"{AppDomain.CurrentDomain.BaseDirectory}sample-code\function\function.cs");
        else if (command == "3")
            codeFile = System.IO.File.ReadAllText($@"{AppDomain.CurrentDomain.BaseDirectory}sample-code\go-fish\go-fish.cs");
        else
        {
            Console.WriteLine("Invalid input. Please try again.");
            continue;
        }
    
        userPrompt += codeFile;
        await GetResponseFromOpenAI(userPrompt);
    } while (true); Step 4: Code generation from AI Please find below the method GetResponseFromOpenAI, which generates the code using gpt-turbo. Read the configuration values required, if not present don’t execute. Prepare the request for chat completion response. Finally, write the response back to result > app.txt file async Task GetResponseFromOpenAI(string prompt)
    {
        Console.WriteLine("\nCalling Azure OpenAI to generate code...\n\n");
    
        if (string.IsNullOrEmpty(oaiEndpoint) || string.IsNullOrEmpty(oaiKey) || string.IsNullOrEmpty(oaiDeploymentName))
        {
            Console.WriteLine("Please check your appsettings.json file for missing or incorrect values.");
            return;
        }
    
        // Configure the Azure OpenAI client
        OpenAIClient client = new OpenAIClient(new Uri(oaiEndpoint), new AzureKeyCredential(oaiKey));
    
        // Define chat prompts
        string systemPrompt = "You are a helpful AI assistant that helps programmers write code.";
        string userPrompt = prompt;
    
        // Format and send the request to the model
        var chatCompletionsOptions = new ChatCompletionsOptions()
        {
            Messages =
            {
                new ChatRequestSystemMessage(systemPrompt),
                new ChatRequestUserMessage(userPrompt)
            },
            Temperature = 0.7f,
            MaxTokens = 1000,
            DeploymentName = oaiDeploymentName
        };
    
        // Get response from Azure OpenAI
        Response<ChatCompletions> response = await client.GetChatCompletionsAsync(chatCompletionsOptions);
    
        ChatCompletions completions = response.Value;
        string completion = completions.Choices[0].Message.Content;
    
        // Write full response to console, if requested
        if (printFullResponse)
        {
            Console.WriteLine($"\nFull response: {JsonSerializer.Serialize(completions, new JsonSerializerOptions { WriteIndented = true })}\n\n");
        }
    
        // Write the file.
        System.IO.File.WriteAllText(@"result\app.txt", completion);
    
        // Write response to console
        Console.WriteLine($"\nResponse written to result/app.txt\n\n");
    } Test Case 1: Add comments to the code Choose option 1 Then add the following prompt to add comments to the code Add comments to the following function. Return only the commented code. Output Test Case 1 Refer to the sample on . function.cs file GitHub Please find below the convert function with the single line comments added as shown below. // This function calculates the absolute square of the difference between two numbers
    
    namespace Function
    {
        class Program
        {
            // Function to calculate the absolute square of the difference between two numbers
            int AbsoluteSquare(int num1, int num2)
            {
                // Calculate the absolute difference between the two numbers
                int result = Math.Abs(num1 - num2);
    
                // Square the result
                result *= result;
    
                // Return the absolute square of the difference between the two numbers
                return result;
            }
        }
    } Additionally, the user can suggest gpt model to add multi-line comments instead of single lines using the following prompt Add comments to the following function. Return only the commented code. — namespace Function
    {
        class Program
        {
            // This function calculates the absolute square of the difference between two integers.
            // Parameters:
            //   num1: the first integer
            //   num2: the second integer
            // Returns:
            //   The absolute square of the difference between num1 and num2
            int AbsoluteSquare(int num1, int num2)
            {
                int result = Math.Abs(num1 - num2);
                result *= result;
                return result;
            }
        }
    } Test Case 2: Add comments to the code Choose option 2 Then add the following prompt to add comments to the code Write four unit tests for the following function. — Output Test Case 2 Refer to the sample on . Please find below the test cases added function.cs file GitHub Sure! Here are four unit tests for the `AbsoluteSquare` function:
    
    1. Test case where `num1` is greater than `num2`:
    
    [Test]
    public void TestAbsoluteSquare_GreaterNum1_ReturnsSquaredDifference()
    {
        int num1 = 5;
        int num2 = 2;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    2. Test case where `num2` is greater than `num1`:
    
    [Test]
    public void TestAbsoluteSquare_GreaterNum2_ReturnsSquaredDifference()
    {
        int num1 = 2;
        int num2 = 5;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    3. Test case where `num1` and `num2` are the same:
    
    [Test]
    public void TestAbsoluteSquare_SameNumbers_ReturnsZero()
    {
        int num1 = 4;
        int num2 = 4;
        int expected = 0;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    }
    
    
    4. Test case where `num1` and `num2` are negative:
    
    [Test]
    public void TestAbsoluteSquare_NegativeNumbers_ReturnsSquaredDifference()
    {
        int num1 = -3;
        int num2 = -6;
        int expected = 9;
        int result = Function.Program.AbsoluteSquare(num1, num2);
        Assert.AreEqual(expected, result);
    } Test Case 3: Fix my Go Fish game Choose option 3 Then add the following prompt to add comments to the code Fix the code below for an app to play Go Fish with the user. Return only the corrected code. — Output Test Case 3 Refer to the sample on . go-fish.cs file GitHub Please find below the code that is fixed. using System;  
    using System.Collections.Generic;  
    using System.Linq;  
      
    namespace GoFish  
    {  
        class Program  
        {  
            static void Main(string[] args)  
            {  
                // Define the deck of cards  
                List<string> deck = new List<string> { "A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K" };  
                deck.AddRange(deck);  
                deck.AddRange(deck);  
                deck.AddRange(deck);  
      
                // Shuffle the deck  
                var rand = new Random();  
                deck = deck.OrderBy(x => rand.Next()).ToList();  
      
                // Deal the cards  
                List<string> playerHand = deck.Take(5).ToList();  
                List<string> computerHand = deck.Skip(5).Take(5).ToList();  
      
                // Define the initial score  
                int playerScore = 0;  
                int computerScore = 0;  
      
                // Define the main game loop  
                while (deck.Count > 0)  
                {  
                    // Print the player's hand  
                    Console.WriteLine("Your hand: " + string.Join(", ", playerHand));  
      
                    // Ask the player for a card  
                    Console.Write("Do you have any... ");  
                    string card = Console.ReadLine();  
      
                    // Check if the player has the card  
                    if (playerHand.Contains(card))  
                    {  
                        // Remove the card from the player's hand  
                        playerHand.Remove(card);  
      
                        // Add a point to the player's score  
                        playerScore += 1;  
      
                        // Print the player's score  
                        Console.WriteLine("You got a point!");  
                        Console.WriteLine("Your score: " + playerScore);  
                    }  
                    else  
                    {  
                        // Go fish!  
                        Console.WriteLine("Go fish!");  
      
                        // Draw a card from the deck  
                        string drawnCard = deck.First();  
                        deck.RemoveAt(0);  
      
                        // Add the card to the player's hand  
                        playerHand.Add(drawnCard);  
      
                        // Print the card that was drawn  
                        Console.WriteLine("You drew a " + drawnCard);  
                    }  
      
                    // Check if the player has won  
                    if (playerScore == 5)  
                    {  
                        Console.WriteLine("You win!");  
                        break;  
                    }  
      
                    // Computer's turn  
                    string computerCard = computerHand[rand.Next(computerHand.Count)];  
                    Console.WriteLine("Do you have any " + computerCard + "?");  
                    if (playerHand.Contains(computerCard))  
                    {  
                        // Remove the card from the player's hand  
                        playerHand.Remove(computerCard);  
      
                        // Add a point to the computer's score  
                        computerScore += 1;  
      
                        // Print the computer's score  
                        Console.WriteLine("The computer got a point!");  
                        Console.WriteLine("Computer score: " + computerScore);  
                    }  
                    else  
                    {  
                        // Go fish!  
                        Console.WriteLine("The computer goes fishing!");  
      
                        // Draw a card from the deck  
                        string drawnCard = deck.First();  
                        deck.RemoveAt(0);  
      
                        // Add the card to the computer's hand  
                        computerHand.Add(drawnCard);  
      
                        // Print the card that was drawn  
                        Console.WriteLine("The computer drew a " + drawnCard);  
                    }  
      
                    // Check if the computer has won  
                    if (computerScore == 5)  
                    {  
                        Console.WriteLine("The computer wins!");  
                        break;  
                    }  
                }  
            }  
        }  
    } Finally, if you type quit, the console application will be terminated. Complete code on GitHub Make sure to give it a star on GitHub and provide feedback on how to improve the tool further..!! ssukhpinder/AzureOpenAI C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

Taking the Azure Open AI Challenge, Day 3: Mastering Code Generation

This paper is available on arxiv under CC 4.0 license. Authors: (1) Ali Ghanbari, Dept. of Computer Science, Iowa State University; (2) Deepak-George Thomas, Dept. of Computer Science, Iowa State University; (3) Muhammad Arbab Arshad, Dept. of Computer Science, Iowa State University; (4) Hridesh Rajan, Dept. of Computer Science, Iowa State University. Table of Links Abstract & Introduction Background Motivating Example Proposed Approach Supported DNN Bugs Evaluation Threats to Validity Related Work Conclusion, Acknowledgments & References IV. PROPOSED APPROACH Our technique deepmufl comprises four components: (1) mutation generator, (2) test case splitter, (3) mutation executor/tester, and (4) suspiciousness calculator. Figure 2 depicts these components as processes, numbered accordingly, taking inputs and producing outputs. Mutation generator (marked ⃝1 in Figure 2), applies 79 mutators on all the layers of the input buggy DNN, so as to generate a pool of mutants, i.e., variants of the original, buggy DNN model with small perturbations, e.g., replacing activation function of a layer. Test case splitter (marked ⃝2 in the figure), applies the original buggy DNN on a given set of test data points, i.e., test cases (or input values) paired with their expected output values, so as to partition the set into two subset, namely passing test cases and failing test cases. Passing test cases are referred to as those input values for which the expected output matches that of produced by the original model, whereas failing test cases are referred to as those input values for which the expected output does not match that of produced by the model. This component also stores the output of the original model on each of the test cases. Next, mutation executor (which is also called mutation tester, marked ⃝3 in the figure) applies the generated mutants on each of the passing and failing test cases and the results are compared to that of the original model recorded in the previous step. This amounts to a mutation execution matrix that is used to calculate suspiciousness values for each layer in the model (marked ⃝4 in the figure). The user may instruct deepmufl to use a specific fault localization formula, e.g., MUSE or Metallaxis with SBI or Ochiai, for calculating suspiciousness values. The layers are then ranked based on the calculated suspiciousness values for user inspection. The ranked list is accompanied with the information about the mutations conducted on each layer to facilitate debugging. A. Mutation Generator Mutation generator component receives the original, buggy DNN model and generates as many variants of the model, i.e., mutants, as possible, by systematically mutating every elements of the input model. This component implements 79 mutators. Mutators can be viewed as transformation operators that when applied to a given element, e.g., a neuron or a layer, in the model, returns a new variants of the model with that particular element mutated. Table 2 lists all the mutators implemented in deepmufl, the types of model elements on which they can operate, and the way each mutator affects the target element. These mutators are inspired by the ones implemented in the existing mutation analysis systems, e.g., [27], [28], [29], [49], [50], [51], [52], [53], to name a few. Ma et al. [29], and Hu et al. [28], define so-called model-level mutators that also operate on pre-trained models. Direct reuse of all of their mutators was not possible, as those mutators depend on random values which would introduce a source of nondeterminism in deepmufl: mutating the same model element with random values, e.g., Gaussian fuzzing, as in [29], would yield a different mutant each time, making deepmufl to produce different outputs on each run for the same model. In general, as far as MBFL is concerned, using variable values (whether it is deteministic or not), instead of the current hard-coded ones, for mutation of weights would not bring about any benefit, as the goal here is to break the model in some way and observe its impact on originally failing and passing test cases. We argue that not all model bugs could be emulated using mutators at the level of pre-trained models, e.g., missing batch normalization, but the mutators listed in Table 2 are sufficient for emulating a subset of such bugs, e.g., wrong activation function or missing/redundant layer. Please see §V for a more detailed discussion on supported bugs. Mutation generation in deepmufl is done directly on the trained model and there is no need for retraining the model. This makes deepmufl quite fast and perhaps more attractive from a practical point of view. However, this comes with a risk of not being traceable, i.e., a mutation on pre-trained .h5 model does not directly correspond to a line of source code for the user to inspect. In the Keras programs that we studied, this limitation was mitigated by the fact that the models with Sequential architecture were implemented using a wellunderstood structure and mapping layer numbers/identifiers in deepmufl’s reports to source code was trivial. In a future work, with the help of simple auto-generated annotations, e.g., for lexical scoping of the code snippet for model declaration, we will extend deepmufl to automatically map layer numbers/identifiers in its reports to actual lines of source code. Humbatova et al. [27] argue about the importance of mutators emulating real DNN faults. We acknowledge that mutators emulating real faults would help generating more informative reports that would also give hints on how to fix the program. However, unlike mutation analysis, the main objective of an MBFL technique is to assign suspiciousness values to the program elements which can, in theory, be done using any kind of mutator, whether or not it makes sense from the standpoint of a developer. It is worth noting that the alternative design decision of using DeepCrime [27] as a mutation generation engine for deepmufl would result in finding more bugs than the current version of deepmufl, e.g., bugs related to training hyper-parameters or training dataset, but such a design is expected to be impacted by the nondeterminacy inherent in training process and, given the fact that we do not employ any training data selection, would be significantly slower due to numerous re-training. Nevertheless, finding more bugs would be an incentive for exploring this alternative as a future work. B. Test Case Splitter Before we introduce this component, we need to clarify certain terminology. .** Definition 1 A data point in a testing dataset for a DNN model is defined to be a pair of the form (I, O), where I ∈ R m and O ∈ R n, with m and n being positive integers. In this paper I is called test case, test input, or input, while O is called expected output or ground-truth value. Given a test dataset, test case splitter component applies the original model on each of the test cases for the data points and checks if the model output matches to the expected output. If the two outputs match, then the corresponding test case will be marked as passing, otherwise it will be marked as failing. This component also records the output produced by the original model to be used during impact analysis, described below. C. Mutation Executor (Mutation Tester) We start describing this component with a definition. Definition 2. A mutation execution matrix E is a k×l matrix, where k is the number of generated mutants, while l is the number of test cases. Each element Ei,j in the matrix is a member of the set {✓, ✗, ❍}, wherein ✓ indicates that the i th mutant impacts j th test case, whereas ✗ indicates that the mutant does not affect the test case. ❍ denotes a nonviable mutant, i.e., a mutant that fails when loading or applying it on a test case. Such mutants might be generated, e.g., due to creating a shape error [32] after the mutation. Mutation executor component construct mutation execution matrix by applying each of the generated mutants (see §IV-A) on the failing and passing test cases to determine which of the test cases are impacted by which mutants. The impact of mutation on test cases is measured using two types of impacts, i.e., type 1 impact and type 2 impact, defined below. Definition 3. Given a DNN model M, its mutated version M′ , and a data point (I, O), we define the two types of impacts: • Type 1: Mutant M′ impacts the test case I if M(I) = O but M′ (I) ̸= O, or M(I) ̸= O but M′ (I) = O. In other words, type 1 impact tracks pass to fail and fail to pass test cases, a la MUSE [17]. ` • Type 2: Mutant M′ impacts the test case I if M(I) ̸= M′ (I). In this definition, M(I) or M′ (I) denotes the operation of applying model M or M′ on the test case I. It is worth noting that checking for equality of two values can be tricky for regression models, as those models approximate the expected values. To work around this problem, deepmufl compares values obtained from regression models using a user-defined delta threshold, i.e., the values are deemed equal if their absolute difference is no more than a threshold. By default, deepmufl uses a threshold of 0.001. This is the approach adopted by well-known testing frameworks for comparing floating-point values [54], [55]. Also, whether deepmufl uses type 1 or type 2 impact is a user preference and is determined alongside the threshold. D. Suspiciousness Value Calculator Armed with the above definitions, we can now give concrete definitions for the terms used in Eq. 1, 2, and 3, specialized to DNNs. • Given a model element, i.e., neuron or a layer, e, M(e) is defined to be the set of all mutants generated by mutating e. These sets are produced by mutation generator process. • Assuming that m is a mutant on the element e, Tf (m, e) (or Tp(m, e)) is defined as the set of failing (or passing) test cases that are impacted in type 1 or type 2 fashion by m. More concretely, Tp(m, e) = {t | Em,t = ✓ ∧ t is passing}, similarly Tf (m, e) = {t | Em,t = ✓ ∧ t is failing}. These two sets are defined using a quite similar notation; the readers are encouraged to review Definitions 2 and 3 to avoid confusion. • Tf (or Tp) is the set of originally failing (or passing) test cases. These sets are constructed by test case splitter. • F ⇝ P (or P ⇝ F), for a model element e, is defined as the set of originally failing (or passing) test cases that turned into passing (or failing) as a result of some mutation on e. More concretely, assuming the execution matrix E is constructed using type 1 impact, F ⇝ P is defined as {t | t is failing ∧ ∃m ∈ M(e) · Em,t = ✓}. Similarly, P ⇝ F is defined as {t | t is passing ∧ ∃m ∈ M(e)·Em,t = ✓}. In other words, these sets track all the failing/passing test cases that are type 1 impacted by some mutant of a given element. These two sets are defined using a quite similar notation; the readers are encouraged to review Definitions 2 and 3 to avoid confusion. Having specialized definitions for the terms used in the fault localization formulas described earlier, we are now able to calculate suspiciousness values for the elements in a DNN model. Guided by the user preferences, deepmufl calculates all the values for |Tf (m, e)|, etc., and plugs into the specified formula to calculate suspiciousness values for the elements. It is worth noting that if all the mutants generated for a given element are nonviable, MUSE formula (Eq. 3) and all the variants of Metallaxis (e.g., Eq. 1), by definition, will return 0 as the suspiciousness value for the element. Nonviable mutants do not contribute toward localizing the bug, therefore they are considered overhead to the fault localization process. Fortunately, based on our observations in our dataset of buggy DNNs, nonviable mutants are rare. Equivalent mutants are another source of overhead for deepmufl. Currently, we do not have any means of detecting equivalent mutants, but we argue that these mutants do not impact MBFL results, as they are equivalent to the original model and do not impact any passing or failing test cases.

Mutation-based Fault Localization of Deep Neural Networks: Proposed Approach

The market offers a wide range of solution providers to choose from. The Best Identity Verification Software category on any listing platform includes over 200 products. Add to it all sorts of hardware devices, and you’ll get the impression that the market is over-saturated, and there are plenty of go-to solutions for handling ID documents and Biometric verification for any business use case. Identity Verification Below is a 9-step guide that will empower you with insights on how to choose the best Identity Verification (IDV) software provider effectively, guiding your selection towards ones that excel in delivering precision, security, and the utmost trustworthiness in the field of identity verification. Step 1: Make sure that document capture is fully automated If you ask any forensic expert how to verify ID documents reliably, they will likely give you the following answer: first of all, make sure you have a physical document at hand. The reality, however, is often far from such ideals. In the face of digital transformation, the capture process largely determines the check’s credibility. At the capture stage, an identity verification solution should cope with two things: recognize the submitted document and assess its quality. The thing is that software solutions use the capabilities of the user’s device, and rely on the user’s accuracy in taking photos. A bad camera, poor lighting, glares, or a skewed image make it difficult to read the information. This may lead to either errors or asking users to re-take photos over and over again until they meet the quality requirements. The best solutions can assess an image's quality and fine-tune it if necessary: adjust brightness or contrast, remove glares, or deskew the photo if it was shot at an angle. As for document type recognition, it’s mostly a matter of Unfortunately, many identity verification solutions still add two extra steps in the user journey: “choose your document type” and “choose your country.” UX. You can avoid making your users do extra clicks and typing by choosing a solution that identifies the document type and its origin country. As simple as it sounds, such capabilities require the vendor to invest a lot of time, money, and effort into creating a comprehensive document template database. For now, let’s just make a mental note that, ideally, your identity verification solution should do most of the work automatically. Questions to ask a vendor: Does your solution identify the document type automatically? Does it assess the document image quality? What are the criteria? Can it enhance the image’s quality to improve the data's readability? Step 2: Test-drive document checks Identity verification solutions must comply with ICAO and BSI guidelines for checking international documents, visas, etc. For domestic ID documents, though, there may be their own variants of execution of security elements of protection that require specific checks. Ideally, an identity verification solution should offer a check for each aspect: both standardized international features and local characteristics. The denser the coverage with checks, the more credible the conclusion about the authenticity and validity of the document. You can judge a vendor to provide first-class performance when their solution performs a long list of checks, plus runs massive cross-checks comparing the data from different elements to make sure they match. Document checks to ask for: Automatic document type identification Visual inspection zone verification MRZ validation Barcode type and format reading and validation Document liveness check (includes checks of holograms and screenshot detection) RFID chip detection and reading Cross-checks of the data fetched from different elements Step 3: Ensure that NFC-based RFID chip verification is in place A radio-frequency identification—or simply —chip is a tiny device that modern electronic ID documents contain. RFID chips store document holders’ data. The ICAO (International Civil Aviation Organization) strictly regulates the exact list of the data encoded in the chip. RFID Usually, reading this information entails using special passport readers or NFC technology built into mobile phones. You should be especially careful if it’s the latter. In the case of a remote process, there’s a risk that fraudsters can intercept and modify verification results. That’s why a good vendor needs to practice a zero-trust-to-mobile approach. In practice, the data needs to be re-verified to ensure the chip is not cloned or its data manipulated. Here’s an example of how Regula tackles this issue. RFID sessions can be re-verified on the server side in addition to the checks conducted on mobiles. Thanks to this, the data of the check is impossible to compromise. All this is done strictly on-premises: the results of the verification session are stored on a customer’s server, so it’s possible to get back to them afterward. This approach is considered the most reliable and secure way to verify a document with an NFC chip. Questions to ask a vendor: Does your identity verification solution read and verify an RFID chip? Can it read the information encoded in the chip? Do you apply a zero-trust-to-mobile approach? If so, how exactly does it work in your solution? Step 4: Explore capabilities for Biometric checks Validating the ID document is just a part of identity verification. Another part is ensuring that the person submitting it is the legitimate holder. That’s done with the help of biometric checks. Biometrics is a broad term that may imply a wide range of checks: face, fingerprints, voice, or even iris recognition. Most of them are overkill for regular business’ digital onboarding, but state authorities can require them, for example, when you apply for a visa. The most common way to run a biometric check for business is by using face biometrics. The process is simple: the user takes a selfie, and then the technology matches that photo with the photos in the submitted ID document (e.g., in the visual inspection zone and the RFID chip), and flags if there’s anything wrong. The essential feature of a proper face recognition module is liveness detection. That means you need not only to determine that it’s the same person in the photographs but also to make sure that the selfie is real. Sometimes attackers try to pass off an edited photo as a real selfie. Sometimes, they might use various masks and even deepfake technology. A good identity verification solution should be able to detect such issues. There are two types of liveness verification: passive and active. A passive liveness check implies the use of a static selfie, while active liveness requires the user to perform a series of simple movements: rotating the head, moving closer or further away, etc. Questions to ask a vendor: Do you perform biometric verification? What components does it include (face detection, face matching, face search, age verification, etc.)? Do you provide active or passive liveness checks? What PAD (Presentation Attack Detection) do you protect from? Step 5: Investigate the database of supported documents Cutting-edge technologies on their own aren’t enough for thorough identity verification. The most reliable IDV requires a deep knowledge of identity documents. This usually comes in the form of a document template database containing detailed information for every document: layout, fields, data recording methods, security elements, and more. Gathering such a collection requires tremendous resources and a solid background in document forensics. Ideally, your vendor should have seasoned forensic experts on their team to guarantee the comprehensiveness of templates and competent maintenance of the database. The importance of this cannot be overstated. If the vendor has thoroughly examined thousands of document types, its software solutions can easily distinguish one from another, fully read them, and extract the required data, therefore effectively verifying them as a result. The database needs to be extensive, as even within one country, there can be multiple versions of a document based on the date of issuance. Considering the frequent renewal and re-issuance of identity documents, the database should be regularly updated too. Cooperation with international organizations and security agencies is also a point in favor of the provider. Established relationships help them regularly expand the database with new document types and share the best practices in detecting document fraud. Questions to ask a vendor: How long have you been operating in the identity verification industry? Are there experts on your team with hands-on experience as forensic analysts? Do you have a document template database? How many items does it include? If there is no document in the database, how long does it take to add? Is it proprietary or bought from third parties? Step 6: Evaluate the time to value Reliability and completeness of checks are all good, but they won’t be of help if the integration process takes ages and blows up your budget. The pressure comes from multiple sides. On one side, there are regulators whose requirements are better met sooner than later. Then, there’s also your product and workflows, which will likely demand some customization from the identity verification solution. Add to it a learning curve that, for some solutions, can be rather steep, and lengthy. Questions to ask a vendor: Is it possible to build your solution into a web app? How fast will we be able to get up and running? What does the integration process look like? What customization options does your solution offer? Are they available out of the box, or will they require additional configuration/costs? Step 7: Check out the compliance of the workflows Regardless of the industry, safeguarding customer data is of the utmost importance. Therefore, it’s crucial to find out how your identity verification provider addresses the matter. When it comes to working with customers’ personally identifiable information (PII) during identity verification, there are two primary approaches: where vendors handle the storage and processing of customer data on their own infrastructure. A Software-as-a-Service (SaaS) scenario, where you store and process your customers' PII within your own secured perimeter. An On-premises approach, While the SaaS use case can save you time and the expenses associated with securing the data on your own, it’s even more critical to thoroughly examine the vendor’s procedures for customer data security and protection. Data breaches aren’t uncommon. An on-premises option places a higher emphasis on data privacy and security. Since no third parties have access to PII, it reduces the risk of breaches. However, extra protection comes at a price. The maintenance of infrastructure and reliability for following security policies is on you, so you’ll need to budget resources for engineering and security training for employees. Questions to ask a vendor: What type of solution do you offer: cloud or on-prem? Do you collect and store the personal data of end users? If it’s cloud… What certifications does your service have? (e.g., SOC1 type 2, HIPAA, etc.) Where can I read your security policy? What’s your service availability time? Step 8: Try to contact tech support Salespeople might be responsive before making the sale, but a company’s true colors show when a customer faces difficulties or has a request. If a vendor can provide prompt and professional technical support, it saves you a lot of time, effort, and headaches. Ideally, it’s good to have more than one way to contact support: by phone, email, live chat, or messengers. In most companies, additional communication channels come with the premium support option. Such support may include a dedicated manager, and the ability to communicate with the vendor’s team in real-time, 24/7. If this option is not available, pay attention to the response time SLA. This is the time in which the vendor commits to respond to a client’s issue. It’s usually defined by the support policy. As for cases when a client needs off-hours assistance, the vendor’s website should provide all essential instructions, guides, and FAQs. Comprehensive documentation should answer 90% of the questions, so pay attention to how thoroughly it is made, if it includes demo examples, how often it is updated, and if it’s localized to your language. Questions to ask a vendor: What’s your response time for support requests? Do you have a premium support option? Is support documentation comprehensive and easy to navigate? Step 9: Find customer references If you made it through the steps above, you can confidently trust the results. Still, it’s always a good idea to look for additional social proof from companies that have already succeeded in what you’re trying to achieve. Here, we advise you to conduct your own research and find as many reviews about the vendor as possible. The first go-to source of information is the case study section on the vendor’s website. There, you can look for stories from customers from your niche and find relevant use cases. For example, if you’re a crypto platform on a quest to deploy KYC, then KYC-related cases from banks will also give you valuable insights. Also, pay attention to who a vendor’s existing customers are. The presence of well-known names is a good sign. If the vendor has state-level organizations and security agencies, such as border controls, among their customers, it’s also great, because they have the strictest requirements for identity verification. Also, you may want to research what the media say about different vendors. Consider exploring not only so-called tier-one resources, such as The New York Times or Business Insider but focus more on industry-specific publications that specialize in covering identity verification and cybersecurity. This approach will broaden your research and provide a more comprehensive understanding of different vendors' reputations. Among such media outlets are: Biometric Update, Help Net Security, Infosecurity Magazine, Source Security, Identity Week, Find Biometrics, and others. Try to find out: Are there any references available in open sources from customers in my industry? Can the vendor provide those references on request? Are there relevant use cases in the vendors’ customer success stories? Are there any mentions of the vendor in the industry and/or tier-one media? In conclusion, this 9-step guide empowers you to choose Identity Verification software that aligns with your specific needs while excelling in precision, security, and trustworthiness, ensuring your data and operations are in safe hands. With the right software, you can confidently navigate the evolving landscape of identity verification for a secure and seamless future. If you’re struggling with finding the right solution for your business use case – feel free to get in touch. Also published . here

Stories, News & Mentions about 2TEST

2test’s Stories on HackerNoon

2test's News & Mentions