In this article, we will explore, all those aspects, stories, and interesting facts behind these two.

Let’s imagine, you buy a brand new 1TB hard drive, happily boasting about all that extra space for your photos, videos, and games. But when you plug it in and check the capacity, it shows up as only about 931GB.

Feel Scammed? …. Nope, not really!

Welcome to the confusing yet interesting story of Gigabytes (GB) vs. Gibibytes (GiB).

Background information: Binary vs Decimal

The root of the confusion lies in how computers and humans think about numbers. As we all know computers use the binary system (base-2), where everything is based on powers of two. We, humans, however, generally use the decimal system (base-10) using powers of ten. That is where the whole thing gets confusing.

Before we dive into details, let’s understand a few key units and their conversion:

• Kilobyte (KB): Technically it means 1024 bytes (2¹⁰). Note that this is again “Byte” and not “Bit”. 8 Bits = 1 Byte. But for making it simple, 1000 bytes was easier to work with.
• Megabyte (MB): This should be 1024 KB(2¹⁰), but marketing-wise, it was easier to deal with 1000 KB and it was used.
• Gigabyte (GB): Referring to the above trend it is equivalent to 1024 MB, but often labeled as 1000MB.

We can understand that a metric/decimal “kilo” equals 1,000, but a binary “kilo” equals 1,024.

This difference isn’t huge at smaller scales, but it compounds when grows bigger such as TB (Terrabyte), PB (Petabyte), and so on…

The introduction of the letter “i” by IEC in these Units

To avoid this confusion, The IEC (International Electrotechnical Commission) came up with a new unit for binary systems. They created new units to definitively represent powers of two (binary)

• Kibibyte (KiB): 1024 bytes
• Mebibyte (MiB): 1024 KiB
• Gibibyte (GiB): 1024 MiB
• Tebibyte (TiB): 1024 GiB, and so on…

The aim was to have a distinction between decimal metrics such as KB, MG, GB, etc., and binary metrics. Your 1TB hard drive should be labeled 1TB (decimal systems) or 931 GiB (binary system). Easy, right?

Chaos does not stop here…

The class action lawsuit against major hard-disk and storage manufacturer

Because of the discrepancies mentioned above like 1TB = 931 GB instead of 1000 GB — The class action lawyers sued five flash memory card makers, alleging breach of contract, fraud, and violations of California’s unfair competition laws. This case highlighted the real-world impact of the GB/GiB mess.

So where do we stand today?

Unfortunately, there’s still no single standard. Here’s what you’ll usually encounter:

• Hard Drives/Flash Storage: Listed in decimal (GB = 1000 MB) but with an actual capacity that is closer to the binary value (GiB).
• RAM: Uses accurate binary measurements (GiB)
• Operating Systems: A mixed bag! Some show decimal GB and some GiB. Pay attention to units.

Tips for the Savvy Tech User

1. Check the Units: Look for whether a capacity is specified as GB or GiB.
2. Do your Math: When in doubt, remember 1GB is about 0.93 GiB.
3. Support Accurate Labeling: Push for companies to adopt unambiguous labeling. Consumer awareness matters!

The Final Word

The GB vs. GiB saga is a reminder of how the technical world sometimes clashes with a traditional use case. While it might be a minor annoyance for most, understanding the difference sheds light on the importance of accurate standards and the occasional battle between technical precision and established marketing practices.

The post Gigabytes vs. Gibibytes: Decoding the Storage Capacity Confusion appeared first on Algorithms.

Isn’t it?

But before diving into the magic behind this mystery checkbox, let’s take a look at CAPTCHA (Completely Automated Public Turing test to tell Computers and Humans Apart). It was designed to differentiate between bots and human activities over the internet. This was to prevent websites and other online services from being spammed by bots.

Note: The term CAPTCHA was coined by Luis von Ahn and Manuel Blum at Carnegie Mellon University in 2000.

Early days of CAPTCHA — Text-Based Puzzles

The concept behind the checkbox came about in the late 1990s. Initially, CAPTCHA presented users with distorted text that they had to recognize and input correctly to prove that they were human. Most of you would be familiar with these fonts and texts:

The idea was very simple — humans are good at reading slightly warped text, but bots at that time were not. While we all used to get annoyed by these texts, these early CAPTCHAs were relatively effective because bots were not smart yet.

Bots get smarter…

As bots get smarter, the above method of identifying humans, started becoming ineffective. Google acquired reCAPTCHA in 2009. They massively expanded the concept by using scanned images of real-world text (from books and street signs). Again who is not annoyed by this other type of test that humanity has to go through to prove they are human 😉

Over time, Captcha has undergone numerous iterations to maintain its effectiveness with the advancing intelligence of bots.

Birth of “I’m not a robot” check box

Apart from the main purpose which is identifying bots, one of the common things was that it was getting hard for humans too and therefore annoying. To address this challenge, Google introduced the “No CAPTCHA reCAPTCHA” in 2014, which later evolved into the “I’m not a robot” checkbox we see today.

With this latest advancement in reCAPTCHA, it has become so streamlined that you may question its efficacy, wondering if it’s genuinely functional or just there for amusement! 😄

This Google solution is like saying: “You don’t always need a complicated answer to solve tricky problems. Sometimes, a simple solution can work just as well.”

When you look at that checkbox up there, you might wonder if it works.

But once you know the secret behind it, you’ll be amazed at how effective it is!

How does the “I’m not a robot” checkbox work?

When you see this “I’m not a robot” checkbox, it’s not merely a simple checkbox you check with your mouse click. Behind the scenes, a complex algorithm is evaluating your interactions to determine whether you’re human or not. So, let’s deep dive into — how does it work?

1. Analyzing User Behavior [mouse hover and click behavior]:

As you hover over the checkbox, move your mouse, and interact with the webpage, an invisible web of data is being collected. Every movement, click, and pause is carefully analyzed to distinguish human behavior from bot actions.

This is also called “Behavioral Biometrics”. This includes how you move your mouse, how long you hover over elements, and whether your movements exhibit human-like patterns. Bots often exhibit rapid, precise movements, whereas humans tend to move more erratically and with variations.

2. Invisible Challenges:

In some cases, the checkbox may present you with invisible challenges, such as tracking your mouse movements while you navigate through the page. These challenges are designed to trick automated scripts purposefully that attempt to bypass the checkbox by mimicking human behavior.

3. Machine Learning:

Solution without machine learning?? Naeh it’s not cool 😀

Behind the scenes, machine learning algorithms continuously analyze vast amounts of data to improve the accuracy of distinguishing humans from bots. These algorithms learn from patterns in user behavior and adapt over time to stay ahead of evolving bot technologies. So this CAPTCHA has become self-evolving and therefore would always be ahead in the game 😉

4. Confidence Score:

Based on the data collected and analyzed, the system generates a confidence score that indicates the likelihood of whether you’re human or not. If the score surpasses a certain threshold, you’ll pass the verification without any additional steps. This is like every machine learning algorithm you train.

However, if there’s any uncertainty, you may be prompted to complete further challenges, such as selecting specific images or solving puzzles like old style.

Isn’t it genius?

Now, every time you are prompted with this checkbox and you click, you know how complex things have happened behind the scenes.

The post How does I’m not a robot” checkbox work? appeared first on Algorithms.

Think of them as maps for complex systems. They show how information flows, where decisions are made, and how different parts work together. It’s like having a magic decoder ring that unlocks the secrets of how things tick.

Static diagrams are great for conveying information, but sometimes you need a little extra pop. Imagine visualizing a data flow with lines that flow in real-time or highlighting a specific connection with a pulsating arrow. This is where the magic of animated lines in draw.io comes in!

Following is a sample diagram created by an AWS Architect who is trying to show the flow of information across different systems/modules/apps in AWS. Note that this is a dummy sample created and not for a specific application

Now, the same diagram is re-created where every static arrow is replaced with an animated pulsating arrow like this:

In my opinion, the second GIF file looks cooler than the first one.

However, It would be over-enthusiastic to say that the second one gives more clarity than the first one as I do not have any scientific research data to support my argument.

How to add animated flow lines in Draw.io diagrams

Today, we’ll explore how to easily add animation to your draw.io diagrams, taking your architecture, data flow, pipeline, or any type of diagrams to a whole new level.

The Power of Flow Animation:

draw.io offers a built-in feature called Flow Animation. This allows you to animate the path of any connector (line) in your diagram, mimicking the flow of data, information, or processes. It’s perfect for:

• Visualizing workflows: Showcase how data moves through different stages.
• Creating engaging presentations: Grab your audience’s attention with visually appealing animations.

Let’s Get Animated!

Follow these simple steps to unleash the power of animation:

1. Create your diagram: Build your masterpiece using draw.io’s diverse shapes and connectors.
2. Select the connector(s): Click on the line you want to animate. If you want to select all of them together, then you can right-click on the diagram and click on Select Edges [Cmd+Shift+E] and all the connectors will get selected automatically
3. Activate Flow Animation: Go to the Style tab and click Properties. Scroll down and check the Flow Animation box.
4. Customize (optional): Play with animation speed, color, and style in the Style tab.

All the above steps are shown in the below gif:

Remember: Animation is a powerful tool, but use it wisely. Over-animation can be distracting, so focus on key elements and maintain clarity.

How to export Animated Draw.io diagram as a GIF:

Now you have created this animated diagram but you want to export it as a gif so that you can show this animated video in your presentation and impress your boss 😃.

Exporting as a GIF file is not as easy as it was to create. Draw.io has refused to provide an option to export it as a GIF. But do not worry, there are a couple of workarounds to export your animated diagram as a GIF file.

Workaround 1: Export as HTML file and RecordIt tool

Step 1: Export your diagram as HTML file.

Step 2: Open your HTML file

Step 3: Now, using the RecordIt application, you can record the area that you want to capture in your gif file

Step 4: Once the recording is done, you should be able to see the recording video file which can be saved as a gif file too.

Workaround 2: Screen record and convert recorded MP4 to GIF

Step 1: Using any screen recording software such as Quick Time player

Step 2: Using any online tool or desktop tool, convert your MP4 video or any other format video to a gif file.

Conclusion:

With these tips and a little creativity, you can transform your static diagrams into engaging, animated storytelling tools. So go ahead, unleash your inner animator 😃 , and let your draw.io diagrams truly come alive!

Do you have any creative uses for animated lines in draw.io?

Share your ideas in the comments below!

The post Two simple Steps to Animate your Draw.io diagram appeared first on Algorithms.

Dear Enthusiast,

Personally, this is one of my favourite algorithm. Before we jump in to the maths and computer science part of this algorithms, first let’s understand this algorithm an analogy.

What is 0/1 Knapsack Problem Algorithm

We will first try to understand what kind of problem does it solve. We will understand with an analogy called – The Treasure Hunter's Dilemma
Imagine you are a treasure hunter on a quest to find the most valuable treasures in a limited amount of time. Your challenge is to decide which treasures to pick, considering their weights and values, while abiding by the weight capacity constraints of your treasure bag. Limited space, indicating the maximum weight your treasure chest can hold.

Treasures	Weight	Value	What is Knapsack’s problem
Gold coins	5	4
Jewels	6	3
Artifacts	4	8
Rare gems	8	10
Antique manuscripts	1	6
Precious metals	9	6

Objective

Now the objective is to pick up those items which are still within your treasure bag capacity maximize the total value of the treasures, where each treasure contributes to your overall wealth or value. Such problems are solved using Knapsack Algorithm.
Before solving, lets understand a bit of history about Knapsack Algorithms

History – Origin of Knapsack Problem

The term “knapsack” itself has its origins in the 17th century, derived from the German word “knapzak” which translates to “food bag.” Soldiers during that time would carry rations in a bag on their backs, facing the dilemma of selecting the most essential items without exceeding the bag’s capacity. So now you understand.. why “Knapsack” problem.

The Knapsack Problem became more formally recognized in computer science during the mid-20th century when researchers started to explore optimization problems and algorithms. Its formulation and study gained momentum as part of the broader field of combinatorial optimization.

What is the significance of 0/1 in Knapsak Problem

The term “0/1” in the context of the Knapsack Problem refers to the restriction placed on the items that can be included in the knapsack. Specifically, it means that for each item, you have a binary (0 or 1) choice — either include the entire item in the knapsack or exclude it completely. There is no option to include a fraction of an item.

This restriction distinguishes the 0/1 Knapsack Problem from the Fractional Knapsack Problem, where items can be divided and a fraction of an item can be included in the knapsack. In the 0/1 Knapsack Problem, the decision for each item is more straightforward: it’s an all-or-nothing choice.

Solving the Treasure Hunter’s 0/1 Knapsack Problem:

In Knapsack problems, there can be two types of items. They are basically dependent of types of items you are choosing. Imagine if the items are divisible like grains NOT in a packet then you can pick those items partially. In those cases, Knapsack problmes are really not useful.

1. Brute Force Approach:

Trying out all possible combinations of treasures to see which combination gives the maximum value.
However, as the number of treasures increases, this approach becomes impractical.
The time complexity of the brute-force approach to solving the Knapsack Problem is exponential, specifically O(n*2^n), where ‘n’ is the number of items. The reason for this high complexity lies in the nature of the brute-force method.

2. Greedy Approach:

The possible greedy strategies to the Knapsack problem is:

1. Choose the item that has the maximum value from the remaining items; this increases the value of the knapsack as quickly as possible.
2. Choose the lightest item from the remaining items which uses up capacity as slowly as possible allowing more items to be stuffed in the knapsack.
3. Choose the items with as high a value per weight as possible.

This approach works well for fractional selections if partial inclusion of treasures is allowed. Ofcourse it has a better complexity than the brute force method. It is O(n*Log(n))

3. Dynamic Programming Approach:

Create a table to store intermediate results for different subproblems.
Use a recurrence relation to fill in the table and find the optimal solution efficiently.
This approach is suitable for the 0/1 Knapsack Problem, ensuring that a treasure is either included or excluded.

Let’s first make some assumption here. I am going to pass the input in the following format. It is going to be in the form of a list of tuples. Where each tuple would contain the name of the item, weight and its value. So the input array would like something like this:

[("Jewels", 2, 4) , ("Diamond", 3, 6)....]

and the second parameter would be the total capacity of the bag i.e. an Integer value.

This algorithm works something like filling this matrics to maximize the outcome of chosen items.

knapsack problem solving [Source wikipedia]

def knapsack_problem(items, capacity):
    '''
    knapsack_problem _summary_

    _extended_summary_

    Args:
        items (_list_): List of a tuple - (Item name, weight, value)
        capacity (_integer_): The maximum weight/capacity of the bag 

    Returns:
        _tuple_: Maximum weight could be fit in the sack and list of
                 items which are chosen for that
    '''
    num_items = len(items)
    
    # metrics with all zeros to fill all the knapsack values
    knapsack_values = [[0] * (capacity + 1) for _ in range(num_items + 1)]
    
    for i in range(1, num_items + 1):
        item_name, item_weight, item_value = items[i - 1]

        for c in range(capacity + 1):
            if item_weight > c:
                knapsack_values[i][c] = knapsack_values[i - 1][c]
            else:
                knapsack_values[i][c] = max(
                    knapsack_values[i - 1][c],
                    knapsack_values[i - 1][c - item_weight] + item_value,
                )
    max_value, selected_items = knapsack_values[num_items][capacity], []
    i, c = num_items, capacity
    while i > 0 and c > 0:
        if knapsack_values[i][c] != knapsack_values[i - 1][c]:
            selected_items.append(items[i - 1][0])
            c = c - items[i - 1][1]
        i = i - 1
    return max_value, list(reversed(selected_items))

How to run the knapsack problem function

This is how you can pass the input parameters in the above function and get the expected result.

# Example usage:
items_list = [
    ("Gold coins", 5, 4),
    ("Jewels", 6, 3),
    ("Artifacts", 4, 8),
    ("Rare gems", 8, 10),
    ("Antique manuscripts", 1, 6),
    ("Precious metals", 9, 6)
]
knapsack_capacity = 16

result = knapsack_problem(items_list, knapsack_capacity)
print("Maximum Value:", result[0])
print("Selected Items:", result[1])

Result of knapsack problem

Real-world Applications of the Knapsack Problem:

Resource Allocation in Project Management: Optimizing the allocation of resources such as time, budget, and personnel to maximize project value.
Financial Portfolio Optimization:Selecting a combination of investments with different returns and risks to maximize the overall portfolio value.
Data Compression:Choosing a subset of files to compress within a given storage limit, optimizing for compression ratio and preserving important data.

The post Knapsack Problem: Algorithms, Real-world Applications, and Python Code appeared first on Algorithms.

Confirmation bias
image source : https://www.simplypsychology.org/confirmation-bias.html

Why Confirmation Bias Poses a Challenge:

Challenging one’s own thought processes or beliefs can be an uncomfortable endeavor for individuals. It is deeply ingrained in human nature to seek validation and prove oneself right at every turn. In the age of the internet, a vast sea of information is readily accessible to support and reinforce personal beliefs, often with far-reaching consequences for society. This phenomenon has had a profound and, at times, catastrophic impact on our collective well-being.

In today’s world, whether an ideology benefits society or not, those who subscribe to it are constantly bombarded with a barrage of materials such as news, articles, posts, speeches, and more via the internet and social media. This unrelenting reinforcement of their beliefs has given rise to the alarming trend of radicalizing individuals for political or religious purposes, all the more prevalent due to the ubiquitous presence of the internet and social media on mobile devices. As a result, individuals are more inclined to embrace fake news if it aligns with their preconceived ideologies, often at the expense of accepting verifiable, objective information.

Consider, for instance, the notion of a flat Earth, which lacks scientific substantiation. Despite the absence of empirical evidence, there exists a multitude of articles, videos, and posts that lend credence to this theory, along with a dedicated following who proudly identify themselves as “The Flat Earth Society.”

Similarly, a group of individuals denies the existence of issues like “global warming” or “climate change,”. They think these ideas are made up to control various aspects of how we live. Their convictions grow stronger as they are continually exposed to content over the internet that validates their belief system. The sheer ease of accessing such information further perpetuates the trend of isolating individuals, making it increasingly simple to manipulate, and radicalize people based on various not-scientifically proven claims. Paradoxically, the internet, often regarded as a boundless source of knowledge, can, in practice, foster ignorance rather than enlightenment.

Case Study 1:

A paper published by R. DuBroff in Nov 2017, highlights — how an expert opinion can, too, be confirmation-biased and therefore can not be trusted. The Paper illustrates 6 examples of confirmation bias that appear to distort the evidence to substantiate the opinions and recommendations of experts. This sounds scary, isn’t it? The experts in these cases tried to collect the “only” data points that proved their theory and ignored the rest. Chances of such unreliable information, recommendations, and opinions are increasingly high. Confirmation bias is one of the main reasons for this.

Case Study 2:

This study was done quite recently. This was published in Nov 2021 illustrating how confirmation bias views on the internet induced polarization during Covid 19. This study draws on how manifestations of confirmation bias contribute to the development of echo chambers in supply chain information sharing during the COVID-19 pandemic. While social media played a big role in providing a helping hand to the needy, one can not deny its role in polarizing the views on the COVID-19 pandemic.

Here I am quoting, as-is, the abstract from this case study published.

My observation:

During the COVID-19 pandemic, there was so much information being shared about the coronavirus, its origin, Vaccines, etc. I could broadly categorize my surroundings into two groups —

1. one who believed the coronavirus pandemic was a political stunt across the world by the big political leaders and corporations.
2. The second was too scared and considered it the end of the world.

There was a massive information circulated over social media to form your opinion and reinforce it in whichever group you want to belong to. The “truth”, perhaps, lies in-between/far from the above two beliefs.

During the pandemic, there was enough content being produced over the internet and social media to support the beliefs of both groups. One can form one’s opinion and reinforce it in whichever group one wants to belong to. But the “truth”, perhaps, lies in-between/far from the above two beliefs. During the year 2020–21, the Pandemic caused a huge loss in terms of human life as well as the economy. There was so much loss due to the misinformation being shared across social media platforms and tools such as Facebook, Twitter, wiki, etc. Due to the misinformation shared about the virus, vaccinations, precautionary measures, etc., huge effort had to be spent in order to convince people to follow them.

Discussion

In this article, mostly, I have been discussing and highlighting all the challenges that occur due to Confirmation Bias. The impact of confirmation bias has much more than I have outlined here. Although I do not have a perfect solution to eradicate the confirmation bias view from the internet, before thinking of a solution, I would like to categorize this bias into different levels where they are induced and how could “possibly” be reduced by using Knowledge Management tools such as Semantic Web, Linked Open Data Knowledge repository. Although the removal of confirmation bias completely is close to impossible, the following are a few solutions that can be tried out to reduce the confirmation-biased information available over the internet.

Possible Solutions

1. Search Engine’s Algorithms and Open LinkedData

The very first category is “serving content to the users based on their likes and dislikes”. At first, however, it may sound like a great feature but not always.

An Example: You like or admire a political ideology called “X”. You simply agree with a few of their actions in the past and hence you incline this particular ideology “X”. Search engines, social media platforms, etc. start serving you content that directly or indirectly supports the same ideology. Eventually, it will condition you to become a believer, simply because you were exposed to only those contents which are in favor of “X”. You did not get a chance to evaluate against other ideologies available because they are not automatically served you. Sometimes, even worse, search engines start serving you negative about other ideologies that make you believe even more strongly in the one that is your favorite. Although, at first, as a user, you had a slight inclination towards the ideology “X” but, now you are completely biased because of such content served by the computers.

In my opinion, as it is well quoted in one of the papers published in 2018 — Baeza-Yates 2018 — “Any remedy for bias starts with awareness of its existence”. The developers must be trained and made aware of such biases and their consequences. Awareness about “confirmation bias” and its impact would be the first step towards finding the solution. Search engines, social media platforms, or tools algorithms should not apply any implicit filters before serving content to the users based on their past likes or dislikes. Sometimes, users are unknowingly trapped in a confirmation bias view and isolate themselves into some ideology.

As quoted in a paper published in 2011, Heath and Bizer, — “Just as the World Wide Web has revolutionized the way we connect and consume documents, so can it revolutionize the way we discover, access, integrate, and use data”. LinkedData uses the same principle as search engine indexing. Search engines can use Open LinkedData to bring information and facts about the topic shared by the experts and publishers. The results from these experts can help in reducing the confirmation bias as these results are not influenced by the user’s behavior rather it is based on an expert’s opinion.

2: Use of Semantic Web and Artificial Intelligence

Knowledge representation using semantic web technology can help organize all the information available over the internet. Organized knowledge representation can help “Artificial intelligence” to perform better and provide users with information which are “facts” or at least closure to “facts”. Whether or not the information is “fact”, can be categorized based on — multiple factors such as the publishers of the content, the organization which has published it, etc. Fact-checking processes using the Semantic Web and Artificial Intelligence can be implemented.

I will be delighted to hear your opinion about this challenge, its consequences, and its solutions. Again, the whole idea of this article is “NOT TO BE CONFIRMATION BIASED” while engaging any kind of research, articles, etc. Therefore, different thoughts and ideas are more welcomed than simply seconding my opinion on this topic 😂

References

• Baeza-Yates 2018. Bias on the Web. Communications of the ACM, 61(6).
• Modgil, Sachin et al. A Confirmation Bias View on Social Media Induced Polarisation During Covid-19. Information Systems Frontiers (2021): 1–25.
• Meppelink, Corine S. et al. “I was Right about Vaccination”: Confirmation Bias and Health Literacy in Online Health Information Seeking.” Journal of Health Communication 24 (2019): 129–140.
• DuBroff, Robert. “Confirmation bias, conflicts of interest and cholesterol guidance: can we trust expert opinions?” QJM : monthly journal of the Association of Physicians 111 10 (2018): 687–689 .
• Berners-Lee, Hendler, and Lassila. 2001. The Semantic Web. Scientific American, 284(5).
• Heath and Bizer. 2011. Chapter 1 of Linked Data: Evolving the Web into a Global Data Space. Synthesis Lectures on the Semantic Web: Theory and Technology, 1:1, 1–136. Morgan & Claypool.

The post The Internet: An Endless Reservoir of Knowledge and “Confirmation Bias” appeared first on Algorithms.

It immediately caught my attention as it is so simple yet powerful tool. Just by exploring its simple documentation by Google Cloud, I could start creating one for my project.

In the Data Quality Monitor repository, if you look in the readme file, there is a cloud shell button, clicking on which you will be automatically taken to your Google Cloud account, your cloud shell will be instantiated and the repository will be cloned in the workspace and interactive tutorial will be launched as shown in the below picture.

I figured, “Why not share this gem with all of you?” So, without further ado, let’s dive into what an interactive walkthrough in CloudShell is all about.

What is an interactive walkthrough in Cloud Shell?

An interactive walkthrough in Cloud Shell is a step-by-step guide to using Cloud Shell and Google Cloud products to complete a specific task. Walkthroughs are written in Markdown and can include text, code, images, and videos. Users can run commands directly from the walkthrough to follow along and perform or learn any action that the provider wants them to perform.

Why create an interactive walkthrough for your GitHub repository?

There are several benefits to creating an interactive walkthrough for your GitHub repository:

1. Reduce the installation/learning curve: Interactive walkthroughs can help users get started with your project quickly and easily. By providing step-by-step instructions, you can help users learn how to use your project’s features and avoid common pitfalls.
2. Increase engagement: Interactive walkthroughs are more engaging than traditional documentation. By allowing users to interact with the environment and see the results of their actions, you can help them learn more effectively.
3. Improve your project’s documentation: Interactive walkthroughs can be a valuable addition to your project’s documentation. They can help you explain complex concepts clearly and concisely, and they can also provide users with hands-on experience.

How to create an interactive walkthrough for your GitHub repository

To create an interactive walkthrough for your GitHub repository, follow these guidelines:

1. Create a new Markdown file in your repository.
2. In the Markdown file, you can add HTML as well as Google Cloud-provided markdown styles, walkthrough directives, etc. Walkthrough directives are HTML-like pre-defined tags that are used to create certain UI elements or perform certain actions in the Google Cloud shell window.

A few important directives examples:

1. Open file walkthrough directive:

For example: if you have a config.json file in your repository and you want the user to open that file and modify it accordingly. Then you can use the Open file directive to create a link in the tutorial to open that particular config file in editable format in the cloud shell window.

Click to open the config file to edit 
<walkthrough-editor-open-file filePath="FILE_PATH">Open File</walkthrough-editor-open-file>

The above markdown displays like below:

2. To create or select an existing project:

To create a section or widget for the user to be able to select an existing project or create a new one, you can use the create project directive.

<h2 id="set-up-a-project" data-text="Set up a project">Set up a project</h2>
<ol>
   <li>
      <walkthrough-project-setup billing></walkthrough-project-setup>
   </li>
</ol>

`Note:` In order to be able to install DQM successfully, you need to have billing enabled for your project.

The above markdown code will turn into the following widget on your interactive tutorial page:

3. To get the selected project ID or project name:

In your tutorial, if you want to get the selected project name or ID, you can use one of the following directives i.e.

<p><strong>Project Name:</strong> <walkthrough-project-name/>
<strong>Project ID:</strong> <walkthrough-project-id/></p>

After running the above directive, you can see your selected project ID and project name.

3. Conclusion Trophy:

At the end of the tutorial, if everything is successful, you want to give a trophy to the user :); you can use the conclusion trophy directive as shown below code:

<h2>Congratulations</h2>
<p>
   <walkthrough-conclusion-trophy></walkthrough-conclusion-trophy>
</p>
<p>You’re all set!</p>

The above code will look something like this as shown in the below picture:

To know all available directives and how to use them, you can refer to Google Cloud documentation here: https://cloud.google.com/shell/docs/cloud-shell-tutorials/directives-cloud-shell-editor

Markdown Extensions:

Cloud Shell tutorials support Markdown extensions to expand the capability of the Markdown language itself. To create a code block formatting you can use one of the extensions as shown in the below example:

If you want to run a shell script in cloud shell:

```sh
     gcloud config set project <walkthrough-project-name/>
```

In the above example, I have used extended markdown to write a shell script that can be run in a cloud shell. I have also used one of the directives to get the selected project name.

The above markdown code will look something like shown in the below picture where the entire command can be either copied by clicking on the copy button in the top right corner or can be directly copy-pasted to the terminal. All you need to do is “press” enter to execute.

Refer to this Google documentation page for more extended features: https://cloud.google.com/shell/docs/cloud-shell-tutorials/markdown-extensions

How to launch an interactive tutorial:

To use an interactive walkthrough in Cloud Shell, follow these steps:

• Open Cloud Shell.
• Run the following command

cloudshell launch-tutorial tutorial.md

Tutorial.md is the file where you have written the interactive tutorial in markdown format as explained above. After running the above code, an interactive tutorial will be launched on the right side of the screen, and on the left side, you can see the cloud shell window to work along.

Finally, you can find the entire tutorial file that I created for my project here in this repository.

https://github.com/google/data-quality-monitor/blob/main/deployment/gc_interactive_tutorial.md

How to create a Cloud Shell button for my GitHub Repository

If you want to generate a cloud shell button like shown in the below picture for your GitHub repository, you can follow the below steps explained.

Open this link and at the bottom of the page, there is a form available like below. Fill in the necessary details and click on “generate snippet”. The code snippet is ready to copy and paste it where ever you want.

The generated button will automatically open your Google Cloud console — if already logged in — otherwise it will ask you to log in. After successful login, it will launch the cloud shell and clone the repository [the one that you have provided while generating the snippet] in your cloud shell workspace. Once cloning is done, it will launch the tutorial.md file or whatever interactive markdown file you provided while creating the snippet.

That’s all ! Your user is good to continue with your tutorial now.

Tips for creating effective interactive walkthroughs

Here are some tips for creating effective interactive walkthroughs:

• Keep your walkthroughs concise and focused on a single task. Users should be able to complete the task in a few minutes.
• Use clear and concise language. Avoid using jargon or technical terms that your users may not understand.
• Provide step-by-step instructions. Don’t assume that your users have any prior knowledge of the task.
• Use code snippets and images or videos to illustrate your instructions. This can help your users to understand and follow the steps more easily.
• Test your walkthroughs thoroughly to make sure that they are accurate and complete.

Conclusion

Interactive walkthroughs in Cloud Shell are a great way to help users learn how to use your project and Google Cloud products. By following the tips above, you can create effective interactive walkthroughs that will improve your project’s documentation and make it easier for users to get started.

The post How to create an “Interactive walkthrough” tutorial in Cloudshell appeared first on Algorithms.

As these models continue to evolve, we can anticipate even more innovative and transformative applications that blur the lines between human-computer interaction and the creation of new forms of media and experiences.

Divergence in Approach

The primary distinction between ChatGPT and Gemini lies in their inherent approaches to information processing. ChatGPT, functioning as a text-centric model, primarily concentrates on textual inputs and outputs. It excels in generating coherent and engaging conversations, translating languages, and crafting various forms of creative content.

Whereas, Gemini adopts a multimodal approach, adept at handling and processing information from diverse sources, including text, images, audio, and video. This innate capability to integrate multiple modalities affords Gemini a broader spectrum of applications, such as generating descriptive captions for images, producing lifelike videos, and even composing music.

Architectural Foundations and Learning Mechanisms

ChatGPT relies on the GPT-4V architecture, a robust large language model employing stacked autoregressive transformer layers to capture intricate linguistic patterns. Its learning process involves training on an extensive dataset of text and code, empowering it to generate grammatically correct, semantically meaningful, and often imaginative text.

In contrast, Gemini employs a deep learning architecture specifically tailored for multimodal processing. It incorporates attention mechanisms that enable the model to focus on relevant information across different modalities, facilitating the integration and comprehension of complex relationships between text, images, audio, and video.

Applications and Future Potential

ChatGPT’s text-centric nature positions it well for tasks primarily involving natural language interactions, excelling in applications like chatbots, question answering, and creative writing. However, its limitations in handling multimodal inputs confine its scope to text-based domains.

Gemini’s multimodal capabilities open up a broader range of applications, including:

1. Visualizing text descriptions: Gemini can generate realistic images based on textual descriptions, enabling the creation of creative content and visual storytelling.
2. Understanding and responding to multimedia content: Gemini can analyze and interpret videos, audio, and images, enhancing its ability to engage in more comprehensive interactions with users.
3. Creating synthetic media: Gemini can generate new audio, video, and images, with potential applications in entertainment, education, and advertising.

An analogy to illustrate their future development

Imagine a calculator specifically designed for doing calculations, and a smartphone calculator app that serves the same purpose. Now, imagine a scenario in the future where someone attempts to enhance the calculator’s capabilities by incorporating a “calling” feature. Most likely this seems challenging and might not function optimally, given that the calculator was not originally designed for such a feature.

In a parallel thought, ChatGPT may encounter difficulties in expanding its model to handle multidimensional inputs, a task that Gemini seamlessly accomplishes. In this scenario, Gemini holds a distinct advantage over ChatGPT.

The post ChatGPT & Gemini Models: Explaining the Contrasts in Simple Language appeared first on Algorithms.

While working on an open source DQM [Data Quality Monitor] frontend and backend, I had chosen IAP to secure the frontend of this DQM tool. To secure and control access to the front end, I did not have to create any login page, instead authorization and authentication were completed and taken care of by IAP itself. You can refer to the below design for DQM.

Understanding IAP’s Role in Cloud Security

IAP acts as a gatekeeper, intercepting all traffic destined for your cloud

applications and enforcing access policies based on user identities and contextual factors. It eliminates the need to expose applications directly to the internet, shielding them from unauthorized access and potential attacks. This approach aligns with the Zero Trust model, emphasizing the principle of “never trust, always verify” for every access request.

Key Features that Enhance Cloud Protection

IAP boasts a comprehensive set of features that elevate cloud security to new heights:

• Centralized Access Control: Manage access policies from a single console, ensuring consistency and simplifying administration.
• Granular Access Levels: Define fine-grained access rules based on user groups, attributes, and contextual factors, such as device type and location.
• Application-Level Security: Protect applications hosted on Google Cloud, other cloud providers, or even on-premises infrastructure.
• TCP Forwarding: Secure SSH and RDP connections to VMs without exposing them to public IP addresses.
• Integrated Authentication: Leverage existing identity and access management (IAM) solutions, such as Google Cloud IAM or Active Directory, for seamless authentication and authorization.

Real-World Benefits of Implementing IAP

Adopting IAP brings a multitude of benefits to cloud environments:

• Enhanced Security: Reduce the risk of data breaches and unauthorized access by enforcing stringent access controls.
• Simplified Management: Centralize access policy management and streamline user provisioning.
• Improved User Experience: Provide users with a secure and consistent access experience across all applications.
• Reduced Operational Costs: Eliminate the need for VPNs and simplify network management.

A User’s Perspective on IAP Implementation

As a user, I’ve found IAP to be a valuable tool for securing my cloud applications. Its centralized approach and granular access controls have significantly improved the overall security posture of our organization. The integration with existing IAM solutions has made the implementation process seamless, and the overall user experience has been positive.

Conclusion: A Powerful Ally in Cloud Security

Google Cloud IAP stands as a testament to Google’s commitment to providing robust security solutions for cloud environments. Its comprehensive features, ease of implementation, and tangible benefits make it a compelling choice for organizations seeking to safeguard their valuable data and applications. Whether you’re a seasoned cloud administrator or just starting your cloud journey, IAP is an invaluable tool to enhance your organization’s cloud security posture.

The post Google Cloud IAP A User’s Perspective appeared first on Algorithms.

What is Monotonic Arrays?

A monotonic array is an array that is entirely non-increasing or non-decreasing. In simpler terms, it means that the elements in the array are in either ascending or descending order. For instance, [1, 2, 3, 4, 5] and [5, 4, 3, 2, 1] are both monotonic arrays, while [1, 3, 2, 4, 5] is not.

Brute-Force Approach

Let’s start with the brute-force approach, which is relatively straightforward. We’ll iterate through the array and compare adjacent elements. If all adjacent elements maintain the same order (either all increasing or all decreasing), the array is considered monotonic.

def is_monotonic(arr):
    if len(arr) <= 2:
        return True
    increasing = decreasing = True
    for i in range(1, len(arr)):
        if arr[i] < arr[i - 1]:
            increasing = False
        if arr[i] > arr[i - 1]:
            decreasing = False

    return increasing or decreasing

In this code, we initialize two boolean variables, increasing and decreasing, to True. We then loop through the array, comparing adjacent elements. If any element breaks the monotonicity condition, we set the corresponding boolean variable to False. Finally, we return True if either increasing or decreasing is still True, indicating that the array is monotonic.

The brute-force approach works, but it’s not the most efficient solution, especially when dealing with large arrays. It has a time complexity of O(n), where n is the length of the array.

Optimized Single-Pass Approach [Better Approach]

A more efficient solution involves a single-pass approach that doesn’t require two separate loops for checking both increasing and decreasing monotonicity. Instead, we maintain a single variable to keep track of the direction and compare it with each element.

def is_monotonic_optimized(arr):
    if len(arr) <= 2:
        return True
    direction = 0  # 0 for unknown, 1 for increasing, -1 for decreasing
    for i in range(1, len(arr)):
        if arr[i] > arr[i - 1]:
            if direction == 0:
                direction = 1
            elif direction == -1:
                return False
        elif arr[i] < arr[i - 1]:
            if direction == 0:
                direction = -1
            elif direction == 1:
                return False

    return True

In this optimized approach, we use the direction variable to track the trend of the array. We initialize it as 0 to indicate an unknown direction. As we traverse the array, we compare each element with the previous one and determine the direction. If we encounter an element that doesn't conform to the current direction, we immediately return False. If we complete the loop without any issues, the array is monotonic, and we return `True.

This optimized approach is more efficient and has a time complexity of O(n), the same as the brute-force method, but it traverse through entire array only in worst cases.

Conclusion

In this blog post, we've explored two different approaches to check if an array is monotonic. The brute-force approach is relatively simple and straightforward but may not be the most efficient for large arrays. On the other hand, the optimized single-pass approach offers better performance and is a more elegant solution.

When choosing between the two methods, consider the size of your array and the desired efficiency. In most cases, the optimized single-pass approach is the preferred choice. It's concise, efficient, and offers a better performance guarantee.

Remember that understanding and being able to identify monotonic arrays are valuable skills in algorithm and data structure applications, as they can lead to more optimized solutions in various algorithms and problems.

The post What is Monotonic Arrays – Algorithm to check if an array is Monotonic appeared first on Algorithms.

The Three-Number Sum problem is a classic algorithmic challenge that involves finding all unique triplets in an array that add up to a given target sum. This problem is both intriguing and useful, as it has applications in areas such as data analysis, optimization, and combinatorial problem-solving. In this blog post, we will delve into an efficient algorithmic approach to solve the Three-Number Sum problem, providing a step-by-step explanation of the solution.

Understanding the Problem

Before we jump into the solution, let’s ensure we have a clear understanding of the problem. Given an array of integers and a target sum, our objective is to find all unique sets of three numbers in the array that add up to the target sum. The order of the numbers within each triplet is not important, and duplicates should be avoided.

Algorithmic Approach

To solve the Three-Number Sum problem efficiently, we’ll employ a two-pointer technique along with sorting the array. Here’s a step-by-step breakdown of the algorithm:

Sort the array in ascending order. This step is crucial as it allows us to apply the two-pointer technique effectively.

Initialize an empty result set or a list to store the unique triplets that sum up to the target value.

Iterate through the sorted array from left to right until the second-to-last element, considering each element as a potential first number of the triplet.

Within the outer loop, set two pointers, ‘left’ and ‘right,’ initially pointing to the elements immediately to the right of the current element.

While the ‘left’ pointer is less than the ‘right’ pointer, perform the following steps:

Continue steps 4 and 5, adjusting the pointers accordingly until they meet or cross each other. At that point, move to the next element in the outer loop.

Once the iteration is complete, return the result set containing all unique triplets that sum up to the target value.

Implementation in Python

def threeNumberSum(array, targetSum):
    # Write your code here.
    res = []
    array.sort()
    for i in range(len(array) - 2):
        left = i + 1
        right = len(array) - 1
        while left < right:
            if targetSum == array[i] + array[left] + array[right]:
                res.append([array[i], array[left], array[right]])
                left += 1
                right -= 1
            elif targetSum < array[i] + array[left] + array[right]:
                right -= 1
            else:
                left += 1
    return res

Explanation of the Algorithm

The algorithm utilizes the fact that a sorted array provides a convenient way to traverse through it using two pointers. By sorting the array, we ensure that smaller elements are towards the left, while larger elements are towards the right.

The two-pointer technique enables us to explore all possible combinations of three numbers efficiently. By keeping one pointer fixed (the 'left' pointer) and adjusting the other pointer (the 'right' pointer), we can find all unique triplets without duplicates.

By continuously comparing the current sum with the target sum, we can move the pointers accordingly, eliminating the need for nested loops and achieving a time complexity of O(n^2).

Conclusion

The Three-Number Sum problem presents an interesting challenge that can be solved efficiently using a two-pointer technique and a sorted array. By following the step-by-step algorithmic approach explained in this blog post, you can identify all unique triplets that add up to a given target sum.

By applying this algorithmic approach, you'll be equipped to tackle the Three-Number Sum problem and other similar combinatorial challenges efficiently. Happy coding!

The post Algorithm to Solve Classic Three-Number Sum Problem appeared first on Algorithms.