Daisy Rees

Daisy Rees

1551329886

Which I should select for Building library ? ES5 or ES6

I want to build a simple library in JS (vanilla). I am a bit confused about whether to follow the class-based paradigm or prototypal-based paradigm. ES6 is now in the mainstream, even though ES5 is being used. What things Should I consider

#javascript

What is GEEK

Buddha Community

Watts Kendall

1551338974

The best way to do this is to write your source code using the latest ES6+ features. Now your javascript library may be consumed by three different types of clients:

  1. Browser
  2. NodeJS
  3. Another library

1. Browser - For browser, the best option is to have the source code transpiled into ES5 and then build in IIFE form.

2. NodeJS - The best option is to transpile it to es5 and build in CommonJS(CJS)format.

3. Another library - The best option is to transpile the source code to es5 but still retain the es5 modules (export/import). You can export the build as esm modules. This helps the bundling tools for better treeshaking while using your library as a dependency.

The mostly used js bundling libraries: Rollup, Webpack and Parcel supports them. You can check them out for more info. Happy coding =)

Why ES5 when there is ES6 on the market? 😂

The Best Way to Build a Chatbot in 2021

A useful tool several businesses implement for answering questions that potential customers may have is a chatbot. Many programming languages give web designers several ways on how to make a chatbot for their websites. They are capable of answering basic questions for visitors and offer innovation for businesses.

With the help of programming languages, it is possible to create a chatbot from the ground up to satisfy someone’s needs.

Plan Out the Chatbot’s Purpose

Before building a chatbot, it is ideal for web designers to determine how it will function on a website. Several chatbot duties center around fulfilling customers’ needs and questions or compiling and optimizing data via transactions.

Some benefits of implementing chatbots include:

  • Generating leads for marketing products and services
  • Improve work capacity when employees cannot answer questions or during non-business hours
  • Reducing errors while providing accurate information to customers or visitors
  • Meeting customer demands through instant communication
  • Alerting customers about their online transactions

Some programmers may choose to design a chatbox to function through predefined answers based on the questions customers may input or function by adapting and learning via human input.

#chatbots #latest news #the best way to build a chatbot in 2021 #build #build a chatbot #best way to build a chatbot

Suparnar Taina

Suparnar Taina

1578619623

What the difference between ES5 and ES6?

Introduction

ECMAScript (ES) is a standardised scripting language for JavaScript (JS). The current ES version supported in modern browsers is ES5. However, ES6 tackles a lot of the limitations of the core language, making it easier for devs to code.

This is image title

The most common and important standards that are being used in the software development industry are ES5 (also known as ECMAScript 2009) and ES6 (also known as ECMAScript 2015).

In this article, we will understand the different features of ES5 and ES6 versions of JavaScript. We will discuss problems that were found in ECMAScript 2009 and changes that have been made in ECMAScript 2015 to overcome the limitations of ES5 and further improve JavaScript language.

1. The const keyword

The const keyword of ES6 is used to declare the read only variables, whose values cannot be changed.

<!DOCTYPE html>      
<html lang="en">      
   <head>      
      <script type="text/javascript">      
         const pi = 3.14;      
               
         var r = 4;      
               
         console.log(pi * r * r); //output "50.24"      
               
         pi = 12;      
               
      </script>      
      <meta charset="UTF-8">      
      <title>Document</title>      
   </head>      
   <body>      
   </body>      
</html>    

It throws an Uncaught TypeError: Assignment to constant variable, because variables declared using const keyword cannot be modified.

2. The var vs let keyword

The var Keyword

In ECMAScript 5 and earlier versions of JavaScript, the var statement is used to declare variables.

Here is an example that demonstrates how to create function-scoped variables:

<!DOCTYPE html>    
<html>    
   <head>    
      <script>    
         var x = 11; // can be accessed globally    
         function myFunction()    
         {    
         console.log(x);    
         var y = 12; //can be accessed throughout function    
         if(true)    
         {    
         var z = 13; //can be accessed throughout function    
         console.log(y);    
         }    
         console.log(z);    
         }    
             
         myFunction();    
             
      </script>    
   </head>    
   <body></body>    
</html>   

Here, as you can see, the z variable is accessible outside the if statement, but that is not the case with other programming languages. Programmers coming from other language backgrounds would expect the z variable to be undefined outside the if statement, but that’s not the case. Therefore, ES6 had introduced the let keyword, which can be used for creating variables that are block scoped.

The let keyword

The let keyword is used for declaring block scoped variables. As earlier versions of JavaScript do not support block scoped variables, and nearly each and every programming language supports block scoped variables due to this limitation, the let keyword is introduced in ES6.

Variables declared using the let keyword are called block scoped variables. When the block scoped variables are declared inside a block, then they are accessible inside the block that they are defined in (and also any sub-blocks) but not outside the block.

<!DOCTYPE html>    
<html>    
   <head>    
      <script>    
         let x = 13; //can be accessed globally    
         function myFunction()    
         {    
         console.log(x);    
         let y = 14; //can be accessed throughout function    
         if(true)    
         {    
         let z = 14; //cannot be accessed outside of the "if" statement    
         console.log(y);    
         }    
         console.log(z);    
         }    
         myFunction();    
             
             
      </script>    
   </head>    
   <body>    
   </body>    
</html>  

The above code throws Uncaught ReferenceError: z is not defined

Now, the output is as expected by a programmer who is used to another programming language. Here variables are declared using let keyword inside the {} block and cannot be accessed from outside.

3. The arrow functions

In ECMAScript 5, JavaScript function is defined using function keyword followed by name and parentheses ().

Here is an example,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         const add1 = function(a,b)    
         {    
         return a+b;    
         }    
         console.log(add1(60,20));    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

In ECMAScript 6, functions can be created using => operator. These functions with => operator are called arrow functions. With arrow functions, we can write shorter function syntax. If function is having only one statement and that statement is returning a value, then the brackets {} and return keyword can be removed from the function definition.

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         const add1 = (a,b) => a+b;    
         console.log(add1(50,20));    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body>    
   </body>    
</html>   

4. Object oriented programming concept

Earlier versions of JavaScript did not have true object inheritance, they had prototype inheritance. Therefore ES6 has provided a feature called classes to help us organize our code in a better way and to make it more legible.

Object creation in ES5 version of JavaScript is as follows,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script>    
         function Car(options){    
         this.title = options.title;    
         }    
         Car.prototype.drive = function(){    
         return 'vroom';    
         };    
         function Toyota(options){    
         Car.call(this,options);    
         this.color = options.color;    
         }    
         Toyota.prototype = Object.create(Car.prototype);    
         ToyotaToyota.prototype.constructor = Toyota;    
         Toyota.prototype.honk = function(){    
         return 'beep';    
         }    
         const toyota = new Toyota({color:"red",title:"Daily Driver"});    
         document.getElementById("demo").innerHTML = toyota.drive();    
         document.getElementById("demo1").innerHTML = toyota.title;    
         document.getElementById("demo2").innerHTML = toyota.honk();    
         document.getElementById("demo3").innerHTML = toyota.color;    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body>    
      <p id="demo"></p>    
      <p id="demo1"></p>    
      <p id="demo2"></p>    
      <p id="demo3"></p>    
   </body>    
</html>   

From the above code, we can see that constructor object creation and prototype inheritance is very complicated.

Therefore to organize our code in a better way and to make it much easier to read and understand, ES6 has provided a feature called class. We can use classes for setting up some level of inheritance as well as to create objects to make code more legible.

5. Using class declaration for object creation and inheritance in ES6 version of JavaScript

Declare a class using class keyword and add constructor() method to it.

<!DOCTYPE html>    
<html>    
   <head>    
      <script>    
         class Car {    
         constructor(brand)    
         {    
         this.title=brand;    
         }    
         drive() {    
         return 'i have a '+this.title;    
         }    
         }    
         class Toyota extends Car{    
         constructor(brand,color){    
         super(brand);    
         this.color=color;    
         }    
         honk()    
         {    
         return this.drive()+',its a '+this.color;    
         }    
         }    
         const toyota = new Toyota("Ford","red");    
         document.getElementById("demo2").innerHTML = toyota.honk();    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body>    
      <h2>JavaScript Class</h2>    
      <p id="demo"></p>    
      <p id="demo1"></p>    
      <p id="demo2"></p>    
      <p id="demo3"></p>    
      <p id="demo4"></p>    
   </body>    
</html>   

Above code defines a class named ‘Car’ which is having its own constructor and method. Another class ‘Toyota’ is inheriting ‘Car’ constructor and method with the help of extends keyword.

6. Improved Array capabilities

While ECMAScript 5 introduced lots of methods in order to make arrays easier to use, ECMAScript 6 has added lot more functionality to improve array performance such as new methods for creating arrays and functionality to create typed arrays.

In ECMAScript 5 and earlier versions of JavaScript, there were two ways to create arrays such as creating arrays using array constructor and array literal syntax.

Creating arrays using array constructor,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         let items = new Array(2);    
         console.log(items.length); // 2    
         console.log(items[0]); // undefined    
         console.log(items[1]); // undefined    
              
         items1 = new Array("2");    
         console.log(items1.length); // 1    
         console.log(items1[0]); // "2"    
              
         items2 = new Array(1, 2);    
         console.log(items2.length); // 2    
         console.log(items2[0]); // 1    
         console.log(items2[1]); // 2    
              
         items3 = new Array(3, "2");    
         console.log(items3.length); // 2    
         console.log(items3[0]); // 3    
         console.log(items3[1]);    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

As we can see from the above example, on passing a single numerical value to the array constructor, the length property of that array is set to that value and it would be an empty array. On passing a single non-numeric value, the length property is set to one. If multiple values are being passed (whether numeric or not) to the array, those values become items in the array.

This behavior is confusing and risky, because we might not always be aware of the type of data being passed.

Solution provided in ECMAScript 6 version of JavaScript is as follows,

7. The Array.of() method

In order to solve the problem of a single argument being passed in an array constructor, ECMAScript 6 version of JavaScript introduced the Array.of() method.

The Array.of() method is similar to array constructor approach for creating arrays but unlike array constructor, it has no special case regarding single numerical value. No matter how many arguments are provided to the Array.of() method, it will always create an array of those arguments.

Here is an example showing the use of Array.of() method,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         let items4 = Array.of(1, 2);    
         console.log(items4.length); // 2    
         console.log(items4[0]); // 1    
         console.log(items4[1]); // 2    
         items5 = Array.of(2);    
         console.log(items5.length); // 1    
         console.log(items5[0]); // 2    
         Items6 = Array.of("2");    
         console.log(items6.length); // 1    
         console.log(items6[0]); // "2"    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

8. Converting non-array objects into actual arrays

Converting a non array object to an array has always been complicated, prior to ECMAScript 6 version of JavaScript. For instance, if we are having an arguments object and we want to use it like an array, then we have to convert it to an array first.

In ECMAScript 5 version of JavaScript, in order to convert an array like object to an array, we have to write a function like in the below code,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         function createArray(arr) {    
         var result = [];    
         for (var i = 0, len = arr.length; i < len; i++) {    
         result.push(arr[i]);    
         }    
         return result;    
         }    
         var args = createArray("ABCDEFGHIJKL");    
         console.log(args);    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>   

Even though this approach of converting an array like object to an array works fine, it is taking a lot of code to perform a simple task.

9. The Array.from() method

Therefore in order to reduce the amount of code, ECMAScript 6 version of JavaScript introduced Array.from() method. The Array.from() method creates a new array on the basis of items provided as arguments during function call.

For example let’s consider the following example

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         var arg = Array.from("ABCDEFGHIJKLMNO");    
         console.log(arg);    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>   

In the above code, the Array.from() method creates an array from string provided as an argument.

10. New methods for array

Before ECMAScript 5, searching in an array was a complicated process because there were no built in functions provided to perform this task. Therefore ECMAScript 5 introduced indexOf() and lastIndexOf() methods to search for a particular value in an array.

The indexOf() method,

<!DOCTYPE html>    
<html>    
   <head>    
      <script>    
         var languages = ["C#", "JavaScript", "Java", "Python"];    
         var x = languages.indexOf("Java");    
         console.log(x);     
             
      </script>    
   </head>    
   <body>    
      <p id="demo"></p>    
   </body>    
</html>   

The lastIndexOf() methods,

<!DOCTYPE html>    
<html>    
   <head>    
      <script>    
         var languages = ["C#", "JavaScript", "Java", "Python","C#"];    
         var x = languages.lastIndexOf("C#");    
         console.log(x);     
             
      </script>    
   </head>    
   <body>    
      <p id="demo"></p>    
   </body>    
</html>  

These two methods work fine, but their functionality was still limited as they can search for only one value at a time and just return their position.

Suppose, we want to find the first even number in an array of numbers, then we have to write our own code as there are no inbuilt functions available to perform this task in the ECMAScript 5 version of JavaScript. The ECMAScript 6 version of JavaScript solved this problem by introducing find() and findIndex() methods.

11. The Array.find() and Array.findIndex() function

The array.find() method returns the value of first array element which satisfies the given test (provided as a function). The find() method takes two arguments as follows:-

Array.find (function(value, index, array),thisValue).

The Array.findIndex() method is similar to the find() method. The findIndex() method returns the index of the satisfied array element.

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         let numbers = [25, 30, 35, 40, 45];    
         console.log(numbers.find(n => n % 2 ==0 ));    
         console.log(numbers.findIndex(n => n % 2 ==0));    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

12. Sets and Maps

In ES5, sets and maps objects can be created using Object.create() as follows,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         var set = Object.create(null);    
         set.firstname = "Krysten";    
         set.lastname = "Calvin";    
             
         console.log(set.firstname);    
         console.log(set.lastname);    
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

In this example, the object set is having a null prototype, to ensure that the object does not have any inherited properties.

Using objects as sets and maps works fine in simple situations. But this approach can cause problems, when we want to use strings and numbers as keys because all object properties are strings by default, therefore strings and numbers will be treated as same property, and two keys cannot evaluate the same string.

For example, let’s consider the following code,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         var map = Object.create(null);    
         map[2] = "hello";    
         console.log(map["2"]);     
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body>    
   </body>    
</html>  

In this example, the numeric key of 2 is assigned a string value “hello" as all object properties are strings by default. The numeric value 2 is converted to a string, therefore  map[“2”] and map[2] actually reference the same property.

13. ECMAScript 6 introduced sets and maps in JavaScript

Sets

A set is an ordered list of elements that cannot contain duplicate values. Set object is created using new Set(), and items are added to a set by calling the add() method.

You can see how many items are in a set by checking the size property,

Lets consider the following code,

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         let set = new Set();    
         set.add(10);    
         set.add(20);    
         set.add(30);    
         set.add(40);    
         console.log(set);    
         console.log(set.size);     
             
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body>    
   </body>    
</html>   

Here size property returns the number of elements in the Set. And add method adds the new element with a specified value at the end of the Set object.

Maps

A map is a collection of elements that contains elements as key, value pair. Each value can be retrieved by specifying the key for that value. The ECMAScript 6 Map type is an ordered list of key-value pairs, where the key and the value can be any type.

<!DOCTYPE html>    
<html lang="en">    
   <head>    
      <script type="text/javascript">    
         let map = new Map();    
         map.set("firstname", "Shan");    
         map.set("lastname", "Tavera");    
         console.log(map.get("firstname"));     
         console.log(map.get("lastname"));     
             
      </script>    
      <meta charset="UTF-8">    
      <title>Document</title>    
   </head>    
   <body></body>    
</html>  

14. Functions with default parameters in JavaScript

JavaScript functions have different functionalities in comparison to other programming languages such that any number of parameters are allowed to be passed in spite of the number of parameters declared in function definition. Therefore, functions can be defined that are allowed to handle any number of parameters just by passing in default values when there are no parameters provided.

Default parameters in ECMAScript 5

Now we are going to discuss, how function default parameters would be handled in ECMAScript 5 and earlier versions of ECMAScipt. JavaScript does not support the concept of default parameters in ECMAScript 5, but with the help of logical OR operator (||) inside function definition, the concept of default parameters can be applied.

To create functions with default parameters in ECMAScipt 5, the following syntax would be used,

<!DOCTYPE html>    
<html>    
   <body>    
      <script type="text/javascript">    
         function calculate(a, b) {    
         aa = a || 30;    
         bb = b || 40;    
         console.log(a, b);    
         }    
         calculate(10,20); // 10 20    
         calculate(10); // 10 40    
         calculate(); // 30 40    
      </script>    
   </body>    
</html>  

Inside function definition, missing arguments are automatically set to undefined. We can use logical OR (||) operator in order to detect missing values and set default values. The OR operator looks for the first argument, if it is true, the operator returns it, and if not, the operator returns the second argument.

Default parameters in ECMAScript 6

ECMAScript 6, allows default parameter values to be put inside the function declaration. Here we are initializing default values inside function declaration which is used when parameters are not provided during function calling.

<!DOCTYPE html>  
<html>  
<body>  
   <script type="text/javascript">  
      function calculate(a=30, b=40) {  
         console.log(a, b);  
      }  
      calculate(10,20); // 10 20  
      calculate(10); // 10 40  
      calculate(); // 30 40  
   </script>  
</body>  
</html>  

Summary

In this article, we have discussed briefly, the differences between ES5 and ES6 versions of JavaScript as well as some of the new features introduced in each of these versions. Each and every feature has been explained with proper coding examples.

I hope this tutorial will surely help and you if you liked this tutorial, please consider sharing it with others. Thank you so much!

#javascript #es6 #es5 #ECMAScript #difference

ES6 Reduce Helper and ES6-Equivalent Code Using Reduce

Consider a simple scenario where you have an array of numbers and you want to return the sum of all elements in that array.

We will see that it’s a solution in ES5 and that it’s equivalent in ES6 to using reduce helper.

ES5 Code

  1. var numbers=[10,70,50,20];   
  2. var sum=0;  
  3. function additionOfElementsInArray(){  
  4.    for(var i=0;i<numbers.length;i++){  
  5.          sum += numbers[i]  
  6.    }  
  7.    return(sum);  
  8. }  
  9.    
  10. additionOfElementsInArray();  

The above code will return an output of 150.

ES6-Equivalent Code Using Reduce

  1. const numbers=[10,70,50,20];   
  2.    
  3. numbers.reduce(function(sum,numberElement){  
  4.    
  5.    return sum += numberElement;  
  6.    
  7. } ,0 );  

The above code will also return output as 150.

You can write the same code in ES6 using Reduce Helper with arrow function as follows, which will return the same output.

  1. const numbers=[10,70,50,20];  
  2.    
  3. numbers.reduce((sum,numberElement)=>sum += numberElement,0);

#es6 #es5 code #es6-equivalent code

What is BUILD Finance (BUILD) | What is BUILD Finance token | What is BUILD token

BUILD Finance DAO

The document is non-binding. Some information may be outdated as we keep evolving.

BUILD Philosophy

BUILD Finance is a decentralised autonomous venture builder, owned and controlled by the community. BUILD Finance produces, funds, and manages community-owned DeFi products.

There are five core activities in which the venture BUILDers engage:

  1. Identifying business ideas,
  2. Organising teams,
  3. Sourcing capital,
  4. Helping govern the product entities, and
  5. Providing shared services.

BUILD operates a shared capabilities model, where the DAO provides the backbone support and ensures inter-entity synergies so that the product companies can focus on their own outcomes.

BUILD takes care of all organisational, hiring, back/mid office functions, and the product companies focus on what they can do best, until such time where any individual product outgrows the DAO and becomes fully self-sustainable. At that point, the chick is strong enough to leave the nest and live its own life. The survival of the fittest. No product entity is held within DAO by force.

Along the way, BUILD utilises the investment banking model, which, in its essence, is a process of creating assets, gearing them up, and then flipping them into a fund or setting them as income-generating business systems, all this while taking fees along the way at each step. BUILD heavily focuses on integrating each asset/product with each other to boost productive yield and revenues. For example, BUILD’s OTC Market may be integrated with Metric Exchange to connect the liquidity pools with the trading traffic. The net result – pure synergy that benefits each party involved, acting in a self-reinforcing manner.

El Espíritu de la Colmena (The Spirit of the Beehive)

BUILD is a hive and is always alive. While some members may appear more active than others, there’s no central source of control or “core teams” as such. BUILD is work in progress where everyone is encouraged to contribute.

Following the natural free market forces, BUILD only works on those products that members are wanting to work on themselves and that they believe have economic value. Effectively, every builder is also a user of BUILD’s products. We are DeFi users that fill the gaps in the ecosystem. Any member can contribute from both purely altruistic or ultra-mercantile intentions – it’s up to the wider community to decide what is deemed valuable and what product to support. The BUILD community is a sovereign individual that votes with their money and feet.

BUILD members = BUILD users. It’s that simple.

$BUILD TOKEN

Tokenomics

$BUILD token is used as a governance token for the DAO. It also represents a pro-rata claim of ownership on all DAO’s assets and liabilities (e.g. BUILD Treasury and $bCRED debt token).

The token was distributed via liquidity mining with no pre-sale and zero founder/private allocation. The farming event lasted for 7 days around mid-Sep 2020. At the time, BUILD didn’t have any products and held no value. Arguably, $BUILD has still zero value as it is not a legal instrument and does not guarantee or promise any returns to anyone. See the launch announcement here https://medium.com/@BUILD_Finance/announcing-build-finance-dc08df585e57​

Initial supply was 100,000 $BUILD with 100% distributed via fair launch. Subsequently, the DAO unanimously voted to approve minting of extra 30,000 $BUILD and allocate them as:

  • 15,000 $BUILD (11.5%) to the founding member of the DAO (@0xdev0) with 1-year gradual vesting, and
  • 15,000 $BUILD (11.5%) to the DAO treasury as development funds.

For the proposal of the above see: https://forum.letsbuild.finance/t/proposal-2-fund-the-development-of-defi-lending-platform/24​

The voting took place at a later retired web-page https://vote.letsbuild.finance. The governance has since moved to Snapshot (link below). The results of the old proposals are not visible there, however, on-chain voting contract can be see here: https://etherscan.io/address/0xa8621477645f76b06a41c9393ddaf79ddee63daf#readContract​

$Build Token Repartition

Vesting Schedule

Minting keys are not burnt = $BUILD supply is not fixed as token holders can vote on minting new tokens for specific reasons determined by the token holders. For example, the DAO may mint additional tokens to incentivise usage of its products, which would, in turn, increase the value flow or TVL. Dilution is not in the economic benefit of the token holders, hence any such events has to be considered carefully.

Access to minting function is available via on-chain governance. A safe buffer is established in a form of the contract-enforced 24 hour delay, which should provide a sufficient time for the community to flag. Meaning that before such a transaction could be executed, everyone would be able to act in advance by withdrawing their funds / exiting from BUILD. Any malicious minting would, theoretically, result in an immediate market sell-off of $BUILD, making it economically detrimental to do such an action. This makes it highly improbable that any malicious minting would be performed_._

GOVERNANCE

All components of the BUILD DAO and the control over its have been decentralised:

  • All contracts (incl. the Treasury and Basis Gold) can be operated by $BUILD holders with on-chain proposals (see https://docs.build.finance/build-knowledge-base/on-chain-voting);
  • All social accounts (Discord, Telegram, and Twitter) are managed by multiple moderators;
  • All frontends (Metric Exchange, Basis Gold, and the BUILD homepage) are auto-deployed and managed by multiple devs.

TREASURY & DEVELOPMENT

BUILD DAO Treasury

The BUILD treasury has over $400k that can be managed by on-chain proposals and used in whichever way the community desires. For example, to hire developers. Having a functioning product, enough funds in the treasury and a fully decentralised governance has been a long-term goal since the inception in September 2020, and now it’s finally here.

Current holdings are (might be outdated):

  • Capital budget (dev / incentives fund) - 11,025 $BUILD (~$94k);
  • Operational budget (product development) - 204,300 $aDAI;
  • Ownership stake - 200,000 $METRIC (~$84k);
  • Ownership stake - 199,900 $UPDOWN(~$62k);
  • Ownership stake - 5,400 $HYPE (~$1.3k);
  • Ownership stake - 2% of $BSGS supply.
  • TOTAL: ~$445k

Funding of the Development

In an early stage, the development will be funded by an allocation of bCRED debt tokens for development expenses. After the first product was built (i.e. Metric Exchange), the DAO sold 5,000 $BUILD for 203,849 $DAI which will now be used for funding of other products or a combination of revenue + a smaller token allocation. This is up to the community to decide.

Smart Contract Audit

Contracts are not audited. It’s up to the BUILD community governance to decide how to spend our funds. If the community wants to spend any amount for auditing, a voting proposal can be initiated. As with any decisions and proposals, the cost-benefit analysis must be employed in regards to the economical sense of spending any funds on audit vs developing more products and expanding our revenue streams.

DAO Liabilities and $bCRED

$bCRED is a token that allowed the DAO to reward members for work before the DAO source sufficient funds. Effectively, $bCRED is a promissory note or an IOU to give back $DAI at 1:1 ratio, when the DAO starts generating revenues. Read more about $bCRED here: https://medium.com/@BUILD_Finance/what-is-bcred-b97e4cc75f8c.

“BUILDER” User Role in Discord

Since Discord is our primary coordination mechanism, we need to make effort to keep it focused on producing value. During the launch of METRIC, we’ve doubled our total number of users! This made it very difficult for existing users to explain what BUILD is about to new users and created a lot of confusion.

To help improve the quality of conversations, we’ve introduced a new user role called BUILDer. BUILDers will have write-access to product development channels while everyone else will only be able to read them. This should keep those product changes focused on actual productive conversations and make them more informative.

“GUARDIAN” Role in Discord

To increase our collective output as a community, a governance vote introduced an incentivisation mechanism for community contribution, tipping, and other small projects using our unique bCRED token (but may change in the future as required). These tokens are stewarded by active community members — “guardians’’ — who are free to allocate these funds to tip people for proactive work. Current guardians are @Son of Ishtar and @0xdev0, although anyone can propose the tip for anyone else. For more details see Proposal #15.

Hence, Guardians are defined as members of the DAO who are entrusted with a community budget for tipping other members for performing various small tasks.

PRODUCT SUITE & ROADMAP

  • Metric Exchange - is a DEX aggregator that allows for limit orders trading for any ERC-20 token via 0x relayer. Development continues with the product owner SHA_2048 and inputs from vfat. Live at metric.exchange.
  • Basis Gold - a synthetic, algorythmically-adjusted token pegged to the price of gold (sXAU) with elastic supply. Live at https://basis.gold/.
  • Updown Finance - binary options for volatility trading instrument (alpha is live at updown.finance).
  • Vortex - a lending & borrowing platform, which will target the long tail of assets that are currently not served by the existing DeFi money markets. Aiming to launch by March’2021.

The other immediate focus right now will be to make good use of our newly available funding and hire several product managers for other projects.

Please note that nothing is here set in stone. Just like any other start-up, we’ll keep experimenting, learning, and evolving. What’s listed here is just our current trajectory but it might change at any point.

SOCIAL MEDIA

Would you like to earn BUILD right now! ☞ CLICK HERE

Top exchanges for token-coin trading. Follow instructions and make unlimited money

BinanceBittrexPoloniexBitfinexHuobi

Thank you for reading!

#blockchain #cryptocurrency #build finance #build

Daisy Rees

Daisy Rees

1551329886

Which I should select for Building library ? ES5 or ES6

I want to build a simple library in JS (vanilla). I am a bit confused about whether to follow the class-based paradigm or prototypal-based paradigm. ES6 is now in the mainstream, even though ES5 is being used. What things Should I consider

#javascript