CodeIsGo.com

Libra is not designed to minimize the number of trusted parties in an economic transaction. Libra is designed to maintain a stable value and users trust the Libra Association’s management of a reserve fund to achieve that goal. Users also rely on the permissioned validators to add transactions to the ledger, and but for their participation a transaction would not go through.

Peter van Valkenburgh article about differences between Bitcoin and Facebook’s Libra. The two have different design goals, work in different ways, and raise different regulatory questions.

Author’s answer is that Bitcoin and Libra are very different projects that use very different technologies and, as a consequence, each project faces different regulatory and legal challenges.

The article then look sat the design goals of each project, the technologies they use, and conclude with a high-level comparison of the relevant laws and regulations:

• Different design goals and priorities
• Different technologies employed
• Different regulatory consequences

For a deeper dive on the concepts of permissionless vs permissioned blockchains, the technical details involved in their development, and their legal implications, check out the Coin Center report: Open Matters: Why Permissionless Blockchains are Essential to the Future of the Internet. Nice one!

Matt Wade authored this beginner guide to QnA Maker multi-trun conversations. In the past there was a glaring difference between a QnA Maker knowledge base (KB) and a real human: the ability to clarify, ask for more information or do anything more than a one-off question-response type of conversation. With multi-turn, the experience with your QnA KB is much more fluid and significantly more natural.

Multi-turn relies on follow-up prompts that are sent with an A (answer) when asked a Q (question). These prompts aren’t just helpful; they can pull the user along a set path of your design. That path can be whatever you think is logical or it can go in a direction that, over time, most users have shown to go.

The article is divided into these sections:

• Prompt me (follow-up prompts sent with answer when asked question)
• Example Contoso Restaurant Bot
• A web of knowledge
• The build-out process
• Connecting your KB to your bot
• Wrap up

To help you visualize multi-turn conversations, there is an example chatbot meant to be used on a restaurant’s website. Also, if you haven’t already checked it out, you want to learn all the new things that come with QnA Maker’s active learning. Good read!

An artcile by James Sinclair about reduce in JavaScript. Reduce is the Swiss-army knife of array iterator. It’s really powerful. So powerful, you can build most of the other array iterator methods with it, like .map(), .filter() and .flatMap().

Reduce is one of the most versatile functions that was ever discovered.

Why does reduce() cause people so much trouble?

Getting used to the idea of an initial value is a non-trivial step. And then the reducer function also has a different signature. It takes an accumulator value as well as the current array element. So learning .reduce() can be tricky because it’s so different from .map() and .filter().

Some interesting things we can do with reduce So, what interesting things can we do then?:

• Convert an array to an object
• Unfold to a larger array
• Make two calculations in one traversal
• Combine mapping and filtering into one pass
• Run asynchronous functions in sequence

Plenty of code examples in this excellent resource which will teach you more advanced uses of reduce(). Nice one!

Sara Kassabian and Brad Downey wrote this piece for GitLab.com exploring GitLab CI and how this powerful tool can be used for a number of things, including infrastructure as code. GitLab is tool agnostic, but they use Ansible in this demonstration because it’s a language commonly used by developers for infrastructure as code.

What’s particularly cool about GitLab CI is that the code from the Ansible playbook can be edited and shipped without ever having to install any dependencies locally. The demo project, which calls for an update to the SNMP strings on all devices monthly per GitLab security policy, can be done entirely on GitLab.com.

The article then guides through the Ansible playbook, including:

• Gather router facts
• Display version
• Display serial number
• Configure SNMP

Committing the changes will automatically kick off a GitLab CI pipeline. GitLab CI pipelines are a string of sequential tasks that execute everything you need to test and implement your Ansible code. GitLab CI is configured with a single simple YAML file that lives in the repository, named .gitlab-ci.yml. The tutorial video and repository with the code provided. Great!

Short article from interviewcake.com explaining Big O. Big O notation is the language we use for talking about how long an algorithm takes to run. It’s how we compare the efficiency of different approaches to a problem.

You should make a habit of thinking about the time and space complexity of algorithms as you design them. Before long this’ll become second nature, allowing you to see optimizations and potential performance issues right away.

It’s like math except it’s an awesome, not-boring kind of math where you get to wave your hands through the details and just focus on what’s basically happening.

With big O notation we express the runtime in terms of — brace yourself — how quickly it grows relative to the input, as the input gets arbitrarily large.

• How quickly the runtime grows
• Relative to the input
• As the input gets arbitrarily large

Some code examples helping with explanation. Short but sweet.

Tutorial by Thomas d’Otreppe about installing custom image of Kali Linux on DigitalOcean. DigitalOcean is a cloud provider similar to AWS, Microsoft Azure, Google Cloud Platform, and many others. They offer instances, called “droplets”, with different Linux distributions such as Debian, Ubuntu, FreeBSD, etc. Similar to AWS, DigitalOcean has datacenters around the world and sometimes multiple datacenters in each country.

However, one feature in particular sets DigitalOcean apart them from their competitors. A little while ago, they added support for custom images, which allows users to import virtual machine disks and use them as droplets. This is perfect for us as we can use our own version of Kali Linux in their cloud.

Author will guide you through the build of a lightweight Kali installation with the bare minimum to get it working. You will get detailed instructions on:

• How to generate an ISO
• How to create the Virtual Machine
• Update the System
• Uploading of custom image
• Starting a Droplet

Straight to the point no fuss tutorial. Building the ISO will require around 5 GB of hard drive space so make sure you have enough. Good read!

This document helps you plan, design, and implement the process of migrating your workloads to Google Cloud Platform (GCP). Official Google guide published on their cloud solutions blog.

This document is useful if you’re planning a migration from an on-premises environment, from a private-hosting environment, from another cloud provider to GCP, or if you’re evaluating the opportunity to migrate and want to explore what it might look like.

The content is split into sections:

• Beginning the journey
• Types of migrations (Lift and shift, Improve and move, Rip and replace)
• Google Cloud Adoption Framework
• The migration path

This is excellent and very detailed guide which will help you with migration from any source to GCP. GCP offers various options and resources for you to find the necessary help and support to best leverage GCP services. Excellent!

Ogundipe Samuel wrote this piece about optimization in React. One key factor for positive user experience is speed e.g. how much time a user has to wait to first see contents from your website or application.

With the help of some inbuilt APIs like React.Component, React.PureComponent and life-cycle methods React offers, we can optimize our components to ensure fast and efficient load times in our applications.

In this tutorial, we will learn various optimization methods that use these inbuilt APIs, lifecycle methods and some other general techniques that ensure you improve your React code.

The article covers:

• How to use React.Fragment to avoid adding extra nodes to the DOM
• Use React.Suspense and React.Lazy to load components declaratively
• Use React Suspense
• Prevent unnecessary re-rendering with shouldComponentUpdate()
• Use React.PureComponent
• Remove unused DOM elements with ComponentDidUnmount()
• Use React.Memo to cache components

In this tutorial, you explored several ways we can optimize our React components for better performance. Nice!

An article by Matt Mitchell in which he looks at the history of our infrastructure systems and the significant improvements that have been made in the last year or so in the world of the .NET Core 3.0.

The .NET Core project was a significant departure from traditional Microsoft projects:

• Developed publicly on GitHub
• Composed of isolated git repositories that integrate together vs. a monolithic repository.
• Targets many platforms
• Its components may ship in more than one ‘vehicle’ (e.g. Roslyn ships as a component of Visual Studio as well as the SDK)

The team working on the .NET Core early infrastructure decisions were made around necessity and expediency. The article explains then in some detail:

• A three-pronged approach to development
  • Shared Tooling (aka Arcade)
  • System Consolidation (Azure DevOps)
  • Automated Dependency Flow and Discovery (Maestro)
• Moving to Azure DevOps
• Maestro and Dependency Flow
• A Complex Graph

… you will get much more information in the article. The .NET Core evolved infrastructure quite a bit over the years. From Jenkins to Azure DevOps, from manual dependency flow to Maestro++, and from many tooling implementations to one, the changes they’ve made to ship .NET Core 3.0 are a huge step forward. Good read!

An article by Aaron Burk about distributed systems. Kafka decouples consumers and producers (meaning applications do not directly communicate with each other) it can be a challenge to illustrate exactly how data flows through your system. Author demonstrates how Jaeger is up to the challenge while navigating the pitfalls of an example project.

Jaeger is an open source distributed tracer. It records and illustrates the life cycle of transactions as they propagate through a distributed system. Jaeger does the heavy lifting and ultimately paints the pretty picture, while OpenTracing provides the APIs I will use to interact with it.

The article is divided into:

• What is Jaeger? What is OpenTracing?
• Example project
• Configuring Jaeger tracing
• Configuring Jaeger tracing: Spring Kafka Consumer/Producer
• Configuring Jaeger tracing: Kafka Consumer/Producer
• Initial Jaeger tracing result
• Finish tracing configuration: Headers
• Finish tracing configuration: Kafka Streams first consumer
• Finish tracing configuration: Kafka Streams dead letter queue
• Finish tracing configuration: Kafka and HTTP
• Final Jaeger tracing result

Extremely detailed detailed overview with configuration examples and screen-grabs of final tracing result. Well worth your time!