DEV Community: Mai Luong

Merkle Metric to measure the reliability of blockchains for production use

Mai Luong — Fri, 04 Dec 2020 10:32:09 +0000

Merkle Metric, a methodological approach to measuring the reliability of blockchains for production use.

DappStarter is a blockchain-agnostic platform that generates customized, full-stack project source code for decentralized applications. In our quest to create the best and most accessible developer tooling for smart contracts creation, we often need to decide whether a blockchain warrants being added to the platform.

While some metrics we use in our process are easy to quantify, such as the ease of use for developers, one remarkably hard-to-pinpoint factor is that of trust. What we call the trustless nature of blockchain is the operational independence from any single authoritative actor, eliminating any single points of failure and allowing the network to operate in a permissionless fashion. One aspect of trust still remains, however, and it’s the users’ hope that the blockchain will keep operating in a predictable and reliable way.

Introducing Merkle Metric, our answer to the problem of measuring production use reliability.

“Can I trust this blockchain?” is one of the most overarching and essential questions for blockchain developers, companies looking to leverage blockchain technology, and lastly end-users. For any production use, an affirmative answer provides the necessary confidence that a decentralized application won’t encounter problems caused by the underlying technology. For the consumer, the question itself may never be asked, but what’s still there is the implicit expectation of being able to trust the network with their finances, the same way end users trust a smartphone app without being aware of the technology running in the background.

So what makes a blockchain trustworthy? We’ve identified three main areas relevant to this question, each with a number of quantifiable factors:

Network resilience
Economic resilience
Adoption ‍

Network resilience refers to the trust put in the blockchain’s reliable functioning on the protocol-level. In most blockchains, trust in this category is generated on the basis of two factors: protocol openness and the decentralization of decision-making.

Firstly, there’s no guarantee of a blockchain being truly permissionless and thus authority-independent unless the complete code is open-sourced and verifiable by the networks’ participants.

Secondly, we need to look at the decentralization of decision-making processes. Namely, changes in decentralized blockchains can only happen through verifiers of the network expressing their views by directing the computational power (for proof-of-work algorithms) and stakes (for proof-of-stake). If one entity were able to single-handedly influence the protocol-level decisions (e.g., a double-spend attack for Ethereum), this would greatly endanger the network’s resilience and highly influence the Merkle Metric.

Economic resilience is the economically-related stability of a blockchain. On the most basic level, we want to see whether money involved in the economy around a given blockchain makes it safer or potentially harms it. While a blockchain may be cryptographically sound, one shouldn’t forget that the markets both ensure and serve as a litmus test of how trustworthy a network is. Therefore, the economic resilience against price manipulation serves as the main metric in this area, with development-related metric, i.e., reasonable funding for the team to develop the blockchain, being of secondary importance. The more specific factors we use to measure economic resilience include:

Percentage of the token supply in possession of the top 10 accounts (exchanges and some smart contracts excluded) in relation to the total supply
Presence of mechanisms (or lack thereof) aimed at countering sideloading and/or other economically-harmful technical means
Token supply-related characteristics that directly influence future financial resilience, such as inflation or the relation between tokens circulating and the maximum supply ‍

Adoption is the third and last area of interest in the Merkle Metric methodology and serves as the expression of trust in the network measured through developer and user engagement. The following are factored in:

The blockchain has trustworthy partners and customers, shows production use by successful startups and mid-to-large companies, and is listed on high-quality exchanges
An established developer ecosystem is present, i.e., the number of GitHub repositories and maintainers with active input is measured
Conversations happen around the blockchain, i.e., there’s an active community (in any medium, e.g., forums, Discord, Telegram, Reddit, hackathons/meetups) and/or social media presence
The blockchain is supported on DappStarter

Trust the Merkle Metric

Developers and enterprises need to know which blockchain is trustworthy. It is our belief that Merkle Metric can serve as a useful tool for anyone looking to get involved with blockchain technology. Our methodology isn’t limited to a single area where trust is involved, and instead takes a comprehensive look at all relevant areas, quantifies them, and presents them in an easy-to-consume and informative form.

To see a detailed example of how the Merkle Metric is applied to evaluating the reliability of blockchains for decentralized application projects, check out the Decentology Ethereum Report.

Development tools: An analogy between Web 2.0 and Web 3.0

Mai Luong — Tue, 27 Oct 2020 13:45:45 +0000

If you're looking to get into blockchain development, there are a few tools you'll need to get started. We've drawn some analogies between the blockchain world and the rest of the web development world to make blockchain development easier to understand.

Note: From the Ethereum Perspective
This blog is written from the perspective of a developer building on the Ethereum blockchain.

At Decentology, we make blockchain development simple starting with DappStarter, a blockchain-agnostic platform that generates customized, full-stack project source code for decentralized applications. But after you've generated a dapp with DappStarter, you'll need a few tools to get you started with blockchain development.

In order to develop and build your decentralized application, the following software pre-requisites must be installed:

Visual Studio Code (or any IDE for editing Javascript)
NodeJS v10.x
Solidity v0.5.11
Truffle v5.0.7
Ganache v2.0.0 (for Ethereum)

If you haven’t, follow the instructions at the above links to get the software you need installed.

Solidity, Truffle, & Ganache

‍If you have a development background, you are likely familiar with Visual Studio Code and NodeJs. The last 3 items in the list above may have been new, so let’s briefly detail those. Solidity is the JavaScript-like language for coding smart contracts. Truffle is the most popular development framework for Ethereum and Ganache is a blockchain simulator for Ethereum that runs on your local machine. While this info accurately defines the software, it may be helpful to compare them with a context web 2.0 developers are already familiar with.

Web 2.0 to Web 3.0 - Mentally Connecting the Dots‍

Let’s draw some rough parallels from a web 2.0 developer’s perspective… If you’ve ever used Apache, nginx, IIS, or GWS you can think of Ethereum, EOS, Harmony, Neo, Stellar, and Hyperledger in the same context. They are similar to web servers that host specific platforms. Keep in mind that everything in web 3.0 is decentralized.

Languages
If you’ve developed with Typescript, Go, JavaScript, or C++ you can view Solidity, Vyper, and others from the same lens, they are languages.

Frameworks
If you’ve ever developed on Express, Django, Rails, Spring, or .NET then you can consider Truffle, Fabric, Quorum, Burrow, Sawtooth, Enterprise Ethereum as similar technologies, they are frameworks.

The End Result
And at the end of the day, web 2.0 developers build web applications. You can view a web application as being similar to a Smart Contract, which is what web 3.0 developers build.

Ultimately, web applications target specific web platforms. Developers code applications in languages that are supported by their chosen web platform. Said differently, a compiler or interpreter exists to transform code so it can run on the respective web platform. Developers use web frameworks to not have to do a lot of grunt-work.

Example Scenario‍
Let’s bring it all home with an example from the .NET world. Web 2.0 developers build web applications programming in C# for IIS using .NET. In contrast, web 3.0 developers build decentralized web applications programming in Solidity for Ethereum using Truffle.

Keep Rocking Out!
We hope these analogies help you understand the blockchain development stack a little better. Once you’ve got all of these tools installed you’re ready to rock. And if you want to increase efficiency and reduce coding effort by 80%, try to build your dapp with Decentology DappStarter in three steps:

Select the blockchain and features you want to implement in your dapp
Download your full-stack custom source code for your blockchain app
Customize the code and deploy!

Best practices to avoid costly or irreversible mistakes in blockchain app development

Mai Luong — Sat, 15 Aug 2020 15:56:10 +0000

Blockchain app development can be tricky. We've put together 5 tips and best practices to avoid costly or irreversible mistakes when it comes to blockchain development.

1. Item Collections

Do: Have the client call the smart contract function for each item

Don't: Loop through each item in your smart contract function

Every line of code executed on a smart contract costs money! To save money and improve efficiency, have the client call the smart contract function for each item, rather than looping through each item in your smart contract.

2. Transferring Funds

Do: Have the user "pull" funds

Don't: Send funds to the user by using "push"

Transferring funds can be a high-stakes process. Having the user pull funds, rather than pushing funds to the user can avoid mistakes and immutable errors.

3. Reducing Gas Fees

Do: Validate all inputs before using them in code

Don't: Intersperse input validation within code

Again, smart contract execution is costly. Be sure to validate all inputs before using them in code to avoid expensive errors before it's too late.

4. Arithmetic Errors

Do: Use a library that checks for numeric overflow/underflow

Don't: Perform arithmetic in smart contracts without bounds-checking

Arithmetic errors are never good, but in smart contracts ‒ they're irreversible. Use a library that checks for numeric overflow/underflow to ensure arithmetic errors don't become an expensive headache.

5. Minimizing On-chain Data

Do: Hash data on-chain and store actual values off-chain

Don't: Store large amounts of data on-chain

Storing data on-chain is incredibly expensive. Using a decentralized storage solution such as IPFS or Sia is a best-practice to maintain the decentralized nature of an app without racking up cost.

6. (Extra tip!) Using Great Tools

Blockchain app development can be confusing, using great tools can make it easier. These best practices (and more!) are built into DappStarter, Decentology's full-stack blockchain application generator.

More best practices for blockchain app development (3 part series):

Smart Contract Best Practices

Blockchain App UX Best Practices

Tips to Avoid Costly Mistakes in Blockchain App Development

Best Practices in Blockchain App UX Design

Mai Luong — Mon, 03 Aug 2020 12:39:54 +0000

Communication, communication, communication. Blockchain introduces new challenges that can either make users feel empowered and educated or defeated and alienated. The difference between empowerment and defeat can be boiled down to two main factors: communicating with users and hiding unnecessary blockchain jargon. We've compiled a list of best practices to help craft great user experiences to leave users feeling educated and empowered.

1. Don't make users pay transaction fees

Do ‒ Have the app pay gas fees for transactions

Not only are gas fees difficult for users to understand, but paying for transactions also requires users to have cryptocurrency such as ETH, which is not realistic for most mainstream users.

Don't ‒ Clutter the UI with gas fee-related warts

In most applications, gas fees should be tucked away, but still accessible. An example of this might be providing gas fee-related information under an "Advanced" tab.

2. Set user expectations

Do ‒ Set user expectations that their transaction could fail

On a blockchain, transactions can be valid and allowed, but still fail. Setting expectations and communicating to users that their desired action is "Being Submitted" rather than "Successful" is an important distinction that can hep avoid frustration in the case that the transaction does fail.

Don't ‒ Assume that every submitted transaction will complete

Assuming every transaction will complete can lead to frustration. No one likes to be told "Success!" just to be told "Failed" moments later. Communicate accurately and don't assume that every transaction is going to be a success.

3. Simplify the UI

Do ‒ Make the interface super simple

For applications targeting mainstream users, try to keep new controls, information, and options to a minimum. Oftentimes blockchain applications will include information that, while technical can be provided, is absolutely unnecessary. Unnecessary information in blockchain can alienate users and make them feel uncomfortable.

Don't ‒ Make the user think about how to use the interface

Create intuitive applications that model existing paradigms that users are already accustomed to. Just because you can include the Ethereum address of a user doesn't mean you should! New is good, but consider introducing only one or two new elements ‒ too many can create confusion and frustration.

4. Show clear transaction results

Do ‒ Provide a clear interface for reporting transaction results

People want to feel informed. Providing a clear interface where users can see the progress of a transaction helps ease the mind and make the user feel comfortable.

Don't ‒ Intersperse transaction results where the user might miss them

Hiding transaction results or placing them in unsuspecting parts of the UI not only feels frustrating, it also introduces a level of ambiguity that is particularly frustrating, given that transactions are immutable. When there's no "Undo" button, the stakes for knowing the progress of a given transaction are much higher ‒ make it easy for users to find the details.

5. Warn users about context changes

Do ‒ Warn the user if the app context or account has changed

Context changes can be difficult to communicate, especially when so much happens on the client-side with blockchain apps. Make sure that you have alerts and other ways of communicating to users when the context changes. Again, this goes back to keeping the user informed.

Don't ‒ Continue a workflow if the app context or account changes

Navigating blockchain can be difficult in-and-of itself. Communicate context changes and make sure to confirm that users want to continue with a given workflow in the instance of a context or account change.

Blockchain can be confusing for mainstream users. Following best practices to simplify the user experience boils down to effective communication with users and hiding unnecessary blockchain jargon.

‍

Blockchain app development can be confusing, using great tools can make it easier. These best practices (and more!) are built into DappStarter, Decentology's full-stack blockchain application generator.

More best practices for blockchain app development (3 part series):

Smart Contract Best Practices

Blockchain App UX Best Practices

Tips to Avoid Costly Mistakes in Blockchain App Development

Best Practices in Blockchain Smart Contract Development

Mai Luong — Thu, 23 Jul 2020 13:39:11 +0000

Smart contracts can be intimidating. Whether you're just getting into the world of blockchain or you're a seasoned blockchain app developer, these 5 principles cover some basic Do's and Don'ts of smart contract development.

1. Add Circuit Breakers

Do ‒ Add a circuit breaker to your smart contract

Smart contracts can't be changed after deployment. Always include a circuit breaker in your contract to reduce unnecessary (and expensive) bugs.

Don't ‒ Let contracts run without oversight

Allowing contracts to run without oversight is high-risk because contracts are irreversible and immutable (and discovering a vulnerability after deployment can be risky and expensive).

2. Encrypt Data

Do ‒ Encrypt all sensitive data in contract storage

Data on public blockchains can be read by anybody, so encrypting sensitive data is an absolute must to preserve security and privacy.

Don't ‒ Assume private variables will hide your data (they won’t)

Private variables within a smart contract are not actually private. "Private" means within the execution scope of the contract, but the data is public and can be read by anyone.
‍

3. Add Limits

Do ‒ Enforce per transaction and rate limits

Smart contracts are immutable and bugs or errors can have significant unintended consequences. Enforcing rate limits helps mitigate risk.

Don't ‒ Permit uncontrolled loops, transfers and rates

Uncontrolled loops, transfers, and rates increase risk and potential for damage, including unintentionally depleting funds.

4. Check Inputs

Do ‒ Check all inputs before using them in code

Because smart contracts are immutable, fixing errors is incredibly expensive and checking inputs before using them in code mitigates errors. “Fail Fast” is a good tenet for your code.

Don't ‒ Make any assumptions about input values

Making assumptions can leave room for errors and cause smart contracts to execute code in a way that was not initially intended.

‍

5. Minimize On-chain Data

Do ‒ Keep smart contracts small and modular

Every line of code in a smart contract costs money to execute and storing data is incredibly expensive.

Don't ‒ Store unnecessary data on-chain

A best practice is to store a pointer to data in a smart contract, rather than storing the data itself. For example, data can be stored using decentralized data storage providers such as Sia or IPFS.

Smart contract development can be confusing, using great tools can make it easier. These best practices (and more!) are built into DappStarter, Decentology's full-stack blockchain application generator.

More best practices for blockchain app development (3 part series):

Smart Contract Best Practices

Blockchain App UX Best Practices

Tips to Avoid Costly Mistakes in Blockchain App Development

Block COVID global virtual innovation camp with blockchain and tech experts

Mai Luong — Sat, 11 Apr 2020 09:14:19 +0000

The dramatic spread of the COVID-19 pandemic has disrupted lives, communities and businesses worldwide. If you wondered what you could do to help, consider joining the Block COVID global virtual innovation camp where you could contribute ideas and work on innovative solutions that solve problems for “the new normal”, while learning from thought leaders in blockchain and across diverse industries.

Block COVID is a month-long virtual open innovation camp to activate anyone anywhere to build COVID-19 solutions on the blockchain and more. By providing a collaboration platform, mentorship, subject-matter expertise, and technical support, the program aims to inspire and catalyze implementable products to address societal challenges arising from the COVID-19 pandemic by the end of the month.

Organized by TryCrypto and WEF Global Shapers, the innovation camp will be joined by some of the best and brightest in the technology, design, and social impact community. Leading blockchain projects such as Truffle and Sia will also be part of the program.

Block COVID will provide an opportunity for participants to:

• Learn new tools to ideate, design, build, and implement innovative solutions, such as creating service design frameworks and shipping blockchain applications

• Hear from thought leaders across diverse industries and put their top tips into practice

• Connect with other developers, designers, entrepreneurs, students, industry experts, and more!

• Make a difference in the world!

Details:
https://blockcovid.org
Join the Block COVID Slack channel to connect with other participants and stay updated with the program.