Forem: MacBobby Chibuzor

Using AWS Blockchain Templates for Hyperledger Fabric Development in Go (2)

MacBobby Chibuzor — Sun, 20 Feb 2022 20:38:49 +0000

Components and Frameworks

All the software to be used for Hyperledger Fabric Blockchain development is available in the AWS Elastic Container Registry (ECR) in Docker containers. The components on the network will run in containers, which will run on a single AWS EC2 Instance.

The peer, orderers, and endorsers will be provisioned in docker containers, and a PostgreSQL database ledger will be used in a separate docker container. Hyperledger Explorer will also run in a separate docker container that will allow you to monitor transactions and blocks on your blockchain network.

These containers are the components and frameworks that make up your Hyperledger Fabric blockchain on the AWS Cloud.

Docker Containers

Docker containers package source codes and dependencies in images. The image contains everything needed to host an application.

The AWS ECS is a fault-tolerant, scalable Docker container management service for managing container lifecycle. It has two launch types:

AWS Fargate
AWS EC2 Instance

Docker-compose will be used to create a multi-container application, having its configuration setting in a YAML file. AWS provides the YAML file, making setup easier.

Network Architecture on Hyperledger Fabric

The network architecture on the Hyperledger Fabric blockchain network is structured as follows:

Set up a VPC on a single availability zone
A public subnet will be set up
An EC2 instance will be set up also, connected to the Security Groups via SSH
The EC2 instance will access the containers that will contain the blockchain network resources
In the EC2 Instance, Docker containers will host the peers, the orderers, the Explorer, and a PostgreSQL database ledger.

Creating a VPC

Create a VPC with a public subnet

Follow these steps to create a VPC with a public subnet:

Navigate to the AWS home page on your browser. Click on Create an AWS Account if you do not already have one, or Sign in. AWS has a 12-month free tier access account you can use for the time being, so you can create a new account.
Enable billing for your account as you will be billed for overusing the free privileges in the free tier access.
Click on Services and search for VPC.
Click on VPC > Launch VPC Wizard .
Click on Select in the first option: VPC with a Single Public Subnet
Leave the default settings on the first section on IP addresses, but at a VPC name of your choice. This article uses the VPC name: HyperLVPC.
In selecting Availability Zone, keep in mind that AWS Blockchain Templates are only available in three zones: US East 1 in North Virginia, US East 2 in Ohio, and US West 2 in Oregon.
Name the Subnet however you want. This article uses the Subnet name: HyperLSubnet.
Click on Create VPC after completing these settings as seen below.

You will see a success message. Click on Your VPCs and you will see your VPC running.

Setting up key pair and Configuring Security Groups

Setting up a Public-Private key pair allows authentication of connections from your local machine to the EC2 Instance on AWS. Follow the steps below to set this up:

Go back to the Services dashboard and search for EC2.
Next, browse through the left navigation pane for the Key Pairs option under the Network & Security section. Select Key Pairs.
Click on Create key pair at the top of the screen. Confirm that you are creating a Key Pair under the same region as your VPC.
Name the key pair as you wish. This article uses the Key pair name: HyperNewKey.
Leave the default settings once again and click on Create key pair below the screen.

The next window displays a Success message, along with your active key pair as seen below.

Copy and store the key safely as you will need it to authenticate yourself while connecting to the new Instance. Notice that it is downloaded in a .ppk file immediately after this window was displayed.

our key pair:
key-0a666d865fc023d4c

Click on Security Groups on the navigation pane and under the Network & Security section.
In the new window, click on Create security group at the top of the page. Security Groups in AWS are similar to Firewalls.
Name the Security Group as you wish. This article uses the Security Group name: HyperFabSG.
Next, add a description of your choice and click on the Create Security Group at the bottom of the page.

Group rules can be created here in the Security Groups section. These rules control the traffic flow. To create a few rules, scroll down the current page displaying the Success message and click on the Edit Inbound Rules tab.
On the new screen, click on the Type field displaying Custom TCP by default and select SSH. In the Source type field displaying Custom by default, select My IP.
Click on Add rule to create a new rule with the following credentials: Type: Custom TCP, Source Type: My IP, Port Range: 8080.
Click on Save rules now.

After the successful modification, new Policies and Roles will be created.

Creating Policies and Roles

The policies and roles will be created next. The roles are first created, then policies are attached to them.

This will require the AWS Identity and Access Management (IAM) service. Follow these steps below to set Roles and Policies on AWS IAM:

In Services, search for IAM. After clicking on it, you should see the window display
Click on Policies in the left navigation pane.
Click on Create Policy, which should take you to a new window where you can create new policies with either a Visual editor or with JSON.
Select whichever you wish and paste your new policy. This article uses JSON with the policy available here.
Next, click on Next: Tags and click Next: Review.
Finally, add the name of your Review Policy. This article uses the Review Policy name: EC2HyperFPolicy.
Review the summary and click Create Policy.

Next, the roles that will manage these policies will be created.

Click on Roles on the left navigation pane.
Click on Create Role at the top of the page to create a new role.
Select the EC2 instance in the Use Case section at the bottom of the page.
Click Next and on the next window, select the policy you just created: EC2HyperFPolicy.
Click on Next at the bottom of the page again, and specify a Role name as you wish. This article uses the Role name: EC2HyperFRole.
Next, Click on Create Role.
Click on View Role to see the summary of the newly created role. Copy the instance profile ARN (Amazon Resource Name) in the summary.

arn:aws:iam::428223012719:instance-profile/EC2HyperFRole

Creating the Hyperledger Fabric Network with AWS CloudFormation Stack

To create the Hyperledger Fabric, navigate to the AWS Blockchain Templates page and follow these steps:

Click on the Get Started with AWS Managed Blockchain link.
Navigate to AWS Blockchain Templates for Hyperledger Fabric.
Select the Launch in US East (Ohio) region (us-east-2) which is the region for the subnet used in this article.
It automatically launches the CloudFormation stack and displays the home screen to quickly create a stack on AWS and configure the Hyperledger Fabric network on a single Amazon EC2 instance.
Create a new Stack Name with your preferred name. This article uses the Stack Name: HyperFabricStack.
Next, specify your organization’s domain name in the Domain field. This article is a demo, hence, the default is used.
Peer organizations are also available, should you have organizations to add.
Scroll to the field for VPC ID, and select the VPC you created. HyperLVPC is selected for this article. Also, do the same for the VPC Subnet, EC2 Key Pair, Security Group, and paste the copied instance profile ARN.
Select the Default for other settings.
Click the two checkboxes under the Capabilities section and click the Create Stack button at the bottom of the page. The following page is displayed:

At this point, you have a complete Hyperledger Fabric blockchain network running on the AWS Cloud.

Conclusion

This article walked you through the process of creating your first Hyperledger Fabric Blockchain platform on the AWS Cloud.

The next article will also be technical as you will learn how to write a Chaincode in the Go programming language, and deploy it on AWS.

Being the final article in the series, you will put all you have learned into practice, and build your foundation as a Hyperledger Fabric Blockchain Developer.

Blockchain DevOps on AWS with The Hyperledger Fabric Model and Golang (1)

MacBobby Chibuzor — Sun, 20 Feb 2022 20:20:02 +0000

The Blockchain

The Blockchain is an encrypted database of transactions stored in a distributed ledger.

Blockchain transactions are exchanges of value in the form of digital money, and the transactions are stored on a ledger to record the transactions. Transactions are immutable, verifiable, and incorruptible.

Blockchains operate with decentralized technology, hence have no single point of failure.

Smart Contracts are pieces of code that control actions on a blockchain network. They are similar to the business logic of Web2.0.

To add entries to a shared ledger, a smart contract must be executed. Consensus protocols are what regulate and decide which node/computer/peer can add entries to a blockchain. Consensus protocols are what empower these nodes to be able to agree upon:

the transactions that get added
the order of transactions to be added

Once nodes accept a blockchain transaction, the transaction gets stored permanently on the blockchain network.

The Hyperledger Project

Hyperledger is not a blockchain, company, or cryptocurrency.

It is a parent project of open-source blockchains and tools started in December 2015 by the Linux Foundation.

It is made up of three components:

Developers and communities
Frameworks and tools
Industries like finance, IoT, supply chain, and manufacturing

Developers

The developers of the Hyperledger Projects are blockchain specialists who are also developers working in different industries and who want to see the blockchain technology used in diverse fields.

Frameworks and Tools

Frameworks include the following:

Hyperledger Fabric by IBM
Hyperledger Sawtooth
Hyperledger Iroha for mobile apps
Hyperledger Burrow built to support the EVM
Hyperledger Indy which supports independent identities on distributed ledgers
Hyperledger Cello for deployment
Hyperledger Composer for UI
Hyperledger Caliper for benchmarking
Hyperledger Explorer for monitoring application status

Industries

IBM, Intel, Wells Fargo, etc., are examples of companies who are involved in the Hyperledger Project

Deep Dive in Comparison

Ethereum is an open-source, public blockchain-based platform that is used to build smart contracts. Ethereum has a cryptocurrency called Ether, used to reward nodes for work done on the network. The smart contracts are written with language such as Solidity.

Ethereum has problems with scaling and speed. The Proof-of-Work algorithm consumes relatively more computing power and resources. Also, each transaction in the Ethereum network gets broadcasted to all nodes in the network, discouraging the idea of confidentiality.

These issues are behind the creation of the Hyperledger Project.

Hyperledger Fabric

The Hyperledger Fabric framework is an open-source, enterprise-grade, permissioned distributed ledger technology platform designed for use in an enterprise application. Hyperledger Fabric is used to build private blockchain networks where all nodes are known and verified. “Known” does not mean trustworthy, but that the peers on the network are not anonymous.

Advantages of Hyperledger Fabric

The following are advantages of the Hyperledger Fabric framework:

1. It is permissioned

Unknown peers are not allowed to participate, and there are private channels between the peers. Membership Service Providers (MSPs) are used to regulate the peers who join the network. Verification is important and compulsory in Hyperledger Fabric. Channels can also be set up to allow for private communication between subsets of nodes. These private channels have private ledgers that no external node can access.

2. Transactions are fast

There is low latency and high throughput for verifying and accepting transactions. Transactions on Hyperledger Fabric are executed using smart contracts also, but they are called Chaincodes in Hyperledger Fabric. Hyperledger Fabric Chaincodes are written in languages such as Golang, or NodeJS. They are not written with contract-purpose programming languages like Solidity.

Chaincodes have standard interfaces with two methods: the init and invoke methods to initialize the smart contract and to invoke or execute the smart contract, respectively.

The execution of a transaction through a smart contract is done by a few endorsing peers. The percentage of the peers endorsing the transaction is determined by an Endorsement Policy. However, the execution does not update the actual ledger. Instead, endorsed transactions are passed down to Orderers.

Orderers determine the sequence of the transaction. Ordering is of different types:

SOLO Ordering
Kafka distributing system
Practical Byzantine-Fault Tolerance

Next, the transaction is passed on to Committing peers. The Committing peers of that particular Hyperledger Fabric network are responsible for validation and “merging” or committing the transaction to their private ledger copy.

They only accept/validate correctly endorsed transactions, and verify that the transaction is valid with the latest version of the shared ledger. If the transaction is found wanting, they are invalidated by the Committed peers.

The lifecycle of a transaction on the Hyperledger Fabric network makes the issue of double-spending inexistent and makes sure that the sender has the asset they want to send.

3. Easy to Plug

It is designed to be modular, so developers can use different databases, membership service providers, consensus algorithms, etc.

A Transaction’s Lifecycle on the Hyperledger Fabric

A client application submits a transaction proposal to Endorsing peers through a Chaincode or smart contract. The Endorsing peers execute the Chaincode and endorse the transaction. The transaction is then sent back to the client application with signatures. The client application then sends the signed transaction to Orderers.

Once the Orderers order the transaction, they pass it on to the Committing peers who perform their duty as explained above and add the transaction to their private copy of the ledger. The Committing peers then send the Confirmation of the transaction to the client application.

Transactions involve hardware assets or software assets; apparently anything of monetary value that can be exchanged between two parties.

Hyperledger Fabric vs Ethereum

The following are highlights of the differences between Hyperledger Fabric and Ethereum

Ethereum is permission-less, Hyperledger Fabric is permissioned
Peers have to be verified, known, and approved to be part of the private Hyperledger Fabric platform.
In Hyperledger Fabric, not all users can validate or endorse transactions, but it is so on Ethereum.
Hyperledger Fabric does not have a cryptocurrency to incentivize nodes for reward of work done. Ethereum has the Ether cryptocurrency for this.
In Hyperledger Fabric, transaction execution mechanism is with Chaincodes and not Smart Contracts as in Ethereum.
The transaction lifecycle on Hyperledger Fabric involves: execute transaction —> order the transaction —> validate the transaction. In Ethereum, it involves: order the transaction —> then execute the transaction. Validation does not exist separately in Ethereum.
Transactions can be kept private from some peers in the Hyperledger Fabric network, but in Ethereum, all transactions are broadcasted to all nodes in the network.
General-purpose languages like Go, Node.js and Java are supported on Hyperledger Fabric, but contract-purposed, domain-specific language like Solidity is used on Ethereum.
On Hyperledger Fabric, the consensus protocol is broad and generic. On Ethereum, it is Proof-of-Work (soon, Proof-of-Scale).
Little effort and resource is wasted in Hyperledger, making it scale far more easily than Ethereum which consumes much more effort and resource.

AWS Blockchain Templates

AWS Blockchain Templates supports two blockchains (Verify this):

Ethereum
Hyperledger Fabric

Only build on the Hyperledger Fabric if you want to a private network for your organization, as only known and verified peers are allowed.

AWS Blockchain Templates specify the network components of your blockchain platform, with a network configuration file. You can also run Chaincode or DApps on the AWS Cloud.

The following are tools on the AWS Cloud that will be used in building the Hyperledger Fabric platform:

AWC EC2 to configure peers, orderers, and the ledger
AWS ECR Docker container registry to provision containers for nodes
Amazon VPC to provide private network access to cloud resources
AWS Security Groups for controlling traffic flows to and from the network.
AWS Roles for access control
AWS CloudFormation Stack for the blockchain network

Conclusion

This article presents a swift guide to the Hyperledger Blockchain platform. The Hyperledger Fabric framework is explained and compared to the popularly adopted Ethereum blockchain.

The next article will take a more technical approach to practice some DevOps principles using the AWS Blockchain Template explained in this article, to build a private Hyperledger Fabric network with the Go programming language.

You can learn more about the Hyperledger Project here.

Data Structures and Algorithms with Go (2): Growing Your Go Skills with Trees

MacBobby Chibuzor — Sat, 19 Feb 2022 18:12:21 +0000

Trees

Trees are non-linear data structures used mainly for searching. Trees have maximum nodes of two children and a minimum of none. In trees, the property values of the left node are lesser than the property values of the right node. Nodes with no children are considered leaves.

Must-knows about trees

A binary tree is a data structure where each node has 0, 1, or 2 sub-nodes.
The root node is the first node of the tree, having no parents.
An edge is the link from child to parent.
The depth/height of the tree is the longest path from the root node to the furthest node.
The depth of a node is the number of edges from the node to the root of the tree.
A leaf is a node with no children.
The children of the same parent are called siblings.
Ancestors of a node are parent/grandparents to the parent of the node's parent.
Trees are either balanced or unbalanced and balancing a tree is difficult and slow.
The size of a tree is the number of descendants it has including itself.

Binary search tree

A tree is called a binary tree if it has a maximum of two child nodes. An empty tree
is also a valid binary tree. Binary trees have a root node with a left and a right subtree.
Binary search trees allow look-up operations, as well as addition, and removal of elements.
They store keys in a sorted order, to make look-up operations faster. Their space complexity is
of the order O(n), but their operations like insert, search, and delete are of the order O(log n).
Binary trees have the following properties:

key of type int

value of type int

LeftNode of the node's type instance
RightNode of the node's type instance

For example, the properties are arranged thus:

type TreeNode struct {
    key int
    value int
    leftNode *TreeNode // best to put it first, as the orientation is left | value | right
    rightNode *TreeNode
}

Binary tree operations

Operations possible with binary trees are grouped into two:

Basic Operations

Inserting elements to a tree
Deleting elements from a tree
Searching for elements in a tree
Traversing the tree

Auxiliary Operations

Finding the size of a tree
Finding the height of a tree
Finding the level with the maximum sum
Finding the least common ancestor (LCA) for a particular pair of nodes
Others

Applications of binary trees

The following are examples of use-cases of binary trees:

Expression trees for compilers
Huffman coding trees for data compression algorithms
Binary search trees (BST) for searching, inserting, and deleting in O(log n)
Priority queues (PQ) for searching and deleting minimum or maximum values in O(log n) time.

Implementing binary trees in Go

Below is an example code where binary trees are implemented:

package main

import (
    "fmt"
    "math/rand"
    "time"
)

// Tree type of recursive struct
type Tree struct {
    Left  *Tree
    Value int
    Right *Tree
}

// traverse method allows visiting of nodes with recursion
func traverse(t *Tree) {
    if t == nil {
        return
    }
    traverse(t.Left)
    fmt.Print(t.Value, " ")
    traverse(t.Right)
}

// create function populates the branches with random integers
func create(n int) *Tree {
    var t *Tree
    rand.Seed(time.Now().Unix())
    for i := 0; i < 2*n; i++ {
        temp := rand.Intn(n * 2)
        t = insert(t, temp)
    }
    return t
}

// insert recursive function does lots of functions with each if statements
func insert(t *Tree, v int) *Tree {
    if t == nil { // if the tree is empty
        return &Tree{nil, v, nil}
    }
    if v == t.Value { // if the value exists in the tree
        return t
    }
    if v < t.Value { // if the value should go left or right
        t.Left = insert(t.Left, v)
    }
    t.Right = insert(t.Right, v)
    return t
}

// main function
func main() {
    tree := create(10)
    fmt.Println("The root of the tree is ", tree.Value, " \n.")
    traverse(tree)
    // fmt.Println()
    tree = insert(tree, -10)
    tree = insert(tree, -2)
    traverse(tree)
    // fmt.Println()
    fmt.Println(" \n The root of the tree is ", tree.Value)
}

Conclusion

This article teaches the reader about Trees and binary trees. The possible operations
with binary trees were also given, along with an implementation of some of these
operations.
In a future article, applications of binary trees in problem-solving with the Go
programming languages will be given.

Get Started with ROS for Embedded Robotics

MacBobby Chibuzor — Sat, 12 Feb 2022 18:52:50 +0000

Introduction

Robotic systems are built to have both software and hardware parts. While the hardware is easier to build, the software — which is responsible for adding intelligence to the robot — is not as easy.

To make the development process less cumbersome and more efficient, an ex-Google researcher built the ROS framework. This article provides fundamental knowledge required to learn about ROS and Robotics, and to apply ROS in projects.

On Robotics

What are Robots?

A robot is a machine built to execute one or more tasks automatically with speed and precision. IEEE defined a robot as “An autonomous machine capable of sensing its environment, carrying out computations to make decisions, and performing actions in the real world.

Anatomy of a Robot

Sensors

Robots have sensors for the eyes and for gathering information. There are different types of sensors for other tasks. For example, the ultrasonic sensor is used for obstacle detection and avoidance, while the PIR motion sensor is used for motion detection. LiDAR stands for Light Detection and Ranging and uses laser pulses. LiDAR is used for obstacle detection and avoidance and object recognition due to its scanning and 3D mapping functionality.

Robots use cameras and AI algorithms to identify and recognize objects. An example of an AI algorithm used by robots is the YOLOv5.

Actuators

Robots use actuators to carry out mechanical action (motion) based on the feedback data gotten through sensors.

Mobility

Mobility is achieved in a technically complex way. It involves the use of Navigation processes (like the ROS Navigation Stack), Sensors (like IMU, Encoders, and LiDAR), software algorithms like (Obstacle Detection and Avoidance algorithms), motors and wheels of different kinds, 3D Cameras, and Mechanical Arms for Spatial Manipulation.

As mentioned, wheels provide translational motion for robots. They come in different forms and sizes for different terrestrial settings and tasks.

Motors are responsible for spinning the wheels. An engine is a device that converts electrical energy into mechanical energy.

Encoders allow you to measure the speed of a motor dynamically.

Microcontrollers are the brains of the robot. All the codes and machine learning workflows required to automate the robot — to tell it what to do — lives embedded inside these microcontrollers. Examples include the Arduino and Raspberry Pi microcontrollers.

Communication

Communication is achieved with 4G or 5G WiFi Modules.

The ROS Framework

For Route Planning and Navigation, robots can make use of the ROS. ROS provides the Software Development Kit needed to configure the robots to navigate their motion. Being software, ROS requires hardware to run. The hardware is in the form of a computer. Examples of computers that are suitable to run ROS include:

NVIDIA’s Jetson Nano
Raspberry Pi computers
Laptops and PCs

ROS Tools and Syntax

Tools used include the following:

RVIZ
Gazebo
RTQ

RVIZ is a visualization tool provided by ROS. It is a GUI interface that lets you visualize big data from sensors and ROS Topics. It also allows the roboticist to create a real-time map of a given space.

Gazebo is a virtual prototyping tool that roboticists can use to simulate their robotics project without having to spend on acquiring or using hardware. This makes robotics development even more cost-friendly as it nullifies the need for Rapid Prototyping. It helps minimize errors, and maximize accuracy and efficiency in robotics development.

The RQT Tool is used to visualize the communication between Nodes in a ROS program. With this tool, you can plot messages for communication, monitor data created by a Node on other Nodes.

ROS programs are broken down into:

Nodes and child nodes
Topics
ROS Master

ROS nodes are written in C++ and Python; hence a roboticist must know both languages.

Getting Started with ROS

The best resources for getting started in ROS installation and setup are available on the official ROS website. Every new ROS version is given a new name: at the time of this writing, Foxy Fitzroy is the name for the latest version.

Follow the guide in the link above to install ROS for your specific operating system.

Navigation Stack in ROS

ROS navigation makes it easier for robots to carry out translational motion without issues. Sensors publish information using Nodes and Topics. Nodes interchange information with each other using Topics. ROS provides Nodes that manage the movement of robots using the navigation stack. This is achieved in three steps:

Perception - collecting data/information using sensors as mentioned above
Decision Making - the making of decisions using information gotten from the perception stage, based on algorithms
Actuation - carrying out motors’ decisions to move at specific speed and direction.

The Navigation Stack has a more profound and more complex process than is explained here, like Mapping, Sensor Transforms, and Odometry.

Who uses ROS and why?

ROS is a set of software libraries that provide tools to build robot applications. It covers the need for drivers, algorithms, dev tools, and visualization/data monitoring tools.

Companies that use the ROS framework include — but are not limited to — NVIDIA, PAL Robotics, INTEL, AWS, ROBOTIS, FETCH Robotics, DJI, CLEAR-PATH.

Where to learn about ROS and Robotics

1. Online Robotics Programs in Northwestern University

The Modern Robotics Program is online and free and is taught by Professor Kevin Lynch. The specialization includes topics in the following categories:

Foundation of Robot Motion
Robot Kinematics
Robot Dynamics
Robot Motion Planning
Robot Manipulation and Wheeled Mobile Robots
Capstone Project

2. Online Robotics in University of Pennsylvania

The courses are taught by 6 lecturers, including Vijay Kumar and Daniel Koditschek. The topics in the specialization include:

Aerial Robotics
Computational Motion Planning
Mobility
Perception
Estimation and Learning
Capstone

3. Wiki ROS

The ROS wiki page has in-depth and helpful tutorials on ROS. It is the most important website for ROS learning because it has tutorials, examples, and projects.

Others include MIT Open Courseware on Robotics, MIT’s Introduction to Deep Learning, Robot Programming in the Queensland University of Technology by Peter Corke, and Udacity’s Basics of ROS Applied in Self-Driving Cars.

Conclusion

Now that you have understood what robots are and how the ROS software development kit is useful for developing robotics software applications, you should go on with developing your knowledge of Robotic systems if you haven’t already while learning and applying the ROS framework.

You can find and build open-source projects on linorobots.org, Arduino.cc, or automaticaddison.com.

Cheers.

Creating Virtual Machines and NGINX Servers on Google Cloud Platform for Go Web Apps

MacBobby Chibuzor — Sat, 12 Feb 2022 15:23:00 +0000

Introduction

This article teaches the reader the concept of virtual machines that run on the cloud, their uses, and how to set them up on the Google Cloud Platform.

The reader might be a web developer looking to get started with Cloud or DevOps engineering on the Google Cloud Platform.

Prerequisites for this course

This article is a practical one, requiring the reader to follow along with the procedures while working on their own computer. Hence, the following are prerequisites for this article:

a personal computer
a free tier or normal account on GCP with Billing enabled
working knowledge of Go programming language

Virtual Machines

The concept of virtual machines is similar to launching a secondary operating system on your computer. Think of it as creating a virtualized version of a computer. The idea is to recreate or mimic everything you can do with your physical computer relating to specific computing functions.

Example uses of virtual machines include:

creating remote operating systems on your local computer
connecting temporarily to a network, platform, or system to perform tasks solely exclusive to that platform
practicing unsafe concepts like pwning a machine, etc
development and testing environments
supporting DevOps practices
enabling workload migrations, etc

Let’s look at the Go language that we will use for the project in this article.

Go

The Go programming language was created in 2007 by Google to solve problems in the area of multicore processors, networking systems, large codebases, computation clusters, and general web development. It has intense dependency management, supports scalable software architecture, and maintains cross-platform robustness.

Google developed the language to simplify development, eliminate clumsiness during development, control dependency, ease of writing script automation tools, boost code reuse, etc.

It is logical to work on the Google Cloud Platform with Google’s Go programming language 🙂. You can learn more about Go at Google here.

Starting the Cloud Shell

First, navigate to the Google Cloud Platform on your browser. Next, create an account (This article assumes you know how to set up an account comfortably).

Upon login on the cloud platform, you will be greeted with the following or similar window:

After the search icon in the navigation bar, you will see another icon that symbolizes “Code” or “Terminal,” depending on your familiarity. It has a greater than sign and an underscore: [>_ ].

Click the icon, and it will spawn a remote terminal just below your current page.

What You Can Do On The Google Cloud Shell

The Google Cloud Shell, or gcloud CLI, is a useful tool similar to your Git Bash or standard shell. The difference is that it has its own set of commands and functionalities. You can do the following on gcloud CLI:

creating and managing Compute Engine virtual machine instances and other resources
deploying App Engine applications
creating and managing Cloud SQL instances
managing authentication
creating and managing Google Kubernetes Engine clusters
creating and managing Dataproc clusters and jobs
for Cloud DNS managed zones and record sets
for Cloud Deployment Manager deployments
customizing local configuration, etc

You can download the gcloud CLI locally or remotely use it on the Compute Engine shell. If you decide to download the CLI to your local computer — especially if you’re going to be using it for long — you should Install the CLI with these instructions..

Basic Commands

gcloud CLI commands can be run on the Cloud Shell or cloud automation platforms. For example, you could run Cloud Compute commands on Kubernetes Engine to automate it. The four categories of commands for gcloud include:

gcloud compute
gcloud compute instances
gcloud beta compute
gcloud alpha app

These categories support commands that are product- or feature-specific for the Google Cloud Platform.

Let’s take a look at some basic commands.

Initialize the gcloud CLI with the following command:



$ gcloud init

you can display the version of the CLI with the following command:



$ gcloud version

The gcloud CLI supports the installation of specific components. You can install and update components with the following commands:



$ gcloud components install

$ gcloud components update

List active user account with the following command:



$ gcloud auth list

Check the current project ID with the following command:



$ gcloud config list project

Like other CLI you may have used before, the gcloud CLI support options and flags too.

To learn more about the CLI commands on gcloud, click here.

Starting a new project on Google Cloud Platform with the `gcloud CLI`

You may be launching the cloud shell only when you want to start a new VM for a project. This way, you can start a VM with the command below:



$ gcloud compute instances create <project_name> --machine-type <type_of_machine> --zone <a_preferred_zone>

For example, let’s create a project named projtest. The entire command will be:



$ gcloud compute instances create projtest --machine-type n1-standard-2 --zone us-central1-f

This command spins an instance with the following output:



Created [...projtest].
NAME     ZONE           MACHINE_TYPE  ...    STATUS
projtest us-central1-f  n1-standard-2 ...    RUNNING

On Machine Types

When you create a virtual machine instance on the Google Cloud Platform, you are required to choose a machine type that will determine the resources available to your new virtual machine.

This article created an instance that uses the n1-standard-2 machine type. Nevertheless, you can choose an alternative like nq-highmem-4 or n1-highcpu-4 machine types. You can even create your machine type. There are machine series and family categories in the Google Cloud Platform, and you can learn about them here.

Also, you can use the GUI to create a new VM instance. by following these procedures:

Click the Navigation Menu
Click on Compute Engine and select VM Instances
Click Create Instance
Configure every parameter in your preferred way

It is advisable to setup an instance using ssh

Next, let’s see what an NGINX web server is and how to install it on the Google Cloud Platform.

Installing an NGINX web server on Google Cloud Platform

The NGINX (pronounced “Engine X”) webserver is among the most popular and widely used web servers in cloud/web development. Nginx runs about 30% of the web servers in the world, and is seeing more adoption. Like every other web server software, NGINX runs on top of an operating system. The operating system runs on physical hardware. You can have NGINX installed on your local machine, or on the Google Cloud Platform.

// more about NGINX servers

Installing an NGINX webserver

Navigate to the console and run the following command to get root access:



$ sudo su -

Next, update your selected operating system with the following command:



$ apt-get update

The following or similar output will be generated:

(image)

Now, install NGINX on your console with this command:



apt-get install nginx -y

You can confirm that NGINX is appropriately set up on your console with the command:



$ ps auwx | grep nginx

The following or similar output will be generated:



root      2320  0.0  0.0 175532  1748 ?        Ss   14:06   0:00 nginx: master process /usr/sbin/nginx -g daemon on; master_process on;
www-data  2321  0.0  0.0 159924  3004 ?        S    14:06   0:00 nginx: worker process
www-data  2322  0.0  0.0 154874  3114 ?        S    14:06   0:00 nginx: worker process
root      2332  0.0  0.0  19680   758 pts/0    S+   14:07   0:00 grep nginx

You have successfully installed an NGINX web server on your GCP VM instance.

Next, let’s create a basic Go web app on a Google Cloud Platform Virtual Machine instance.

Creating a Basic Web App with Go on a Virtual Machine

To build a Go web app on top of Google Cloud Platform, we will utilize our just learned knowledge of the gcloud CLI and others.

First, open the Google Cloud Shell.

Next, create a project in the Project Selector page on GCP.

After this, you need to enable the GCP Cloud Build API using the following procedure:

Open the Navigation Menu
Click on the APIs & Services, select Library, then search for the Cloud Build API.
Click Enable

To enable billing, you need to have a free tier account if you’re not using GCP professionally.

Afterward, you will install and initialize the gcloud CLI if you didn’t before. Running the following command will create an app engine that will provide the needed resources to develop and maintain your app.

To start the web app, you need to run the following command:



$ gcloud app create

After this, you can start your web app directly by creating a directory that will contain a yaml file and your Go source file.

The yaml file is what will initialize the Go environment to run your application. Without a yaml file, no application project will run.

Thus, we create an app.yaml file in the directory and the main.go source file. Your basic web application code will reside in the source file.

To deploy the web application on the App engine, run the following command:



$ gcloud app deploy

You can view your new web application if it is done right by running the following command:



$ gcloud app browse

Conclusion

In this article, we learned about Virtual Machines and their uses. Next, we looked at the Go programming language and why it was created by Google. We further learned how to start a Cloud Shell session on the Google Compute Engine as a Virtual Machine instance. Furthermore, we looked at NGINX web servers and how to install and spawn them in the Cloud.

In a future article, we will build a web app in Go, putting all we have learned here into practice. We will build a proper Go application, learn how to structure a complete codebase for a project on GCP, and finally deploy the web app on the App Engine.

See you soon!

Get Smarter About Smart Contracts

MacBobby Chibuzor — Sun, 06 Feb 2022 08:24:28 +0000

Introduction

This article is an unusual introduction to smart contracts, Solidity, and Blockchain.
You will add to your knowledge about Smart Contracts, their building languages, development environment, vulnerabilities in smart contracts, and the syntax of contract-specific languages.

Smart Contracts - What's Smart About Them?

Smart contracts are pieces of computer software or a transaction protocol intended to execute automatically, control, or document legally relevant events and actions according to the terms of a contract or an agreement.
They are considered smart, perhaps due to their self-executing nature.

On Choosing a Language to Author a Smart Contract

Solidity is the most popular language for authoring smart contracts. However, there are other Ethereum-specific languages that are compatible with the Ethereum Virtual Machine. They include:

Serpent
Vyper (a close competitor to Solidity)
Bamboo
LLL

The EVM is rigid, hence the importance of sticking with languages that are specifically built for author smart contracts. Why were they built in the first place? It's relatively easy building a specific-purpose language from scratch compared to hammering and bending a general-purpose language to suit the needs of the EVM.

If you are interested in using a high-level, general-purpose language for smart contracts, you must choose between Golang and Rust. Reasons include Rust being the language for the Party client and Golang, the Geth client.

Tools for Authoring Smart Contracts

Setting up your Development environment for smart contracts development is not a specific process. The following are tools you may require:

1. Remix IDE

Remix is a powerful, open-source tool that helps you write Solidity contracts straight from the browser. Written in JavaScript, Remix supports both usage in the browser and locally.
Remix also supports testing, debugging, deploying smart contracts, and much more.
You can read further about Remix in the official documentation. You can also download Remix here.

2. Truffle Framework

Truffle is a world class development environment, testing framework and asset pipeline for blockchains using the Ethereum Virtual Machine (EVM), aiming to make life as a developer easier.
You can learn further about Truffle from the [official documentation.](https://truffleframework.com/docs/truffle/overview] You can also get Truffle here.

3. Embark Framework

Embark is a fast, easy to use, and powerful developer environment to build and deploy decentralized applications, also known as “DApps”. It integrates with Ethereum blockchains, decentralized storages like IPFS and Swarm, and decentralized communication platforms like Whisper.

Embark’s goal is to make building decentralized applications as easy as possible, by providing all the tools needed and staying extensible at the same time.
You can read further in the official documentation. You can also get Embark here.

Greeting the Blockchain in .sol

It is a common tradition to print out “Hello World” in Web2. Whoever invented that rule should accept the Decentralization gospel.
We are going to print out “Hello Blockchain” in Solidity in comparison to other languages. We will also learn the basic structure of a contract.

pragma solidity ^0.8.10;

contract HelloWorld {
    string public greet = "Hello World!";
}

Dissecting Solidity Code with Solidness

1.





```pragma```

 is the compulsory first word in the first line of code within any Solidity file.

 ```pragma```

 is a directive that specifies the version of Solidity compiler to be used for current Solidity file.

### 2.

 ```Solidity ^0.8.10;```


Solidity is a new language and is subject to continuous improvement on an on-going basis. Thus, there are older and newer versions and you could set a range of compiler version with this syntax:



```Solidity
pragma solidity >= ^0.5.0 < 0.9.0;

This means that any version between that range can run/compile the Solidity source file.

3.



As stated earlier, Solidity is created to be EVM-Compatible. It is a contract-specific language. A smart contract is a set of functions that does stuff. Thus, in-between the

 ```contract Name{ }```

 tags, there are other properties, including functions, data types, and technically every other thing you have in a normal object oriented language.

### 4.

 ```public```


The

 ```public```

 keyword signifies functions that can be called internally and externally, by any one. 

# Greeting the Blockchain in .vy
Let's greet the rest of the Web3 world again, but this time, with Vyper.



```Python
# @version ^0.2.0

greet: public(String[100])

@external
def __init__():
      self.greet = "Hello Blockchain"

Dissecting Vyper Code without a Bite

1.



You can instantly tell that it means the version of the current Vyper source file.
### 2.

 ```greet```


A public variable named greet is declared as a string data types, and initialized with a max length of 100.
### 3.

 ```@external```


Despite that the contract is set to public, the

 ```@external```

 keyword is repeated. What this means is that the function below it can only be called via transactions or other smart contracts.

....

After comparing these languages, you will notice that Solidity is JavaScript influenced, while Vyper is... you guessed right, Python influenced.

Why build Vyper when Solidity is in high demand and adoption?

# Coming to terms with the Vyper
A [research was conducted in 2018](https://arxiv.org/pdf/1802.06038.pdf), where roughly one million deployed Ethereum Smart Contracts were analyzed. The research uncovered vulnerabilities in these smart contracts. The researchers grouped these vulnerabilities into threw: for ease of identification:
- *Suicidal Contracts* - smart contracts that arbitrary addresses can kill.
- *Greedy Contracts* - smart contracts in a state where they can no longer release ether
- *Prodigal Contracts* - Smart contracts that can be made to release ether to arbitrary addresses.
What's common among these vulnerabilities? 
They are introduced to the smart contracts via code. It could be unintentional from the developer, but regardless, these vulnerabilities have the potential to cause unexpected loss in funds for users. 
That's why Vyper was built. It tries to eliminate this by letting users write secure code and making it difficult for programmers to write misleading or vulnerable code accidentally. 

# Conclusion
This article introduced you to smart contracts. You learned about languages used in writing smart contracts, comparing the two most adopted ones. Next, you see how contracts are written in both languages and what each beginning term stands for. 
Perhaps you concluded on a choice of language for authoring your smart contracts already; however, do put the findings from this article into consideration.


### Did you enjoy this article?
Follow me here and on [Twitter](twitter.com/ghostmac9).

Understanding and Building Authentication Sessions in Golang

MacBobby Chibuzor — Sun, 06 Feb 2022 07:57:13 +0000

Introduction

The Authentication Session of a web app is the heart of it's defense against malicious threats. Hence, it is among the first point of recon for a security tester.
In this article, the Go developer will be enlightened on the authentication sessions of a web app, vulnerabilities and design flaws in authentication sessions, the difference between Session-Based and Token-Based Authentication methods, and when to apply each.
Example use cases for both methods are also given.

Authentication Sessions

A web application’s Authentication protocol is in sessions. The procedure follows like this:

A client sends an authentication request to the log in session of the web app
The web app receives it and sends to the web server
The web server matches it with existing credentials
The web server returns a cookie if a match is found, and then the relevant REST API is called to the needed page.

When web developers build authentication mechanisms, they often rely on either of these methods:

Using HTML forms
Using Multifactor mechanisms
Client SSL-Certificates
HTTP authentication
Authentication Services
JSON Web Tokens

Let's take a look at each of these methods and what they imply.

Using HTML Forms

HTML forms are the most common methods of authenticating web applications, where username and password are collected and submitted to the application. This mechanism accounts for well over 90% of applications available on the internet.

Using Multifactor Mechanisms

In platforms where more security is required, like in online payment systems, a multistage form filling session is initiated, and users are mandated to provide additional credentials. In banking apps, physical tokens are often required. These tokens typically produce a stream of one-time passcodes (OTPs) or provide challenges that require input from the user.
The rule of thumb is to make use of OTPs for highly sensitive data.

Client SSL-Certificates

Some web apps make use of SSL Certificates or cryptographic mechanism. The process involves:

Purchasing and/or Generating a Client Authentication Certificate.
Completing the Validation Process.
Downloading or Exporting the User's Client Certificate.
Importing the Client Authentication Certificate to OS & Browser Certificate Stores.
Configuring the Server to Support Client Authentication.
Testing the Certificate to Ensure It Works.

HTTP Authentication

HTTP based authentication is extremely rare in internet adoption. It is used more on intranet basis. It the most basic form of authentication. In HTTP authentication, client login credentials are sent in the request headers with each request like:

Authorization: Basic YWxqY2U6cGE2NXdbcmQ=

Basic authentication doesn't use encryption on username and password. As such, it's application is limited to cases where there is low value data, and need for easy access.
Even at that, it is advisable to use it:
-On HTTPS connections
-With really strong passwords
-With rate limiting added to prevent brute forcing attacks

Authentication Services

Authentication services are gaining weight in terms of application and credibility. A popular and widely used authentication and authorization service is the Auth0. Auth0 is an easy to implement, adaptable authentication and authorization platform that has gain wide popularity and use among developers.

JSON Web Tokens

JWT, or JSON Web Token, is an open standard authentication protocol used to share security information between two parties — a client and a server. The client credentials are not stored to the server in this case, but transferred back to the client for safekeeping and reuse.

Vulnerabilities in Authentication Sessions

The vulnerabilities and attacks that are possible in HTML forms will most likely work in other methods of authentication, albeit with a little upgrade.
Let's take a look at design flaws that can be exploited in an attack.

Design Flaws in Web Applications

1. Weak Passwords

Weak Passwords are a thing in this era, still. They take the form of short passwords, predictable words, user’s name that can be easily gotten through social engineering, words or names with obvious symbols representing vowels, etc.

Exploitation:

The first thing hackers do is to attempt logging into the web application and taking note of the rules specified by the software in filling password boxes.

2. Password Change Functionality

Web developers often fail to provide password change Functionality in their apps. This feature is very important in web apps, though, for two especial reasons:

For the user to quickly change their password when they detect malicious activity
For periodic testing, and validation of a password change session

The flaws in web apps that don't use a Password Change Functionality include:

Verbose error messages
Allowing unrestricted guessing in the existing password field
Matching “new password” and “confirm new password” fields only after validating the existing password

Other design flaws in authentication sessions are present in the Forgotten Password Functionality, Remember Me Functionality, and Invalid Credentials Functionality
Let's learn how to build authentication sessions in Go.

Basic HTTP Authentication in Golang

As explained earlier, the basic HTTP authentication method is not the safest. However, it can be implemented with hashing in the following way:

func basicAuth(next http.HandlerFunc) http.HandlerFunc {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    username, password, ok := r.BasicAuth()
        if ok {
        usernameHash := sha256.Sum256([]byte(username))
            passwordHash := sha256.Sum256([]byte(password))
              expectedUsernameHash := sha256.Sum256([]byte("username"))
              expectedPasswordHash := sha256.Sum256([]byte("password"))
        usernameMatch := (subtle.ConstantTimeCompare(usernameHash[:], expectedUsernameHash[:]) == 1)
              passwordMatch := (subtle.ConstantTimeCompare(passwordHash[:], expectedPasswordHash[:]) == 1)
        if usernameMatch && passwordMatch {
                next.ServeHTTP(w, r)
                return
            }
        }
    w.Header().Set("WWW-Authenticate", `Basic realm="restricted", charset="UTF-8"`)
        http.Error(w, "Unauthorized", http.StatusUnauthorized)
    })
}

It is important to emphasize that the username and password are not being hashed for the purpose of storage. They are hashed to get two equal-length byte slices that can be compared in constant-time.
In using this method of HTTP Basic Authentication, the imported packages include:

import (
    "crypto/sha256"
    "crypto/subtle"
    "fmt"
    "log"
    "net/http"
    "os"
    "time"
)

An application instance of struct type should be created to contain the username and password:

type application struct {
    username string
    password string
}

The main function will contain the entire operations and the server instance:

func main() {
    webapp := new(application)

    webapp.auth.username = os.Getenv("AUTH_USERNAME")
    webapp.auth.password = os.Getenv("AUTH_PASSWORD")

    if webapp.auth.username == "" {
        log.Fatal("Illegal username provided")
    }

    if webapp.auth.password == "" {
        log.Fatal("Illegal password provided")
    }

    mux := http.NewServeMux()
    mux.HandleFunc("/unprotected", webapp.unprotectedHandler)
    mux.HandleFunc("/protected", webapp.basicAuth(app.protectedHandler))

    srv := &http.Server{
        Addr:         ":8080",
        Handler:      mux,
        IdleTimeout:  time.Minute,
        ReadTimeout:  10 * time.Second,
        WriteTimeout: 30 * time.Second,
    }

    log.Printf("starting server on %s", srv.Addr)
    err := srv.ListenAndServeTLS("./localhost.pem", "./localhost-key.pem")
    log.Fatal(err)
}

Session-Based Authentication Session in Golang

Session-Based authentication systems are often used in web apps that implement server side templating. OAuth and OpenID could be added to further secure the application.
In Golang, the popular

Gorilla Mux

package has a


 package that can be used to create authentication sessions.
Hence, the first step in creating an authentication session is to install the

 ```gorilla/mux```

 and

 ```gorilla/sessions```

 packages.



```Shell
go get github.com/gorilla/mux
go get github.com/gorilla/sessions

After this, create a local directory for the project.
Next, import the


 package as well as other important packages.



```Go
package main
import (
    "log"
    "net/http"
    "os"
    "time"
    "github.com/gorilla/mux"
    "github.com/gorilla/sessions"
)

Seeing that we are creating session-based authentication for API endpoints, we will create a cookie store using the


 method in the sessions package we imported.



```Go
var store =sessions.NewCookieStore([]byte(os.Getenv("SESSION_SECRET")))

Assuming we are logging into a dashboard, then the necessary API endpoints are:



-

 ```/dashboard```


-

 ```/logout```



There will be a list of users having their own dashboards, so the server must have a map it can search for yours in. Initializing an example user credentials:



```Go
var users = map[string]string{
    "Mac":   "username",
    "admin": "password"
}

A login handler function would be responsible for the client's request, credential matching, and return of the /dashboard endpoint.
The function will initially parse the POST form. Then, it will retrieve the client's credentials.

func LoginHandler(w http.ResponseWriter, r *http.Request) {
   err := r.ParseForm()
   if err != nil {
      http.Error(w, "Please pass the data as URL form encoded",
 http.StatusBadRequest)
     return
   }
   username := r.PostForm.Get("username")
   password := r.PostForm.Get("password")

}

The function is also going to match the collected data with the ones stored in the server. The function will authenticate an existing match, and return error when there's no match.

//continued in the LoginHandler function
if originalPassword, ok := users[username]; ok {
    session, _ := store.Get(r, "session.id")
    if password == originalPassword {
        session.Values["authenticated"] = true
        session.Save(r, w)
    } else {
        http.Error(w, "Invalid Credentials",
http.StatusUnauthorized)
        return
    }
} else {
    http.Error(w, "User is not found", http.StatusNotFound)
    return
}
w.Write([]byte("Logged In successfully"))

The login either succeeds or not, depending on the availability of the client on the server’s credential store.
The log out session, on the other hand, receives a GET request and turns the


 method to false.



```Go
func LogoutHandler(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "session.id")
    session.Values["authenticated"] = false
    session.Save(r, w)
    w.Write([]byte(""))
}

The


 method saves the cookie state after modification. 
Next, it is important to create the

 ```/dashboard```

 API endpoint. The

 ```/dashboard```

 function would return the time of login:



```Go
func DashboardHandler(w http.ResponseWriter, r *http.Request) {
    session, _ := store.Get(r, "session.id")
    if (session.Values["authenticated"] != nil) && session.Values
    ["authenticated"] != false {
        w.Write([]byte(time.Now().String()))
    } else {
        http.Error(w, "Forbidden", http.StatusForbidden)
    }
}

After we finished writing the endpoints, the next step is to write the


 function. This function will connect and start up all endpoints, and the server at an open port:



```Go
main() {
    server := mux.NewRouter().StrictSlash(True)
    server.HandleFunc("/login", LoginHandler)
    server.HandleFunc("/dashboard", DashboardHandler)
    server.HandleFunc("/logout", LogoutHandler)
    http.Handle("/", server)
    srv := &http.Server{
        Handler: server,
        Addr:    "127.0.0.1:8080",
        // Good practice: enforce timeouts for servers you create!
        WriteTimeout: 15 * time.Second,
        ReadTimeout:  15 * time.Second,
    }
    log.Fatal(srv.ListenAndServe())
}

This completes the secure authentication session. Running the command

go run main.go

starts the server at localhost:8080.

Token-Based Authentication Session in Golang

One of the downsides of this token- or session-based authentication system is that it stores credentials to the program memory or on a special server software like Redis.
However, JWT poses a solution to this. What JWT does is to resend the login credentials to the client to store in a database. The entire procedure is explained below:

The client sends login credentials as a POST request to the login API endpoint
The server authenticates the details and, if successful, it generates a JWT
The server returns this to instead of creating a cookie. It becomes the client's responsibility to store this token
Since the client is in charge of the token, it needs to add this in the headers section to make subsequent REST API calls
The server checks the JWT from the header and if it is successfully decoded, the server authenticates the client For RESTful APIs, token-based authentication is the best and recommended approach given that it is stateless. In creating a JWT Token-Based session with go, the jwt-go package will be imported. It has a NewWithClaims method that accepts a signing method and a claims map. A great guide on implementing JWT with Go is available on Auth0 blog.

Conclusion

At this point, the reader should be aware of what authentication sessions are under the covers, the kind of vulnerabilities possible in authentications, popular options in authenticating web apps, and the difference and ways to write session- and token-based authentication sessions.

A walk around the block: Blockchain and Web3.0

MacBobby Chibuzor — Sat, 05 Feb 2022 21:42:33 +0000

introduction

In the tech space, new technologies buzz now and then. Given the nature of developers, learning about these new trends is essential, mainly if you belong to a network of developer friends or are looking to transition into something new and more challenging.

The rave of the moment is Web3 and Blockchain, and this article will put you in the know about these things. This writeup offers you a walk around the block, literally taking you from the meaning of important terms, through facts about Web3, to ways in which you can transition from wherever you are to Blockchain development.

At the end of this article, you will know every neighborhood in and around the block - literally. You'll know enough to decide whether to get into blockchain development or not, whether you should adopt blockchain in your next project or not, and how to become a blockchain developer should you choose to enter the space.

blockchain, smart contracts, and the web3 - who are these guys?

Web3.0

Web 3.0 is the third generation of the internet featuring web apps that are able to process information in a smart human-like way through technologies like machine learning (ML), Big Data, decentralized ledger technology (DLT), etc. Web 3.0 was originally termed the Semantic Web by Tim Berners-Lee, and was portrayed to be an autonomous, intelligent, and open internet.

Blockchain

A ledger is essentially a list of transactions. You could think of it as a database, but a database is different from a ledger. In a ledger, we can only append new transactions, whereas, in a database, we have the ability to append, modify, and delete transactions. A database can be used to implement a ledger, but it doesn't work the other way round.
A blockchain is a data structure used to create a decentralized ledger. A blockchain consists of blocks that are chained in a serial manner. A block contains:

a set of transactions
a hash of the previous block
timestamp indicating when the block was created
block reward
block number, and so on. Every block contains a hash of the previous block, thus making a chain of blocks linked with each other. Every node in the network holds a copy of the blockchain.

Smart Contracts

Now, smart contracts aren't smart, no. And they aren't legal contracts either. Think of them as the Web3 version of your business logic or controller in Web2. Smart contracts are pieces of code that execute based on external input. They validate the input and run the business logic they were built for.

The advantages of smart contracts over normal controllers is this: a smart contract runs exactly as programmed without any possibility of downtime, censorship, fraud, and third-party interference.

are they the rich kids?

If, by rich kids, you mean whether blockchain development is lucrative, then yes, it is! On CNBC for example, Blockchain developers were estimated to have salaries between $150 000 - $175 000.
A senior blockchain developer could make as much as $1 000 000 per year, as was proposed in a viral LinkedIn job post.

In as much as money is a big factor in motivating virtually all developers to get into new niches, consideration for usefulness and passion for work must be reflected on.

wow, I want to be friends! how can I?

Do you mean whether you too can become a blockchain developer? Sure, why not?! You need only to learn the tools and concepts, and you'll be fine. If you are curious whether it is worth venturing into Web3, you might want to consider these facts:
The Internet is evolving, just like every other technology. From Web1.0, we saw the power and usefulness of Web2.0. The truth is Web2 will not always be the only way to build web applications. This is very much true for FinTechs.
The whole Web3 space is buzzing at the time of this writing; if you are in any tech community, chances are you have come across the term or a developer in it.
Blockchain has promising potential to be the future of the web. Well, why not? It has seen wild adoption in both new and old FinTechs companies alike and even tech giants like Google and Facebook are pioneers.
Pro tip: Since blockchain is still in its early stages and not older than ten years, give or take, you can pick up Web3 skills even faster than Web2 skills if you're just starting out.

where are the parks and malls?

Well, in this block, the parks are fun/practical focused websites, and the malls are EdTech companies that offer free or paid tutorials and trainings on Web3 related technologies. Excellent points of call for upskilling include:

It doesn't matter which one you pick, just pick one and start learning. You most likely will end up Googling for more videos, books, tutorials, etc., depending on your best learning methods.

where's the bank at?

Concerning where you can cash out on your blockvhsin skills, many companies are sourcing for blockchain talents - even Google recently moved into the neighborhood. In this block you can make money from either of the following:

Hackathons
Contract projects
Full time roles You can find cryptocurrency jobs here, on Consensys, on angelList, or on Uniswap.

how do I keep up with the joneses?

There are a rife of technologies and concepts to learn, but this shouldn't warrant worries in your mind. There are fantastic resources - both free and paid - that will get you up to speed in these technologies, leaving your self-discipline as the only unreliable factor in this block.
The learning path and developmental process for web3 is different from the traditional web2

In web2, an action in the form of HTTP requests is sent to a web server, but in web3, users send transactions to a blockchain.
In web2, data is queried from a centralized data store, but in web3, the data store is a decentralized ledger called the blockchain.

Exemplary differences are not limited to these alone, but they should paint a clearcut picture in your mind.
Technologies and neighborhood slangs you need to know about to get into blockchain development include:

Blockchain Basics

Blockchain and types
Consensus Mechanisms and types
Smart Contracts and examples
Gas and Transactions ### Cryptography
Encryption and Decryption
Public and Private Key Encryption
Hash functions
Digital Signatures

Programming Languages
Solidity: Solidity was modeled after JavaScript to promote ease of transition for JS developers. Solidity is used for Ethereum client dApps and smart contracts, and is the most in-demand skill in the Web3 space.
Rust: Rust is a C/C++-inspired language used for Solana client dApps and smart contracts. The Parity client was written in Rust.
JavaScript: As the popular language of the web, JavaScript has libraries that are particularly tailored for Web3. Examples include Etheruem.js, Three.js, Ethers.js, Web3.js, etc.
Golang: The powerful Go language has shown dexterity in the web3 niche also. For example, the Geth client was written in Go.
.NET: The .NET framework is not left out. You can easily integrate Ethereum blockchain into your .NET applications using Nethereum.
C++: C++ mainly qualifies for protocol development - you can never go wrong with the language.
Python: Given its popularity and ease of use, Python has also seen adoption in Web3. The pyethereum project is an example, as well as the web3.py project.

conclusion - counting the costs

At this point, you've seen and understood everything that's worth seeing and knowing to get started in Blockchain. Is it worth getting into this block? That's for you to decide.
If you were in the FinTech space, you may find it somewhat enticing to settle down here. If you have the time and effort to learn a new set of tools and technologies that will prolly build the future of the internet, then, why not?
As more companies declare their emergence into Web3, even more, will enter as a means of survival. What that means for developers is more money and opportunities in the space.

Do you like this article?

Consider following me here and on Twitter

Get Better At Technical Writing 3: Documentation as a Service

MacBobby Chibuzor — Sat, 22 Jan 2022 18:09:39 +0000

Introduction

Open Source contributions are not restricted to just code, as is believed by most developers. Documentation is a recognized and valid means of contributing to open source projects. In this article, documentation is treated as a service (DaaS), similar to Infrastructure (IaaS), Platforms (PaaS), etc.

Technical writing is an important part of software development because it serves as a bridge between the developers and the users. The ability to write good documentations is a must-have skill for every engineer and researcher; you should probably take a course on it if you often find yourself doing stuff other people need to know about.

Writing documentation for a software is not just something you do to fulfil all righteousness. As stated in a previous issue in this series, it can be the defining difference between useful and useless software. Best case scenario of a poorly documented software: hundreds of emails get shipped to support team. Worst case: it doesn't get used.

Let's look at possible ways you can write or improve DaaS.

DaaS in Your Learning Journey

In the tech ecosystem, everyone is plunged into an infinite loop of learning. Over the years, cognitive psychologists have proven to us that an effective technique to solidify knowledge of something learnt is to teach it. You can teach your pet, yes, but nothing stops you from teaching people who would find it useful.

Looking for topics to write about while building your tech career? Write about your learning journey.

It could be in the form of daily or weekly entries for a personal learning challenge, or creation of content based on what you've learnt and sharing with people. It can also be writing end of year reviews and new year resolutions, as is common in the Nigerian Tech community.

Chances are that you personally will sometimes have to refer to your own articles later in the future — a very common thing to me and some of my friends.

Furthermore, some recruiters would love to see these blog posts to confirm how long you have learnt a language or if you learnt it thoroughly. In these cases, some bootcamps like HNG Internship program has made it compulsory for enthusiasts to blog about their learning experience.

It can also be service to yourself in the form of a self-accountability system to continue learning. A simple example is having to tweet everyday about your #100DaysofCode challenge.
Experience gained through this means can help you land a passive income stream as a contract Technical Writer.

DaaS in Open Source Contributions

Technical writing is an open source experience in a sense. Providing documentation for software is a fine way to contribute to open source.
For example, during Hacktoberfest, you can contribute to documentation in the following ways:

Review and updating existing documentation
Test company official SDK in some use-cases and add them to examples.md file in the repository (code required)
Write documentation and provide examples for software built by coders during open source contributions.

DaaS in Product/Software Support

Writing example use-cases for a software — as mentioned earlier — is one means of providing support to potential users of that software.

DaaS in an Agile Team

Working in a company as a technical writer, you will have to work hand in hand with the software team. In that case, your team may follow the Agile methodology, making use of a standard project tracking system like Jira.

In this situation, you should make use of such project management software to keep track of your tasks, review your documentation, raise issues to developers and staff, assign tasks when possible, etc.

If the dev team makes use of X, look for a way to make use of X also. In a future issue, I will expound on how to do this.
Asides working in sync with the dev team, you also have side jobs like:

Reviewing published contents, updating and republishing them
Discussing with the team and staff where needed
Studying the software you're documenting through and through
Checking customer support for complaints that your writing can fix
Others

DaaS Tools

In documenting, several tools are available to make the job easy for you. They are helpful for specific functions, like API documentation or Markdown writing. Some of these include:

Postman
Swagger UI
Apiary
Readme.io
Docusaurus
Gitbook
Read the Docs

To better improve your writing, you may use softwares like Grammarly keyboard, a Thesaurus app, Notion etc.

Conclusion

In this article, you learnt about different means you can write DaaS.
When next you start writing, put in mind that you're writing for your future self, for others to learn that skill thoroughly, for recruiters to know you're adept in that technology, for users to enjoy the product, and for your importance to be acknowledged in the team.

Disclaimer!
A couple people reached out to me asking me to collaborate with them and make these write-ups a paid service. I'm open to collaboration or anything, but just not for this.

Get Better At Technical Writing 2: Don't Start With Writing

MacBobby Chibuzor — Thu, 13 Jan 2022 12:46:39 +0000

Introduction

Technical Writing is not just about writing. There are a whole lot to consider and do before writing even the first draft.

A technical writer is, first of all, a researcher and tester. A huge amount of the writing process should involve research/learning, testing the product or a language's use case, before any writing should be done.

A famous scientist once said, "If I have 1 hour to cut down a tree, I will spend the first 55 minutes sharpening my axe." Accordingly, it is healthy to say that 80% of the writing process should be spent not writing, but researching and testing.

Typical Writing Processes

If you work with a team of developers, your job may be limited to creating manuals or tutorials on softwares they developed, writing documentation of APIs or services they built, etc. In your case, a typical writing process may involve:

Installing the software and it's dependencies on a platform. You may have to write step-by-step installation and setup guide as you do this. You may also have to test this guide on another platform, while writing the procedures. Not all your readers will be using Windows, or AWS, etc. The rule of thumb here is to carry out tests on as much widely used alternative as your product or company allows.
Testing the software as much as possible, trying to understand how it works in every aspect. This is to reduce the amount of complaints that go to customer support, either by explaining obscure concepts in the official manual, or writing more FAQ articles.
Reporting bugs you found while testing. You don't have to solve them yourself, no. You're not a bug hunter.
Writing the content completely, then redrafting if need be. Check for grammar errors, punctuations misuses, and consistency.

Read Now: Get Better At Technical Writing: The Beauty of Consistency.

Updating your write-ups as time goes on and technologies advance. In a future article, I will explain how to automate this process.

If you do not work with a team, you are most likely a developer/engineer who found the beauty of Community as a Service (CaaS). You learn something new and want to teach it to the community through writing. If this screams you, then your writing process involves most of these steps, but a lot more coding.

The following tips will explain how to improve your pre-writing phase.

Define Your Audience:

This is an important first step in pushing out a content. Who are you writing for? What is the bare minimum knowledge they need to have to completely understand your write-up?

The foremost duty every technical writer has is to create content that their intended audiences will read and find useful. Any other duty is inferior to this.

If your audience are experts, you have to tailor your write-up to suit experts, not beginners. This means you don't have to explain what every term mean, or put the reader through the process of installation and setup of a software.

Do Your Own Research

A common thing I noticed among the expert technical writers I know is that they create honest work. Producing unique, honest, and unplagiarized content means you know enough to write in your own words. You know enough to create your own use case.

From experience, some companies would expect you to create and promote contents around their products, as a means of influencing their sales of those products. More often than not, you would have to learn how a particular product works, and technologies you would need to interact with the product to create your own use case.

Research sparks up more curiosity in the technical writer. Some newbies in technical writing often ask questions like: how to find new topics to write about, how to write unique content for a topic already written on before. A great way to do either of these is to embrace research.

Staying updated or learning new things about a tool or technology would definitely leave you asking, "What if I could use this tool to do X?" at some point.

Test Before Publishing

Writing an article or manual for a product, a software, or a programming language means you are familiar with it through and through. You know your way around it enough to teach someone else how to use it. In this sense, testing does not mean improving performance, but increasing personal knowledge.

This is mostly the case for writers who work in teams. If this is you, then you have the option of informing developers about the bugs and issues you find while testing.
In another sense, testing means making sure your content is unfalsifiable. Put testing at the back of your mind and you're sure to produce great content that your readers can find useful.

This is the case for CaaS writers. Before clicking the Publish button, make sure you have tested every piece of code you included in your write-up, in as much widely used platforms as possible for you.

In software development, there is the concept of test-driven development (TDD). TDD entails not taking a software into production stage until it is thoroughly tested.
For you, the technical writer, your software are docs and articles, and you have to test thoroughly before taking them to production.

Finalize your writing process by testing everything you have written.

Benefits of Researching and Testing

You push out content that is absolutely useful to your reader - your ultimate goal for writing in the first place.
It is not just useful, it is also easy to implement/reproduce by your readers. In other words, it works on other people's machine too.

It prevents hundreds of complaints/enquiry emails to customer support. Pro tip: if you work with a team as a technical writer, find out what customers are saying about the software. Ask yourself if there's a way to better the situation by writing more.This might lead to an increase in your paycheck.
Drawing appreciation from readers, it inspires love for the software or language. For example, when generics came to Golang in November 2021, it didn't take long before a developer wrote an article on using generics in a Golang project. That discovery made me love the Golang Community, and developers' energy even more.
During research, you will find potential topics to write next about, especially if your research entails learning new concepts or technologies.

I hope you refer to these tips before you start writing your next awesome article! Also, check in next Thursday for another article in the series.

Using The FizzBuzz Problem to Explain the Goals of Algorithms

MacBobby Chibuzor — Mon, 10 Jan 2022 20:50:36 +0000

In this article, you will gain some insights required to write algorithms that ace job interviews.

The major aim of the article is to explain the five common goals of an algorithm.
In the course of the article, I will explain the simple FizzBuzz algorithm, and implement it in Golang. Additionally, I use two methods to explain the importance of writing clean, readable code.

Introduction

Algorithms are mathematical and computational procedures in solving problems.
Problems are binary relations of inputs and outputs. In a typical coding challenge or job interview, you have a set of input, and are looking to produce a set of possible output.

An algorithmic or computational problem is specified by describing the complete set of instances it must work on and of its output after running on one of these instances.
The first goal, therefore, of an algorithm is to Solve Problems.

Solving Fizz and Buzz with a Simple Sorting Algorithm

You must have heard of the FizzBuzz algorithm before, especially if you have an experience in data structures and algorithms. It can be spelt as Fizz Buzz, FizzBuzz, or Fizz-Buzz. Whichever one you prefer, it remains a common question in technical job interviews.

Imagine a set of numbers from 1 to 10.

x = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}

Fizz and Buzz refer to all number that's a multiple of 3 and 5 respectively. In other words, if a number is divisible by 3, it is categorized as fizz; if a number is divisible by 5, it is categorized as buzz.

fizz(x) = {3, 6, 9}
buzz(x) = {5, 10}

If a number is simultaneously a multiple of 3 AND 5, the number is replaced with "fizz buzz." In essence, it emulates the famous children game "fizz buzz."

In writing the algorithm for solving this computational problem, iterate through the array and check which numbers are fizz and which are buzz. To do this, create a for loop to iterate through the set of numbers from 1-10:

for x := 1; x <=10; x++ {
   if x % 3 ==  0 {
          fmt.Println("Fizz", x)
   } else if x % 5 == 0 {
          fmt.Println("Buzz", x)
   }
   fmt.Println(x)
}

You can run this code in the Go Playground.

You see the output as exactly the fizz(x) and buzz(x) values.

It is not enough. FizzBuzz refer to cases where elements of the set are both divisors of fizz and buzz i.e., 3 and 5.
What makes a computational solution an algorithm is if it can perform efficiently for both large and small area of data. Expert algorists will argue that an algorithm should perform better with larger data sets than smaller.
The second goal of an algorithm is to Argue Efficiency.

The FizzBuzz (in Confusing Code)

The FizzBuzz Algorithm can be improved to a series of if else statements: popular for sorting algorithms. This, however, requires a larger dataset.

func main() {
    for i := 1; i <= 100; i++ {
        if i%3 == 0 {
            if i%5 == 0 {
                fmt.Println("FizzBuzz at", i)
            } else {
                fmt.Println("Fizz")
            }
            if i%5 == 0 {
                fmt.Println("Buzz")
            } else {
                fmt.Println(i)
            }

        }
    }
}

You can run this code in the Go Playground.

You see the expected output, but there's a trade-off here:

Go’s motto is in favor of clean, readable code. Hence, avoid writing nested code of if, else if and else statements.
The third goal of an algorithm is to Communicate Ideas. I know an algorist who got his offer with only pseudocodes. If you ever get stuck in writing an algorithm, switch to pseudocode or draw a flowchart.

The FizzBuzz (in Clean Code)

Instead of writing nested code that might confuse your interviewer, you can use if and continue to make code cleaner.

func main() {
    for i := 1; i <= 100; i++ {
        if i%3 == 0 && i%5 == 0 {
            fmt.Println("FizzBuzz at", i)
            continue
        }
        if i%3 == 0 {
            fmt.Println("Fizz")
            continue
        }
        if i%5 == 0 {
            fmt.Println("Buzz")
            continue
        }
        fmt.Println(i)
    }
}

You can run this code in the Go Playground.

The continue keyword skips an iteration and moves to the next.
The output confirms the fourth goal of an algorithm: to Prove Correctness.

Algorithmic Thinking

The fifth and grandest goal of an algorithm is to correctly Optimize Runtime.
As the range of the dataset increases to 1-100, you have to think carefully for ways to reduce the runtime.

Given, the compiler will check each number to determine whether it is divisible by 3 or 5. It will then run through the numbers again to check if the numbers are divisible by 3 and 5. The code would essentially have to run through each number in the array twice — it would have to runs the numbers by 3 first and then run it by 5. This reduces the speed or time complexity of the algorithm in a sense.

To speed up the process, you can simply divide the numbers by 15 directly, since the smallest FizzBuzz is the product of fizz and buzz i.e. 3 x 5 = 15.

func main() {
    for i := 1; i <= 100; i++ {
        if i%15 == 0 {
            fmt.Println("FizzBuzz at ", i)
        } else if i%3 == 0 {
            fmt.Println("Fizz")
        } else if i%5 == 0 {
            fmt.Println("Buzz")
        } else {
            fmt.Println(i)
        }
    }
}

You can run this code in the Go Playground.

Conclusion

In this article, you learned the definition of several concepts. Moreover, you saw use cases of control structures in Go. You also learned how nested loops make code confusing, and a good way to solve this.
More importantly, you learnt about the five common goals of an algorithm and what they mean. You also leart how to use a simple sorting algorithm to solve the FizzBuzz problem.
Finally, you learnt the need and benefits of thinking algorithmically i.e. of how to optimize the runtime of your algorithm. In a competitive setting, this gives you an edge.

Get Better At Technical Writing: The Beauty of Consistency

MacBobby Chibuzor — Thu, 06 Jan 2022 16:37:37 +0000

Disclaimer

This is not a technical article, but a test article. If it proves helpful to you and you wish to see more like it, please drop a like and comment. I might be motivated to start a weekly newsletter on Getting Better At Technical Writing, or something similar.

Introduction

Consistency is the absence of contradiction. Whenever you conclude a write-up, it is imperative to go proofread it while checking for inconsistencies. In this article, I will give you tips on how to do this, based on the experience I've gained over years of commercial writing.

In the next section, I take you through Grammar Consistency.

Grammar Consistency

Before starting a write-up, you should have in mind who your audiences are or what type of English you wish to express in.
If you're writing for an English audience, you should use “recognise” and not “recognize.” Also, make sure to not mix British and American English in your write-up. Using “recognize” in Section 1 and “itemise” in Section 2 is an example.

If you write with an MS Office product or a mobile phone with auto-prediction switched on, you should be extra careful with this mistake. Some softwares use your location - or theirs - to predict spellings.

Sticking to a particular tone throughout your write-up is also important. When writing about personal experiences or opinionated contents, use “I.” When writing tutorial guides, use “You,” or “We” if you want the reader to feel held and guided. Technical documentations, manuals and some technical articles must be written without these pronouns.

In the next section, I take you through Paragraph Consistency.

Paragraph Consistency

It is no new information that each paragraph in your write-up must have one tone. Its unprofessional to raise two points in one paragraph and another point in a third paragraph.

A proper way I recently learnt to structure paragraphs is provided below:

Start with a sentence that introduces everything your paragraph is going to say.
Keep sentences short, and free of unnecessary contents.
Having 2 - 3 sentences or paragraph is great, although some paragraphs might be occasionally longer.

For example:
A serious Frontend developer must have ReactJS in their repertoire. Knowing HTML5, CSS3, and JavaScript is not enough to land a job as a Frontend developer. This is because virtually all talent recruiters are searching for developers who know and use the ReactJS framework.

Style Consistency

I ended every section of this article with an introduction to the next section, except for the previous one. This is purposely to explain style inconsistency to you. Another inconsistency is not using Consistency as the prefix in a consecutively related section, like I did in the next section.

Whichever writing style you adopt, make sure to stick to it.

If you connect words with an hyphen instead of indentation, stock to it. Don't say “hard-earned” in Section 1 and “easy going” in Section 3.

If you bolden user interface elements (e.g. Click Save, then Exit), stick to it throughout.

If you capitalise all the words in a heading, you should repeat that for every other heading, especially if they are related. That said, you obviously know very short words are not capitalized.

If you use a comma, a period, or nothing at all at the end of an itemization, stick to this pattern throughout your write-up. For example, it's inconsistent having these two formats in one article:

In the next section, I take you through Format Consistency.

Consistency in Formatting

You must have observed that the heading above is a bit bigger than the others. This is purposely to explain to you that Markdown inconsistency is ugly. If you're familiar with Markdown - of course, every technical writer knows Markdown like the back of their hands - then you'd know I used an H1 tag here, and an H2 tag in the others.

Preserve whichever formatting pattern you adopt throughout your write-up.
If you use numbers for itemizing, don't switch to bullet points.

Conclusion

These are not everything you must know about Consistency in writing, but I am pretty sure you will be able to detect inconsistency in any write-up. These aren't rules, also, but best practices; we are all striving to get better.

You're getting better when your article ships on the first drafting, without any edits. Don't flatter yourself, this is subjective. If your message is technically perfect, it is sometimes a fair trade off for grammar and structure.

“Is it too much to ask for both?” - Tony Stark

Forem: MacBobby Chibuzor

Using AWS Blockchain Templates for Hyperledger Fabric Development in Go (2)

Components and Frameworks

Docker Containers

Network Architecture on Hyperledger Fabric

Creating a VPC

Create a VPC with a public subnet

Setting up key pair and Configuring Security Groups

Creating Policies and Roles

Creating the Hyperledger Fabric Network with AWS CloudFormation Stack

Conclusion

Blockchain DevOps on AWS with The Hyperledger Fabric Model and Golang (1)

The Blockchain

The Hyperledger Project

Deep Dive in Comparison

Hyperledger Fabric

Advantages of Hyperledger Fabric

A Transaction’s Lifecycle on the Hyperledger Fabric

Hyperledger Fabric vs Ethereum

AWS Blockchain Templates

Conclusion

Data Structures and Algorithms with Go (2): Growing Your Go Skills with Trees

Trees

Must-knows about trees

Binary search tree

Binary tree operations

Applications of binary trees

Implementing binary trees in Go

Conclusion

Get Started with ROS for Embedded Robotics

Introduction

On Robotics

What are Robots?

Anatomy of a Robot

Sensors

Actuators

Mobility

Communication

The ROS Framework

ROS Tools and Syntax

Getting Started with ROS

Navigation Stack in ROS

Who uses ROS and why?

Where to learn about ROS and Robotics

Conclusion

Creating Virtual Machines and NGINX Servers on Google Cloud Platform for Go Web Apps

Introduction

Prerequisites for this course

Virtual Machines

Go

Starting the Cloud Shell

What You Can Do On The Google Cloud Shell

Basic Commands

Starting a new project on Google Cloud Platform with the gcloud CLI

On Machine Types

Installing an NGINX web server on Google Cloud Platform

Installing an NGINX webserver

Creating a Basic Web App with Go on a Virtual Machine

Conclusion

Get Smarter About Smart Contracts

Introduction

Smart Contracts - What's Smart About Them?

On Choosing a Language to Author a Smart Contract

Tools for Authoring Smart Contracts

1. Remix IDE

2. Truffle Framework

3. Embark Framework

Greeting the Blockchain in .sol

Dissecting Solidity Code with Solidness

1.

3.

Dissecting Vyper Code without a Bite

1.

Understanding and Building Authentication Sessions in Golang

Introduction

Authentication Sessions

Using HTML Forms

Using Multifactor Mechanisms

Client SSL-Certificates

HTTP Authentication

Starting a new project on Google Cloud Platform with the `gcloud CLI`