DEV Community: Pasquale Convertini

How to become a Brave Verified Creator

Pasquale Convertini — Tue, 01 Feb 2022 08:09:35 +0000

Introduction

Do you want to be able to receive tips from the people that read your content? Among the several options available today (e.g. Patreon or Ghost), there is a completely free option consisting in becoming a Brave Verified Creator and offered by Brave.

What is Brave?

Brave is a Chromium-based browser available on all platforms and that you can download here. It is also completely open-source with its code pushed on this repository. The features offered by this browser are manifold and would require a dedicated post to analyse them all, but its raising popularity among the community is clearly due to its privacy-preserving shield. While you surf the internet and access websites you leave breadcrumbs in the form of events and triggers used for advertising and tracking purposes.

Brave is able to block the majority of the ads and trackers automatically and natively, which means without the need of installing any external extension (as it would be required for other browsers). Therefore, if you're concerned about your privacy, Brave is surely a valid option to look at.

The Brave ecosystem

Although Brave is able to block all ads on a page, its goal is not to kill advertising. On the contrary, it defines a new ecosystem where:

users have complete control of their privacy and are entrusted to choose if they want to receive ads and their quantity, earning revenues proportionally to the number of received ads;
publishers earn revenues from ads (if they decide to activate them on their domain) and directly from user contributions;
advertisers can run less intrusive and more effective ads without violating privacy.

Using Brave as browser does not oblige the user to accept silently this ecosystem. Indeed the user can decide to completely shut down the Brave Shield or even turn it on just on specific websites. However, if the user decides to take part in this ecosystem, it will be rewarded receiving BAT.

What is a BAT?

BAT is an acronym for Basic Attention Token and indicates a blockchain-based token used as a currency inside Brave. Brave users receive BAT tokens proportionally to the number of ads they receive on the internal Brave wallet.

They can decide to transfer these tokens in other wallets, exchange them for fiat currencies or use them to reward the web content creators they like in the form of anonymous contributions.

Who is a Brave Verified Creator?

If you are a web content creator and you own a channel (e.g. on YouTube) or a website registered at a specific domain and you want to be able to collect and claim BAT contributions from Brave users, then you must become a Brave Verified Creator, meaning a publisher able to demonstrate that he controls the channel/website to verify.

A Brave Verified Creator is automatically linked with a BAT wallet where Brave converges all the received payments for the channels belonging to the creator. The creator can link the wallet to an Uphold or Gemini account in order to exchange BAT for other tokens or currencies.

How to become a Brave Verified Creator

To get the badge of a Brave Verified Creator, you must be able to prove you actually own the "channel" where you post your content. The channel can be:

a website (as a blog);
a GitHub repository;
a YouTube channel;
a Twitch channel;
a Vimeo channel;
a Twitter account;
a Reddit account.

Brave can update the list of supported channels, thus it is recommended to check the list of the current supported ones directly in your "Creator" homepage.

Sign up

First thing to do is create an account on the Creators Brave website by inserting your email.

Once received the sign-up link in your mail inbox, click on it and proceed with the sign-up.

Add a channel

After the sign-up, in your Creator homepage you need to click on "Add Channel" to add your channel and get the Brave Verified Creator badge.

For account and channel options all you need to do is to verify you're the guy owning the credentials to log in.

For the website option the verification process is more tedious: you must be able to either edit a DNS record or be able to create a folder and upload a file on your hosting domain. If you can't do any of the two options you are not eligible to become a Brave Verified Creator.

Verify your website with a trusted file

If you can access the filesystem of your hosting machine (e.g. a virtual machine hosted on AWS), you can use the option involving the creation of a trusted file. To do that, click on the option "I'll use a trusted file". Once clicked, you should be prompted with the content you need to write inside the file.

On host side, you need to create a folder named .well-known under your domain root folder and create a file called brave-rewards-verification.txt inside the just created folder. Assuming your host machine is Linux-based, you should do something like:

$ cd $DOMAIN_ROOT_FOLDER
$ mkdir .well-known && cd .well-known
$ touch brave-reward-verification.txt

Then you need to write inside the file brave-rewards-verification.txt the content indicated in the webpage you landed, which has a format like the following:

This is a Brave Rewards publisher verification file.

Domain: test.com
Token: 31d19738f1b2192e6f87c739e1edf9b48344159ec47870dcce5c1611fd04e133

At this point, click on the Verify button and your website should obtain the "Brave Verified Creator" badge.

Verify your website with a DNS record

If you cannot create the file on your website hosting machine, you can still complete the verification by adding a DNS TXT record for your domain (a procedure similar to the one used for the domain verification in Google Search Console). The record TXT data looks like the following:

brave-ledger-verification=0e5e9be6d9a40ff3da74315f3ba41383a3a5f9ec0a83c2040b78eb77543ab3582721ea

The procedure to add a TXT record inside your DNS varies according to the web hosting provider you use, but the result should be the same: querying the DNS servers for a TXT record on the domain we want to verify should return us the inserted token. On Linux and macOS you can verify running the command dig:

$ dig TXT <your_domain>

If you run on Windows, you can use instead nslookup:

$ nslookup -q=TXT <your_domain>

If you're not familiar with command-line tools, you can check if the record is propagating by using a service as DNSChecker.

Once you've added the record, the verification process is not as immediate as the one done by using the trusted file since it requires the propagation of the TXT record among the DNS servers.

Anyway, once you see the record being propagated on the majority of the DNS servers, you can click on the "Verify" button and your website should obtain the "Brave Verified Creator" badge.

Double check the verification

To double check whether your website has been verified, you can go to your website within the Brave browser and look at the BAT icon usually located at the right of the address bar. If your website has been verified, the icon should present the verification badge consisting in a check mark:

If not present, it could be because the status has been not refreshed. To refresh, click on the BAT icon and then on "Refresh Status" in the submenu that appears:

The check mark should appear. If not, the cause is likely related to some issues in the verification process and the recommended option would be to perform it again.

Conclusion

As a web content creator is important to provide good quality content and a great user experience, which is sometimes ruined by aggressive ads. Becoming a Brave Verified Creator allows to give a better experience to the users without necessarily turn down the revenues from advertising. Stay tuned for the next post!

Algorithms vs Heuristics

Pasquale Convertini — Thu, 27 Jan 2022 10:54:44 +0000

Introduction

Given a problem, finding a procedure which brings to the right solution can be a tough task. Programmers knows the feeling of believing to have solved a problem by writing down an algorithm, but then realize that it does not work perfectly in every situation, most likely because built focusing on a specific scenario instead of looking at the general case.

This is presumably true when working on optimization problems where the goal is to find out the best possible solution to the given problem. An example of optimization problem is known as TSP, acronym standing for Travelling salesman problem, where you are given with a set of vertices and you must find the shortest path connecting them all by visiting each vertex just once. To make things clearer, let's image to have the following set of vertices:

The scenario consists in the 4 vertices of a square. An approach could be to randomly choose a vertex as starting point and move to the nearest unvisited vertex. Once visited, remove the vertex from the set of unvisited vertices and repeat the approach until all vertices have been visited. At this point we connect with an edge the last visited vertex with the first one. In pseudocode it would be something like:

Pick a random vertex v0 from the set of unvisited vertices V
v = v0
Mark v as visited and remove from V
Until V is not empty:
    Choose the point w as the nearest point to v
    Visit w and remove it from V
    v = w
Connect v with v0

Following this approach, we would find the following solution to the previous defined scenario:

where we defined the path A->B->C->D->A. The solution is optimal and we could think that such approach is actually the right algorithm to solve the TSP problem. But let's apply the same approach to the following scenario where we pick the vertex A as the starting vertex:

As you can see, the solution is not optimal. You might argue that we could always choose the leftmost vertex as starting point instead of picking randomly, and it would work fine for both the scenarios depicted above. But what about the one below?

As you can see, it is evident how the method is doomed to fail at some point. This procedure is indeed not an algorithm, but an heuristic, known as nearest neighbour heuristic.

What is an algorithm?

To understand the difference between algorithms and heuristics we need to give some definitions. So, when can we consider a procedure eligible to be named "algorithm"?

An algorithm is a procedure with a finite number of steps that always produce a correct solution for a given problem.

Let's break down this definition. First, an algorithm must bring to a solution in a limited number of steps. The reason of this definition lies on the fact that algorithms must produce a solution on finite machines (e.g. computers) which have limited time and limited space. Think for example to the problem of defining π: would you choose between an algorithm which produces all the digits of π but never ends or would you pick one producing only the first 100 digits of π but ends after some milliseconds? I would go for the second option.

Second, an algorithm needs a proof of correctness, which is a demonstration, based on a set of hypothesis, that a procedure cannot lead to an incorrect result for a given problem. They are usually defined in mathematical language and are very complex to make. We are not going in the details of demonstrating correctness, but you can have an example watching this video:

What is an heuristic?

On the other side, an heuristic can be defined as follows:

An heuristic is a procedure for solving a problem without proof of correctness.

Demonstrating incorrectness is easier than doing the inverse. It only requires to find a counter-example: indeed nobody could claim for correctness after a counter-example has been found. If you look back at what we've done before, it's exactly the process of showing incorrectness.

Does this mean that heuristics are wrong and useless? Absolutely not. On the contrary they are widely used for finding an approximate solution to problems whose exact solution would be impossible to find for time or space constraints. The TSP problem is again a valid example: as a combinatorial NP-problem, its exact solution can only be found with a brute-force search algorithm, which has an O(n!) complexity.

How to find counter-examples

Finding counter-examples is an essential skills for developers, as it speeds up the process of spotting weaknesses in the design phase of an algorithm, which usually starts with the definition of a greedy heuristic that is refined fail after fail until it starts looking more and more as an algorithm. This skill can be useful in many situations, from work to interviews. Thus, let me give some tips in the hunt for counter-examples:

Hack the greedy rules: greedy heuristics are usually based on some basic choices to move from a state to the next until a solution has been found. These choices often give a good starting point for our hunt, thus we could focus on them to find a valid counter-example. Think at the rule "...always take the leftmost..." proposed in the TSP heuristic and at the proposed counter-example;
Go for a tie: greedy heuristics move forward chasing for differences. What if we present a scenario where there are no differences? The approach could fail and the just found counter-example would be useful to improve the procedure. In the case of the TSP heuristics based on the "...always take the leftmost..." rule, we could for example present the following scenario where no point is on the left of the others:

Work on extremes: greedy heuristics can define bounds to pick the next move to perform. If so, there's a good chance that the counter-example we're seeking sits on the bound: what if we present a scenario where we reach this bound? Does the greedy approach handle it? Does it give a correct result?

Conclusion

Algorithm design is a tedious refinement process which can require a lot of time. Improving the ability to spot algorithm weaknesses sharpens the intuition and allows to be faster, write better algorithms and be more productive.

In this post we depicted the difference between heuristics and algorithms, focusing on the process of spotting counter-examples to better distinguish between what is indeed an algorithm solving a problem and what is an heuristic solving just a specific instance of that problem. Stay tuned for the next post!

Sources

The Algorithm Design Manual (Skiena)