Indian headline indices ended in the red for the seventh straight session on Monday amid volatility. The declines were on the back of significant selling pressure in IT stocks after the Federal Reserve Chair Jerome Powell indicated that strong US economic growth would delay interest rate cuts.

Market Trading Guide: Infosys, Muthoot Finance are among 5 stock recommendations for Tuesday - Stock Ideas | The Economic Times

The National Retail Federation (NRF), in partnership with The Chertoff Group, has released a comprehensive “Guide to Developing a Retail Supply Chain Cybersecurity Risk Management Plan.”

The Chertoff Group Partners With NRF to Create Supply Chain Cybersecurity Risk Management Guide For Retailers - HS Today

The “Guide to Enhancing Cybersecurity Resilience” report, developed by the CyberRisk Collaborative, shares expert insights and recommendations on improving cybersecurity resilience.

Building Cybersecurity Resilience: Strategies, Technologies, and Best Practices from Industry Leaders | SC Media

Apple also published the PCC Security Guide, detailing how the platform's structure upholds privacy in cloud-based AI operations.- Back End News

Apple expands security bounty to boost trust in AI cloud | Back End News

The National Institute of Standards and Technology requests comments on its draft of a quick-start guide on cybersecurity supply chain risk management, or C-SCRM, assessments. The C-SCRM guide was drafted to help organizations undertake the due diligence that would inform them about potential suppli

Comments Open on Cybersecurity Supply Chain Risk Management Guide

CYRISMA explains what 'reasonable cybersecurity' means and how to achieve it.

The CIS Guide to Defining Reasonable Cybersecurity | ChannelE2E

These include Guidelines for secure AI system development (by the UK National Cyber Security Centre and US Cybersecurity and Infrastructure Security Agency), National Institute of Standards and Technology Risk Management Framework, MITRE Adversarial Threat Landscape for AI Systems and Open ...

Launch of Guidelines and Companion Guide on Securing Artificial Intelligence Systems

The PETALS Framework is an investor’s guide for evaluating RWA investment opportunities across six key levers.

Web3 Fundamentals: An Investor’s Guide To Evaluating Tokenized Assets

Guide

guide

Upgrading From Rails 7.1 to Rails 7.2: A Step-by-Step Guide for Enhancing Your Application

213 Stories To Learn About Guide

If you are new to tech, you might be confused by a term that you’ll see all over the place: API. Let’s take a look at what it means, some examples, and how you can use it. Definition API is the abbreviation for application programming interface. Those words alone probably don't help much, so let’s see what each of them means here. Application Applications are programs that provide some feature(s) to users. They store and retrieve data, perform calculations, etc. Applications give us a reason to use computers at all. The direct usefulness of applications contrasts with programs that we run to access other programs, for example: we use the operating system to open applications, and we use browsers to access web applications. Interface The interface is an exposed part of an application, prepared to receive input from the outside. As a user, you maybe already be familiar with some types of interfaces: graphical user interface (GUI)—the most common interface that we all know from personal computers and mobile devices. command line interface (CLI)—where the user types a program name and parameters to run a program. Programming An API is an interface that is meant to be used by other programs. So, instead of exposing buttons or menus, the application provides a way of interacting with it in a machine-friendly way. Nowadays, it is typically understood as a Web API—an online server that exposes different routes and returns data in a format that is both easy to parse for a computer and understandable for humans. The name itself doesn’t imply any specific channel of communication—there are other types of APIs as well. On the web platform, we have an ever-growing list of APIs exposed to JavaScript by the browsers. The way of accessing differs, but the method is almost always rather rigid and requires precise interaction with it. Intuition APIs are simply a way for applications to communicate with each other. Good APIs are stable—because a breaking change in one application will require an update in all applications that use it. And good APIs are documented—because otherwise it’s very difficult to write a program that uses them. Examples Let’s take a look at some examples of APIs that you could play around with. URL The URL (uniform resource locator) is a form of an API. As users, we usually use them without thinking much about them. We use a web browser to fetch and display a website from an address that we clicked as a link. With well-designed addresses, we can tweak them and get still get a response from the server: when we replace the part of with , we get a valid URL: Netherlands en.wikipedia.org/wiki/Netherlands Belgium en.wikipedia.org/wiki/Belgium Some URLs are organized in a nice hierarchy. If we remove parts of , we go up to: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Numbers_and_dates A , list of JavaScript guides general , JavaScript page for web platform documentation. Main page A well-designed URL system invites us to tweak the address but will not help much if we ask for a page it doesn’t have. For example, when we replace with , we get : JavaScript TypeScript developer.mozilla.org/en-US/docs/Web/TypeSc.. Playing around with URLs can be a simple way of trying out communicating directly with a machine—and getting used to their requirements of providing the parameters in exactly the way they expect. Command line programs Another simple way of starting with APIs are command line programs. Similarly to web APIs, the first step is to read the documentation. Then, make a few trial and error attempts at getting the program to do what you want it to do. In another article, I provide a simple introduction to . CLI programs Web API As a tester or a programmer, you are most likely to use a web API. They are relatively easy to use, but there are some difficulties involved: the access can be limited to authorized users—each system will have a different way of authorization and can require creating a user, logging in, providing the session information in cookies or some ID and key pair without getting too deep, you can do only GET requests—by pasting the API address into the address bar of your browser. The other types of requests (POST or DELETE) will require either getting some specialized program or writing simple JavaScript in the developer tools of your browser. Let’s see some examples of APIs that you could experiment with: , Open street map , Mastodon . Wikipedia What you can do with APIs The main use of an API is to call other applications from the program you write. You can use them to leverage other systems for any variety of functionalities: OAuth for authorization with 3rd-party providers such as Google for Facebook getting automated translations from the cloud getting geolocation from map systems automatically cross-publishing the same content on many social media platforms accessing large language models to provide some AI functionality and many more In a way, a lot of modern programming is writing glue code between different APIs. How understanding APIs helps you debug Because so much programming is about calling APIs, there is a lot of troubleshooting that can be done there. Many bugs I created encountered in my frontend programming career were caused by either sending an incorrect request to the API, or interpreting the response incorrectly. If the frontend sends a valid request and displays the response as it should, then the bug is probably on the backend. If you can troubleshoot that much as a tester, this can significantly speed up finding and fixing the bug. Learn more If you are interested in learning more about APIs, programming, and testing, for an occasional email from me. sign up here Also published . here

What is an API? A Beginner's Guide 

Introduction In this article, I would like to share my experience of implementing Silent Push Notifications in an iOS app. The purpose of using Silent Push Notifications was to solve the problem of some services going to sleep when the phone is idle for a long period of time. Or for example, if you have a messenger app and you want the user to be able to access new/updated content and not have to wait for it to download. Silent Push Notifications allowed us to activate the app once every 21 minutes (the minimum value we picked up so that Apple would not grant a temporary ban) and run the services in the background to update. Silent Push Notifications Provide the ability to update the content of your application, make API calls, and perform background tasks. They are sent without activating screen beeping or other visible notifications. In fact, the application goes into an “active” state and is generally no different from a normal startup. Navigation will function, and screens will initialize, although they will not be visible on the screen. All actions called in the “didFinishLaunchingWithOptions” method will also be executed. Silent push notifications wake up your application in the background, allowing time to download data from the server and perform tasks in the background. 1. Setting up Silent Push Notifications First, you need to set up support for Silent Push Notifications in your application. Here is a brief overview of the steps you need to follow. **1.1 Developer Portal
\ Go to the Developer Portal on Apple’s website and make sure Background Modes and Background Fetch support are enabled. **1.2 Provisioning Profile
\ Ensure that the Provisioning Profile (linked to your App ID) includes support for Background Modes and Background Fetch. **1.3 Enabling Remote Notifications
\ In your project in Xcode, open the file AppDelegate.swift and add the following code to the method `application(_:didFinishLaunchingWithOptions:)`: // Registration to receive notifications

let center = UNUserNotificationCenter.current()
center.requestAuthorization(options: [.alert, .badge, .sound]) { (granted, error) in
    if granted {
        DispatchQueue.main.async {
            UIApplication.shared.registerForRemoteNotifications()
        }
    }
} **1.4 Signing & Capabilities
\ Here you need to give permission to use push notifications Scroll to the bottom. And tick the box for “Remote notifications.” Check the rest, depending on your needs. 2. Handling Silent Push Notifications After setting up Silent Push Notifications, you’ll need a handler that will respond to receiving such notifications and trigger a service. Here’s a sample code to add to your AppDelegate.swift func application(_ application: UIApplication, 
     didReceiveRemoteNotification userInfo: [AnyHashable: Any], 
     fetchCompletionHandler completionHandler: @escaping (UIBackgroundFetchResult) -> Void) {
        // Silent Push Notification processing
    if let silentNotification = userInfo["aps"] as? [String: AnyObject], 
       silentNotification["content-available"] as? Int == 1 {
        // Launch of a some service
        SomeManager.shared.startUpdatingAnything()
    }
        // Ending a background operation
    completionHandler(.noData)
} Using the completion handler You only have 30 seconds to execute the background request, and you should call the completionHandler on completion. 3. Backend All the things you should tell your backend developers You must tell the backend which body to send. You can add additional fields at your discretion. For notifications to be silent, you must specify “content-available”: 1. 3.1 {
   “aps” : {
      “content-available” : 1
   },
   “apns-priority” : 5,
   “apns-push-type” : “background”,
} You can read more about it . here If you want to check your notifications without a backend like I do. You will need an application that emulates the backend to check. 3.2 I used . PushNotifications (You can skip this point and go straight to 3.2.1) On the day I published this article, apple introduced a new tool for push notifications 😅 Update! 3.2.1 Push Notifications Console “The new Push Notifications Console makes it easy to send test notifications to Apple devices through the Apple Push Notification service (APNs). You can access logs that provide insights into the delivery process and leverage tools to generate and validate tokens.” — Taken from Apple’s official . website You will not need the p8 file for Push Notifications Console. You simply log in to your account and start testing. It’s also very convenient to use push notifications logging. **3.3 Registration token
\ A registration token is required to send remote notifications. In order to send notifications to remote devices, your application must receive a registration token that the APNs (Apple Push Notification Service) uses to deliver notifications to a specific device. The registration token is a unique identifier tied to the device and your app. When your app is launched, it communicates with APNs to receive a registration token, which can then be sent to your server. Your server uses this token to send notifications to the relevant device. func application(_ application: UIApplication,
                 didRegisterForRemoteNotificationsWithDeviceToken deviceToken:Data) {
   let pushToken = deviceToken.map { String(format: "%02.2hhx", $0) }.joined()
   self.yourPushNotificationsService.pushTokenDidReceived(pushNotificationToken: pushToken)
} Once you have a registration token for a particular user, you can send notifications to their remote device via your server, a third-party service (PushNotifications), or Firebase Cloud Messaging. The process of receiving a token and sending notifications is shown in the diagram below. 3.4 Download the .p8 file If your app already has normal push notifications, request the p8 key from the person in charge of push notifications on the backend or a senior/lead iOS developer. a. If you are setting up push notifications for the first time, the following instructions are for you: b. Go to Apple developer account and go to Certificates, Identifiers & Profiles. Go to the Keys section and click on a new key using Add button(+). Choose a unique name for the key and select the Apple Push Notification service (APN) checkbox. Click continue and then confirm. Note and save the key ID. Click Download to generate and save the key. you have to save the key in a secure place because you can’t download the key more than once. Do not rename Auth key file. !!! Please note 4. After installing the app on your physical device When you install the app, be sure to check whether it has Background App Refresh enabled Settings > (scroll down) > Your app > Background App Refresh (enable) 5. Problems and solutions In the process of implementing Silent Push Notifications, I have encountered a few problems which may be useful to you. Apple’s restrictions Apple has a strict limit on how often Silent Push Notifications are sent. 5.1 If several Silent Push Notifications are sent in a row, they may stop reaching the user. To avoid this problem, I used a backend timer to ensure that Silent Push Notifications are only sent once every 21 minutes. Error handling 5.2 It is important to handle possible errors when processing Silent Push Notifications. For example, if a service is already active, new Silent Push Notifications should be ignored to avoid having to run the service continuously and using resources unnecessarily. Optimise battery usage 5.3 Running some services can consume a significant amount of battery power. To minimize this, I have set a limit on the time the service will run after each Silent Push Notification. It is very important to note the following points: The Silent Push does not work in “low power mode.” 5.4 The treatment of the silent-push system depends on several factors: 5.5 Amount of free memory available: when you close an application, the system creates a snapshot of the memory used and assigns points to the Silent Push processing speed. If your application is training a machine learning model or using more than 400 MB of memory, the system may refuse to process the push notification. It is therefore recommended that you try to minimize resource usage and free up memory when switching to background mode. Battery charge level. Frequency of push notifications: the system can handle silent push notifications no more frequently than once every 20 minutes. Time of day: the system can change its attitude towards handling push notifications depending on the time of day. Phone charging status: if the device is charging, the system may be more prone to handle silent push. App crash: if your app crashes, the system will probably not handle the silent push and may assign penalty points. So when you put your phone on charge and get your first silent push the next morning, the system will gradually increase the likelihood of handling push notifications and reduce the penalty points over time. Conclusion The use of silent Push notifications in the app has solved the problem of some services falling asleep when the phone is left for extended periods. Launching the service every 21 minutes after receiving a silent Push notification updates the data in the app, providing a better experience and usability. Share your thoughts about the article. Your comments will help me expand on this research and provide additional material on the topic of the article. This will make it more useful. I would like to dedicate my first technical article to my mentor. I want to express my sincere gratitude for your patience, politeness, and consistency while I was a junior developer. Keep up the great work! Also published . here

A Comprehensive Guide to Silent Push Notifications in iOS: A Step-by-Step Walkthrough

Introduction A large language model (LLM) is a machine learning model trained on vast amounts of data and can perform natural language processing (NLP) tasks such as analyzing and summarizing text, interpreting languages, answering questions based on sentiments, text generation, and more. The model generates coherent and contextually relevant human-like responses based on the data it was trained on and the input it receives. allows you to create models that utilize the OpenAI GPT-4 features and deploy them so that you are ready to perform NLP tasks within your database. MindsDB The concept makes this possible. MindsDB Generative AI Tables AI Tables refer to machine learning models stored within a database as virtual tables. In this article, you will learn how to deploy LLMs with MindsDB and OpenAI. We will leverage the engine made available by MindsDB to create and deploy models that can , and . OpenAI rephrase text determine word count, analyze & respond to customers’ reviews Additionally, MindsDB allows you to fine-tune some LLMs with specialized or task-specific datasets to improve their performance and applicability to specific tasks. Pre-Requisites To follow along with this tutorial, you need a . MindsDB cloud account If you prefer a local instance, set up MindsDB via or . Docker pip Connecting to a Database Let’s start by connecting MindsDB to a public MySQL demo database. We will use a few tables inside the MySQL public database to demonstrate how to deploy LLMs. CREATE DATABASE project_llm
WITH ENGINE = 'mysql',
PARAMETERS = {
    "user": "user",
    "password": "MindsDBUser123!",
    "host": "db-demo-data.cwoyhfn6bzs0.us-east-1.rds.amazonaws.com",
    "port": "3306",
    "database": "public"
}; We have successfully connected our database to MindsDB with the name . project_llm Let’s take a look at its tables. Run the following query to see the tables: SHOW FULL TABLES FROM project_llm; Rephrasing Text Recall we mentioned that for this tutorial, we will create and deploy 3 different models to , and . rephrase text determine word count, analyze & respond to customers’ reviews In this section, we will create a model for rephrasing text. We will call it the . This model will rephrase email content more politely. rephraser_model CREATE MODEL rephraser_model
PREDICT paraphrase
USING
    engine = 'openai',
    prompt_template = 'rephrase content in a more polite way. {{email_content}}'
    api_key = 'YOUR_OPENAI_API_KEY'; The Model uses the OpenAI engine. stores a message to be answered by the model. prompt_template If you are on the MindsDB cloud, the parameter is optional but mandatory for local usage and MindsDB pro. api_key For convenience and to avoid repetition, you can create a MindsDB ML engine to hold your API key. This way, you don’t have to enter the API key each time you want to create a model. CREATE ML_ENGINE openai2
FROM openai
USING
    api_key = 'YOUR_OPENAI_API_KEY'; Check the status of your model. You can only use a model after it has completed generating (this process does not take time to complete). DESCRIBE rephraser_model; Now that our Model is ready. Let’s ask it to rephrase some texts for us. SELECT email_content, paraphrase
FROM rephraser_model
WHERE email_content = "Jeff, get over here!"; : Output Let’s do a batch prediction by joining our to the table and rephrase some email content more politely. rephraser_model email SELECT input.email_content, output.paraphrase
FROM project_llm.emails AS input
JOIN rephraser_model AS output
LIMIT 3; : Output Determining Word Count Following the same process, let’s create and deploy a model to determine the word count of comments. Create a Model CREATE MODEL word_count_model
PREDICT count
USING
    engine = 'openai2',
    prompt_template = 'describe the word count of the comments strictly as "2  words", "3 words" "4 words", and so on.
    "this is great" : 3 words
    "I want this good" : 4 words
    "I want bread right now" : 5 words
    "please take note and effect changes": 6 words
    "{{comment}}.":'; Optionally, you can add the and parameters to . defines the maximum token of the prediction. defines the riskiness of the answer provided by the model. max_tokens temperature USING max_tokens temperature Check the status of your model, and then go ahead to test it out. SELECT comment, count
FROM word_count_model
WHERE comment = 'I like the fact that things are getting better with me daily'; : Output Let’s do a batch prediction by joining our model to the table. user_comments SELECT input.comment, output.count
FROM project_llm.user_comments AS input
JOIN word_count_model AS output
LIMIT 3; : Output Analyze and Respond to Customers’ Reviews Let’s create a model to analyze and respond to customers’ reviews. The model will first analyze and determine if a review is positive or negative. If negative, the model responds with an apology and promises to make their experience better next time. If positive, it will respond with a thank you note and ask them for a referral. CREATE MODEL auto_response_model
PREDICT response
USING
    engine = 'openai',
    prompt_template = 'Give a one sentence response to customers based on the review type.
    "I love this product": "positive"
    "It is not okay" : "negative" If the review is negative, respond with an apology and promise to make it better.
    If the review is positive, respond with a thank you and ask them to refer us to their   friends.
    {{review}}'; Let’s query the model with some synthetic data. SELECT review, response
FROM auto_response_model
WHERE review = "I am not happy about this product"; : Output Make a batch prediction. SELECT input.review, output.response
FROM project_llm.amazon_reviews AS input
JOIN auto_response_model AS output
LIMIT 2; : Output It is important to note that the models we have built are production ready. MindsDB simplifies the process of building and deploying machine learning models by designing them to be production ready by default so that you don’t need to use an ML Ops flow. It makes using machine learning in your database easier and faster without requiring extensive ML expertise. Conclusion allows you to use pre-trained OpenAI natural language processing (NLP) models inside your database to perform NLP tasks easily and derive valuable information from text data with only a few SQL queries or by using REST endpoints. MindsDB The MindsDB OpenAI integration enables developers to leverage natural language queries to analyze data and efficiently gain a deeper understanding of their data. Introducing ML capabilities into your database enables you to make data-driven decisions and scale your product by making insightful predictions. Sign up for a to get a hands-on experience with NLP capabilities with MindsDB and mindsDB is one of the most promising artificial intelligence startups in 2023. free demo account That was the end of this blog. Today, I hope you learned something new. If you did, please like/share it so that others can see it as well. Thank you for being a regular reader; you’re a big part of why I’ve been able to share my life/career experiences with you. Follow on Twitter for the most recent updates, and if you have any questions or problems, you can join their server to discuss and get help. MindsDB Slack Follow me on to get more writing and software engineering articles. Twitter Want to Read More Interesting Blog Posts About Blogging? ✅ Here are some of my most popular posts that you might be interested in. How I Made $30,000 From Writing In 1 Year A Software Developer’s Guide To Writing A Complete Step-By-Step Guide To Start A Blog For Software Developers How I Become A Better Writer As A Software Engineer Shameless Plug Subscribe to my to receive monthly updates on my small bets and writing journey! Join over 3600+ others! newsletter

How to Deploy LLMs With MindsDB and OpenAI: An Essential Guide

This article will guide you step by step through how to build a custom tool & to the SuperAGI. Using an example provided in a . add your tool sample repository Step 1: Installing SuperAGI Dependencies Begin with installing all the dependencies, and make sure you have Python installed on your system. After you've done this, run to get the SuperAGI and . pip install superagi-tools BaseToolkit BaseToolclasses Step 2: Creating a New Python File Create a new Python file (for example, ), which will define your tool class. Import all the necessary dependencies required to build your own custom tool using the following commands: my_tool.py from superagi.tools.base_tool import BaseTool
from pydantic import BaseModel, Field
from typing import Type Step 3: Defining the Input Model Next, create a Pydantic class. This class will define the input schema for your tool. You'll need to specify the fields and their types, as shown below: BaseModel class MyToolInput(BaseModel):
message: str = Field(..., description="Message to be processed by the tool") Step 4: Defining Your Tool Class Now, you can create a class that inherits from . BaseTool You'll need to set required attributes such as name, , and . Moreover, you need to implement the _execute method, which contains the logic for your tool. This method takes the input parameters as arguments and returns the tool's output. args_schema description Here's an example: class MyTool(BaseTool):
name: str = "My Tool"
args_schema: Type[BaseModel] = MyToolInput
description: str = "Description of my tool"

def _execute(self, message: str = None):
# Tool logic goes here Step 5: Creating a Toolkit File Next, create another Python file (for instance, my_toolkit.py) to define your toolkit class. Import the necessary dependencies as follows: from superagi.tools.base_tool import BaseToolkit, BaseTool
from typing import Type, List Step 6: Defining Your Toolkit Class This class should inherit from and optionally from if you want to make it abstract. BaseToolkit ABC Set required attributes such as and . You should also implement the method, which returns a list of instances of your tool classes, and the method, which returns a list of environment variable keys required by your toolkit. name description get_tools get_env_keys Below is an example: class MyToolkit(BaseToolkit):
name: str = "My Toolkit"
description: str = "Description of my toolkit"

def get_tools(self) -> List[BaseTool]:
return [MyTool()]

def get_env_keys(self) -> List[str]:
return [] Step 7: Configuring the Environment At this stage, create a configuration file (like ) to define any environment variables your toolkit or tool might require. config.yaml MY_ENV_VAR: 'YOUR_VALUE' Step 8: Building Your Tool Now implement the logic within your tool's method based on your requirements. _execute You can access the environment variables using the method inherited from . get_tool_config BaseTool Step 9: Testing Your Tool After you've built your tool, you need to write test cases to verify its functionality. This step ensures that your tool works as expected. Step 10: Listing Your Tool Dependencies If your tool requires additional dependencies, list them in a file. This way, anyone who uses your tool can easily install the necessary dependencies. requirements.txt Step 11: Creating a GitHub Repository Create a new GitHub Repository with your Toolkit's name and upload all the files you've worked on so far. Step 12: Linking Your GitHub Repository to SuperAGI Start SuperAGI using . Add your GitHub repository link to SuperAGI’s front end by clicking on the “add custom tool” button at home or navigating to the toolkits section. Paste your toolkit repository and save changes. docker-compose up --build The SuperAGI tool manager will take care of the installation of your tool along with its dependencies. Step 13: Rebuilding SuperAGI Re-build SuperAGI using Docker and start using your tools: docker compose down
docker compose up --build At this point, you should be able to configure your tool settings from the toolkit section and start using them during the agent provisioning. This concludes our step-by-step guide to building your own custom tool in SuperAGI. In case you face any challenges in building/ to SuperAGI, don't hesitate to join our to work with the community to resolve the issues. adding your custom toolkit discord

Building Your Own Custom Tool in SuperAGI: A Step-by-Step Guide

LLMs have revolutionized tons of aspects of our lives, from language generation to software to friendly chatbots. These AI models provide powerful tools for solving real-world problems, such as generating chat responses or following complex instructions. image captioning In this blog post, part of a on , we will compare two popular AI models: llama13b-v2-chat and Alpaca, and explore their features, use cases, and limitations. series LLaMA v2 We'll also see how we can use to find similar models and compare them to llama13b-v2-chat and Alpaca. Let's begin. AIModels.fyi About the LLaMA13b-v2-chat Model The llama13b-v2-chat model is a fine-tuned version of the 13-billion-parameter LLaMA-v2 language model originally developed by Meta. It has been fine-tuned specifically for chat completions, making it an excellent tool for generating chat responses to user messages. You can find detailed information about the model on the and the . llama13b-v2-chat creator page llama13b-v2-chat model detail page This language model is designed to assist in generating text-based responses for chat-based interactions. Whether it's providing customer support, generating conversational agents, or assisting in natural language understanding tasks, llama13b-v2-chat can be a valuable tool. Its large parameter size enables it to capture complex language patterns and generate coherent and contextually relevant responses. In summary, llama13b-v2-chat can understand inputs and generate appropriate chat responses. Understanding the Inputs and Outputs of the llama13b-v2-chat Model To effectively use the llama13b-v2-chat model, it's essential to understand its inputs and outputs. The model accepts the following inputs: : A string representing the chat prompt or query. Prompt : An integer specifying the maximum number of tokens to generate. Max Length : A number that adjusts the randomness of outputs. Higher values (greater than 1) result in more random responses, while lower values (closer to 0) produce more deterministic outputs. Temperature : When decoding text, samples from the top p percentage of the most likely tokens. Lower values limit the sampling to more likely tokens. Top P : A number that penalizes the repetition of words in the generated text. Higher values discourage repetition, while values less than 1 encourage it. Repetition Penalty : A boolean flag to provide debugging output in logs. Debug The model processes these inputs and generates a list of strings as output, representing the generated chat responses. The schema for the output is a JSON array containing strings. You can find out more about this model in the guides and . here here About the Alpaca Model The Alpaca model is an instruction-following language model fine-tuned from the LLaMA 7B model on 52K instruction-following demonstrations. It was developed by the Stanford Center for Research on Foundation Models (CRFM). The creators of Alpaca are Rohan Taori, Ishaan Gulrajani, Tianyi Zhang, Yann Dubois, Xuechen Li, Carlos Guestrin, Percy Liang, and Tatsunori B. Hashimoto. You can find detailed information about the model on the the team created. Stanford page The Alpaca model focuses on instruction-following capabilities and aims to bridge the gap between research and industry by providing an accessible instruction-following language model for academic purposes. It is fine-tuned from the LLaMA 7B model using a dataset of 52K instruction-following demonstrations, generated in the style of self-instruct using text-davinci-003. The model demonstrates promising performance in single-turn instruction following. This model's release is intended to facilitate academic research and foster improvements in instruction-following models. It is important to note that Alpaca is not designed for commercial use, and its safety measures are not fully developed for general deployment. In summary, Alpaca offers a lightweight and reproducible instruction-following language model that can be utilized for research purposes and the exploration of instruction-following scenarios. https://notes.aimodels.fyi/content/images/2023/07/alpaca_main-1.jpeg How the Alpaca model works, from the official website. Understanding the Inputs and Outputs of the Alpaca Model To effectively utilize the Alpaca model, let's explore its inputs and outputs. As an instruction-following model, Alpaca follows instructions and generates responses based on the given instructions. The inputs to Alpaca are represented by the instructions themselves, which describe the tasks the model should perform. Alpaca also has an optional input field, providing additional context or input for the task. The outputs of the Alpaca model are the generated responses to the given instructions. The responses are generated based on the fine-tuned model's understanding of the task and the underlying language patterns learned during training. You can read more about this in the model's README on . GitHub Comparing and Contrasting the Models Now that we have explored the llama13b-v2-chat model and the Alpaca model in detail, let's compare and contrast them to understand their similarities, differences, and optimal use cases. LLaMA13-v2 vs Alpaca Both the llama13b-v2-chat and Alpaca models are fine-tuned language models designed for different purposes. While llama13b-v2-chat focuses on chat completions, Alpaca specializes in instruction-following tasks. Use Cases The llama13b-v2-chat model is suitable for a wide range of chat completion tasks. It can be utilized in customer service applications, chatbot development, dialogue generation, and interactive conversational systems. This model's versatility allows it to generate coherent and contextually relevant responses to user queries or prompts. On the other hand, the Alpaca model is specifically tailored for instruction-following tasks. It excels at understanding and executing instructions provided by users, making it ideal for applications such as virtual assistants, task automation, and step-by-step guidance systems. Alpaca's ability to comprehend and follow instructions makes it a valuable tool for users seeking assistance in performing various tasks. Pros and Cons The llama13b-v2-chat model's strengths lie in its large parameter size (13 billion) and its fine-tuning for chat completions. It can generate detailed and contextually appropriate responses, making it useful for engaging and interactive conversational experiences. However, due to its generic nature, the model might occasionally produce responses that are factually incorrect or propagate stereotypes. Careful monitoring and filtering mechanisms should be implemented to mitigate these risks. Alpaca, on the other hand, offers a smaller and more cost-effective model (7B parameters) that is specifically optimized for instruction-following. It demonstrates performance comparable to the text-davinci-003 model in this domain. Alpaca's relative ease of reproducibility and lower cost make it an attractive option for academic researchers interested in instruction-following models. However, it shares common limitations of language models, including occasional hallucinations and the potential to generate false or misleading information. Similarities Both models are built upon the LLaMA framework, which provides a strong base language model for fine-tuning. They leverage the power of large-scale language models to generate high-quality outputs. Additionally, both models have been evaluated and compared to the text-DaVinci-003 model, showcasing their ability to perform similarly in instruction-following tasks. Differences The primary difference between the models lies in their intended use cases and specialties. While llama13b-v2-chat is a versatile chat completion model suitable for various conversational applications, Alpaca is specifically designed for instruction-following tasks. Alpaca's training data is generated based on self-instructed prompts, enabling it to comprehend and execute specific instructions effectively. Optimal Use Cases Choosing between the llama13b-v2-chat and Alpaca models depends on the specific requirements of your project or application. If your goal is to develop a conversational system or chatbot that engages in dynamic and context-aware conversations, llama13b-v2-chat would be a better choice. On the other hand, if you need a model that can understand and execute user instructions for task-oriented applications, Alpaca is the more suitable option. Taking it Further - Finding Other Instruction-Following or Chat Models with AIModels.fyi If you're interested in exploring additional instruction-following models beyond Alpaca, is a valuable resource. It offers a comprehensive database of AI models, including those catered to instruction-following tasks. AIModels.fyi By following these steps, you can discover similar models and compare their outputs: - Head over to to begin your search for instruction-following models. Step 1: Visit AIModels.fyi AIModels.fyi Utilize the search bar at the top of the page to enter specific keywords related to instruction-following models. This will provide you with a list of models relevant to your search query. Step 2: Use the Search Bar - On the left side of the search results page, you'll find various filters to narrow down the models. You can filter and sort by model type, cost, popularity, and specific creators. Apply these filters to find models that align with your requirements. Step 3: Filter the Results - By leveraging the search and filter features on , you can find models that best suit your needs and explore the diverse landscape of instruction-following models. AIModels.fyi Conclusion In this comparison, we explored the llama13b-v2-chat and Alpaca models in terms of their use cases, pros and cons, similarities, differences, and optimal applications. We emphasized the versatility of llama13b-v2-chat for chat completions and the specialization of Alpaca for instruction-following tasks. serves as a valuable resource for discovering and comparing various AI models, including instruction-following models. AIModels.fyi We hope this guide inspires you to explore the creative possibilities of AI and encourages you to leverage to find models that align with your specific needs. AIModels.fyi Remember to subscribe for more tutorials, updates on new AI models, and a wealth of inspiration for your next creative project. Happy exploring and enhancing your AI-powered endeavors with ! AIModels.fyi Subscribe or follow me on Twitter for more content like this! Also published here

LLaMA-v2-Chat vs Alpaca: A Guide to Know When to Use Each Model

Creating games for VR could sound like quite a complex area, especially for someone building for web or mobile. While this is partially true, since we are entering an era of new types of devices, I want to demonstrate that creating games for VR is not that challenging at all. In this article, I'll guide you through creating a modern and robust Oculus-compatible game in Unity and share a few tips on how to optimize your asset for maximum performance and quality when building Quest headsets. The key steps include: Setting Up your Unity Workspace Setting Up and configuring the Device Optimizing your project Running the App on the Device Let's dive into each step more comprehensively. Setting Up your Unity Workspace To start, go to the Unity website and create an account. If you don’t have one, . The personal edition should be fine for the vast majority of projects. download Unity Install the program in a location of your choice, and make sure you add in the Asset store. Start Unity and create your new project. Oculus Integration Your Editor will look similar to this: is a great starting point, and it comes with components that handle tracking the headset and controllers. Some settings still need tweaking so it knows what kind of headset to use. VR sample Navigate to → , find . Once found, select the tab and check the setting. You may see a similar setting below, but it may vary depending on the Unity version. Edit Project Settings XR Plug-in Management Android Oculus Your Unity Editor might look like this after the project is created and configured (depending on the Unity version) Now all set on a project level, let’s dive into device configuration. Setting Up and configuring the Device For development purposes, the Quest 2 headset has to be paired with the PC using a USB cable and to the Oculus phone app to enable some settings. Instructions are available on Meta’s website . Please follow the instructions from Oculus to pair the device to the PC and your mobile phone. Once your headset is paired, the key is to enable open the Oculus mobile app, and go to the Devices tab. Choose Headset Settings,  “Developer Mode” heading should be visible. Tap and enable the toggle. A prompt will appear to create a developer account. Follow the instructions from Oculus to turn on the developer mode. here Development mode, The device is ready to go, but before we run the game on the headset, let’s check some optimization recommendations. Optimizing your project This seems to be quite early to explore since we are just starting with Quest and Unity, but I think it’s important to start thinking about performance and quality early in your journey. Here is the list of areas I suggest you look at to make your experiences more performant: : In the Unity Player settings, under "XR Settings," set the stereoscopic rendering mode to "Single Pass Instanced" or "Single Pass Multiview." These modes optimize rendering for VR by reducing the rendering overhead. Set the stereoscopic rendering mode : Use the Unity Profiler to identify and optimize GPU performance bottlenecks. Look for excessive draw calls, overdraw, and high GPU utilization. Optimize shaders, reduce the number of polygons, and minimize texture usage. Optimize GPU performance : Unity's static batching combines multiple small meshes into a single, larger mesh, reducing draw calls. Mark small objects as static and enable static batching in the Unity Player settings under "XR Settings" to improve performance. Use static batching Quest 2 is a mobile VR device, so optimizing for mobile performance is crucial. Optimize textures by reducing their resolution and using compression formats suitable for mobile platforms. Use fewer materials and simplify shaders when possible. Optimize for mobile performance: : Avoid heavy scripting and computations that can strain the CPU. Optimize scripts by reducing unnecessary calculations, using object pooling, and avoiding expensive operations within Update loops. Use the Unity Profiler to identify CPU bottlenecks. Minimize CPU overhead : Occlusion culling prevents the rendering of objects that are not visible to the player, reducing GPU load. Unity provides built-in occlusion culling tools that you can use to optimize your scenes. Implement occlusion culling (Level of Detail): Implement Level of Detail for 3D models to reduce the polygon count of objects as they move further away from the player. This helps improve performance by reducing the GPU load. Use LOD : Remember that optimization is an iterative process! Regularly test your project on the Oculus Quest 2 hardware to identify performance issues. Use the Oculus Developer Hub and Unity Profiler to gather performance data and iterate on your optimizations. Test and iterate I suggest saving this list or bookmarking it simply because this could be useful later in your Quest 2 journey or useful at any point in your development. Let’s move on and finally see how to run the game on the headset. Running the App on the Device It’s time for the final step, and the most exciting part, running the app on the device. Get back to the Unity project and navigate to menu. This will open a window with various target platforms Unity can build for. Go with the option since the Oculus has Android as an underlying operating system. File/Build and Run Android From the settings listed in the left menu, the ones that should be modified for this first build are and . Set the compression to . From the dropdown menu, choose headset (the headset name will have an ID associated with the device). Click Refresh if there is no device listed. Make sure you add the current scene to the build by clicking button. Texture Compression Run Device ASTC Run Device Quest 2 Add Open Scenes Now is the time to try it yourself! Press . The build will be saved. Once the building is done and successful, the game will be saved to the headset and launched. Put on the headset and try it yourself! Build and Run Wrap up This is a baseline for creating virtual experiences for the Quest platform and headsets, but you can use it as a starting point and enable your imagination to build the most comprehensive and advanced games and experiences in VR. I think Quest 2 is a great device to start with and build for, we will see more advanced devices in the upcoming future, but the skills and knowledge you acquire while building for Quest 2 will help you advance in your developer journey.

Building An Oculus Quest 2 Compatible Game With Unity: A Beginner's Guide

Accessibility was always important, but lately, it has gained even more traction, and if you don’t know how to create accessible websites, you can’t really call yourself a . good front-end developer That’s a bold statement, I know, but it’s true. Just deal with it. Today we’ll look at one of the most basic elements of any website: a button. How do I make it accessible? Without further ado, let’s just jump into it. First and foremost, use a tag. You might ask, why not a for example? button div Here you have a few reasons tag is the better choice: button Semantic HTML is really important. It helps with code readability and also helps web crawlers better understand our website. It’s semantically correct. You don’t need to implement those behaviors (but if you use some CSS frameworks that reset styles for every element - remember to implement and states) It’s focusable and clickable by default. hover focus When you use any of the screen readers, it will announce the tag as, well, a button. It’s recognizable by screen readers. button Is that it? That would be great, wouldn’t it be? But no, the next thing we need to talk about is button content.  Here we can go three ways: Text Icon + text Only Icon Text Buttons In this case, the best thing we can do is to just use the text that is self-explanatory. We don’t need to put any additional attributes to make this kind of button accessible. There can be occasions where you’d be tempted to use to “overwrite” the text on the button. I strongly recommend you not to do it - it is against one of the WCAG principles. aria-label : You can check all the code that I use in this article here: NOTE Codepen <html lang="en">
  <body>
    <button>This is a test button</button>

    
    <button aria-label="This is a different button">This is another button</button>
  </body>
</html> Icon with Text Buttons The second case - icon with text is also quite simple. We can actually use the same technique as for the simple text, but with one additional thing - we’ll need to add attribute for the icon. This way, screen readers will ignore the icon and read only the text. aria-hidden=true svg One thing also worth doing is to add attribute as some of the old browsers focus on for some reason. focusable=false svg <button>
	<svg class="svg-icon" viewBox="0 0 20 20" aria-hidden="true" focusable="false">
		<title>The icon</title>		
		<path d="M9.719,17.073l-6.562-6.51c-0.27-0.268-0.504-0.567-0.696-0.888C1.385,7.89,1.67,5.613,3.155,4.14c0.864-0.856,2.012-1.329,3.233-1.329c1.924,0,3.115,1.12,3.612,1.752c0.499-0.634,1.689-1.752,3.612-1.752c1.221,0,2.369,0.472,3.233,1.329c1.484,1.473,1.771,3.75,0.693,5.537c-0.19,0.32-0.425,0.618-0.695,0.887l-6.562,6.51C10.125,17.229,9.875,17.229,9.719,17.073 M6.388,3.61C5.379,3.61,4.431,4,3.717,4.707C2.495,5.92,2.259,7.794,3.145,9.265c0.158,0.265,0.351,0.51,0.574,0.731L10,16.228l6.281-6.232c0.224-0.221,0.416-0.466,0.573-0.729c0.887-1.472,0.651-3.346-0.571-4.56C15.57,4,14.621,3.61,13.612,3.61c-1.43,0-2.639,0.786-3.268,1.863c-0.154,0.264-0.536,0.264-0.69,0C9.029,4.397,7.82,3.61,6.388,3.61"></path>
	</svg>
  Button with icon
</button> Icon Buttons The third case - icon only button is also pretty straightforward. We can just use on the tag, and the screen readers will ignore everything that’s inside the button (so, in this case, an icon). We don’t even need to add on the icon. aria-label button aria-hidden=true <button aria-label="Like">
	<svg class="svg-icon" viewBox="0 0 20 20" focusable="false" width="40px">
		<title>The icon</title>		
		<path d="M9.719,17.073l-6.562-6.51c-0.27-0.268-0.504-0.567-0.696-0.888C1.385,7.89,1.67,5.613,3.155,4.14c0.864-0.856,2.012-1.329,3.233-1.329c1.924,0,3.115,1.12,3.612,1.752c0.499-0.634,1.689-1.752,3.612-1.752c1.221,0,2.369,0.472,3.233,1.329c1.484,1.473,1.771,3.75,0.693,5.537c-0.19,0.32-0.425,0.618-0.695,0.887l-6.562,6.51C10.125,17.229,9.875,17.229,9.719,17.073 M6.388,3.61C5.379,3.61,4.431,4,3.717,4.707C2.495,5.92,2.259,7.794,3.145,9.265c0.158,0.265,0.351,0.51,0.574,0.731L10,16.228l6.281-6.232c0.224-0.221,0.416-0.466,0.573-0.729c0.887-1.472,0.651-3.346-0.571-4.56C15.57,4,14.621,3.61,13.612,3.61c-1.43,0-2.639,0.786-3.268,1.863c-0.154,0.264-0.536,0.264-0.69,0C9.029,4.397,7.82,3.61,6.388,3.61"></path>
	</svg>
</button> This is definitely the simplest and most supported solution. But what are the alternatives? The first one would be creating a or class in your CSS and then using it to create an “invisible” label. sr-only visuallyhidden TailwindCSS defines class as follows: sr-only .sr-only {
	**position: absolute;
	width: 1px;
	height: 1px;
	padding: 0;
	margin: -1px;
	overflow: hidden;
	clip: rect(0, 0, 0, 0);
	white-space: nowrap;
	border-width: 0;
} When you have this class in place, you can then use it like this: <button>
	<svg class="svg-icon" viewBox="0 0 20 20" aria-hidden="true" focusable="false" width="40px">
		<title>The icon</title>		
		<path d="M9.719,17.073l-6.562-6.51c-0.27-0.268-0.504-0.567-0.696-0.888C1.385,7.89,1.67,5.613,3.155,4.14c0.864-0.856,2.012-1.329,3.233-1.329c1.924,0,3.115,1.12,3.612,1.752c0.499-0.634,1.689-1.752,3.612-1.752c1.221,0,2.369,0.472,3.233,1.329c1.484,1.473,1.771,3.75,0.693,5.537c-0.19,0.32-0.425,0.618-0.695,0.887l-6.562,6.51C10.125,17.229,9.875,17.229,9.719,17.073 M6.388,3.61C5.379,3.61,4.431,4,3.717,4.707C2.495,5.92,2.259,7.794,3.145,9.265c0.158,0.265,0.351,0.51,0.574,0.731L10,16.228l6.281-6.232c0.224-0.221,0.416-0.466,0.573-0.729c0.887-1.472,0.651-3.346-0.571-4.56C15.57,4,14.621,3.61,13.612,3.61c-1.43,0-2.639,0.786-3.268,1.863c-0.154,0.264-0.536,0.264-0.69,0C9.029,4.397,7.82,3.61,6.388,3.61"></path>
	</svg>
	<span class="sr-only">Like</span>
</button> And as you can see and hear, it works as expected (I strongly recommend you to try focusing on the buttons with VoiceOver turned on - it really helps in understanding the things that we are doing here). Another solution is a little bit more complicated. We need to use on the button and then provide a label inside. Be aware that even though the label will be hidden, attribute will still be able to access it. aria-labelledby hidden labelledby It would look like this: <button aria-labelledby="likeBtn">
	<svg class="svg-icon" viewBox="0 0 20 20" aria-hidden="true" focusable="false" width="40px">
		<title>The icon</title>		
		<path d="M9.719,17.073l-6.562-6.51c-0.27-0.268-0.504-0.567-0.696-0.888C1.385,7.89,1.67,5.613,3.155,4.14c0.864-0.856,2.012-1.329,3.233-1.329c1.924,0,3.115,1.12,3.612,1.752c0.499-0.634,1.689-1.752,3.612-1.752c1.221,0,2.369,0.472,3.233,1.329c1.484,1.473,1.771,3.75,0.693,5.537c-0.19,0.32-0.425,0.618-0.695,0.887l-6.562,6.51C10.125,17.229,9.875,17.229,9.719,17.073 M6.388,3.61C5.379,3.61,4.431,4,3.717,4.707C2.495,5.92,2.259,7.794,3.145,9.265c0.158,0.265,0.351,0.51,0.574,0.731L10,16.228l6.281-6.232c0.224-0.221,0.416-0.466,0.573-0.729c0.887-1.472,0.651-3.346-0.571-4.56C15.57,4,14.621,3.61,13.612,3.61c-1.43,0-2.639,0.786-3.268,1.863c-0.154,0.264-0.536,0.264-0.69,0C9.029,4.397,7.82,3.61,6.388,3.61"></path>
	</svg>
	<span id="likeBtn" hidden>Like</span>
</button> Setting the on the is important because that’s how we can access the label from the attribute. id span labelledby All three solutions work the same. That’s why my favorite is just setting the , it is the simplest solution. aria-label These were the most important accessibility adjustments you can make to ensure your buttons work well with screen readers. But what about people with visual impairments that do not use screen readers? Here we have two additional things to take care of, and we’ll be all set. Sizing First, let’s talk about sizing. In the WCAG guidelines, there is a criterion 2.5.5 - Target Size. It’s described as follows: The size of the target for pointer inputs is at least 44 by 44 CSS pixels. There are a few exceptions, and you can see those on the screen now. They are not relevant in this specific case. So let’s ensure that our buttons are, in fact, big enough. I’m not a fan of using pixels; I’d much rather go with or . This will also help if the user changes his base font size - the button will still be sized properly. rems ems button {
  min-height: 3rem;
  min-width: 3rem;
} I used as usually the root font size is , so gives us . But if the user zooms in to, let’s say, , the button will be larger. 3rem 16px 3rem 48px 24px Ok, with that out of the way - let’s handle the last thing I want to talk about today - contrast. Contrast WCAG guidelines say: The visual presentation of text and images of text has a contrast ratio of at least 4.5:1 - for AA success criterion, and 7:1 for AAA criterion. The best tool to use here is the contrast checker by WebAIM https://webaim.org/resources/contrastchecker/ You can just put your button color there, and you’ll get the text color and vice versa. A simple yet great tool. In the case of my examples, let’s say I wanted a green button. As you can see, white text fails all of the criteria, but black should be OK. As you can see, while I’m scrolling through the colors, the contrast ratio changes, and also different criteria are passing. With straight black, we get a contrast of over 10 to 1. So that’s going to work! And that’s it! Those are the things that you can do to make your buttons accessible. I hope you like it. If you did, consider following me on Twitter, , and LinkedIn. More front-end and accessibility-related content are on the way. Dev.to

A Quick Guide on How to Create Accessible Buttons in HTML

Xcode Cloud is a CI/CD service provided by Apple that allows developers to easily run tests, build and distribute iOS applications, and edit workflows directly from Xcode. It was first announced as a beta version at WWDC21 and then became generally available at WWDC22 with a paid plan starting in the summer of 2022. With Xcode Cloud, developers can easily automate the building and testing of their iOS applications, saving time and effort. One of the key features of Xcode Cloud is the ability to resolve dependencies automatically. If you’re using the Swift Package Manager, Xcode Cloud will look at the file to resolve dependencies. However, if you're using other dependency managers like Cocoapods or Carthage, you'll need to install them first. This is where Bundler comes in handy. Package.resolved Bundler is a dependency manager for Ruby that makes it easy to manage dependencies and their versions. It allows developers to specify the exact version of each dependency required by their project and resolves any conflicts between them. Bundler is a best friend of iOS developers since many iOS projects use Ruby-based tools like Fastlane and Cocoapods. To use Bundler with Xcode Cloud, you can create a directory named under the project root directory and create a custom script there to execute during workflow execution. Xcode Cloud executes custom scripts at specific points during the workflow. For example, the script is executed after Xcode Cloud clones a Git repository. ci_scripts ci_post_clone.sh Here is an example script for resolving dependencies: ci_post_clone.sh #!/bin/sh

cd ..

echo ">>> SETUP ENVIRONMENT"
echo 'export GEM_HOME=$HOME/gems' >>~/.bash_profile
echo 'export PATH=$HOME/gems/bin:$PATH' >>~/.bash_profile
export GEM_HOME=$HOME/gems
export PATH="$GEM_HOME/bin:$PATH"

echo ">>> INSTALL BUNDLER"
gem install bundler --install-dir $GEM_HOME

echo ">>> INSTALL DEPENDENCIES"
bundle install

echo ">>> INSTALL PODS"
bundle exec pod install In this script, we first set up the environment by adding and to . Then we install Bundler and run to install all required gems specified in the . Finally, we run to install any dependencies managed by Cocoapods. GEM_HOME PATH ~/.bash_profile bundle install Gemfile bundle exec pod install It’s worth noting that at the time of writing this article, there appears to be an issue with Cocoapods’ compatibility with Xcode 14.3. To resolve this, you may need to use a solution from this thread: . This involves adding a custom row to the to add all changes from the master branch before it was released: https://github.com/CocoaPods/CocoaPods/pull/11828 Gemfile gem 'cocoapods', :git => 'https://github.com/CocoaPods/CocoaPods.git', :branch => 'master' Conclusion In this article, we discussed how to configure Bundler and Cocoapods for Xcode Cloud. With the help of Bundler, managing dependencies for iOS applications has become much easier. We also highlighted a current issue with Cocoapods’ compatibility with Xcode 14.3 and provided a solution to resolve it. Also published . here

Stories, News & Mentions about GUIDE

Guide’s Stories on HackerNoon

Guide's News & Mentions