DEV Community: John Muthua

CockroachDB vs PostgreSQL

John Muthua — Wed, 12 Oct 2022 15:23:47 +0000

    * Chapter 1

    * Chapter 2

Chapter 1 Introduction

Roaches are among the most persistent creatures in the universe. They are so tenacious that they can go for weeks without their heads [1]
. The residency of these creatures is so astonishing enabling survive in high altitudes, extreme weather conditions [2], to a point of surviving a nuclear holocast [4] . Did the creators of cockroachDB have this in mind while designing the software? It's hard to say but it is quite obvious from their software design perspective.

Chapter 2 What is CockroachDB

As they explain the product on their website:

CockroachDB is a distributed SQL database built on a transactional and strongly-consistent key-value store. It scales horizontally; survives disk, machine, rack, and even datacenter failures with minimal latency disruption and no manual intervention; supports strongly-consistent ACID transactions; and provides a familiar SQL API for structuring, manipulating, and querying data.

CockroachDB was created with the cloud in mind. One of its biggest sale points is its ability to be distributed in numerous geographical regions and its simplicity to scale. In relation to the creature, this DB can survive a digital nuclear holocaust through the fault-tolerant methods they incorporate in their software architecture. The DB favors CP (Consistency and Partition Tolerance) in place of Availability. The developers of the DB employed the Eric Brewer CAP theory by allowing the DB to stay functional even when certain nodes are offline [5].

In computing, the occurrence of failure is an indisputable event. The question revolves no if the failure occurs rather it is a matter of when it does occur. CockroachDB addresses this phenomenon by ensuring the salvage, protection, and continuity of data.

Why choose cockroachDB over postgresql

1. Scaling

As pointed out earlier, the greatest benefit of using cockroachDB is its ability to scale. Unlike other RDBMS that scales through complex conventions such as sharding, cockroachDB scales seamlessly. By default, cockroachDB has a fixed threshold of 512MB. After this data range is reached, the data is split into two parts. Each of the parts further splits when the threshold is arrived at providing numerous avenues to scale. Moreover, the 512MB threshold enables easy replication and distribution of data to several geographical regions.

Case of postgres on scaling

Cloud applications rely on their ability to scale to enhance efficiency. There are two types of scaling; horizontal and vertical scaling. Postgres was built with vertical scaling in mind. This simply means that scaling a Postgres database would involve increasing the hardware resources of a single node which has a constraint of an upper limit[6].

Note: This does not mean that Postgres databases have no options for horizontal scaling although it is not a straightforward process[7].

Sebastian Insausti further expounds on scaling postgres and its not a walk in the park[8]. CockroachDB does not suffer from such drawbacks as Postgres as it automatically scales both vertically and horizontally provided there are enough system resources or there is an increase in the number of nodes within the cluster.

2. Data Integrity

CockroachDB employs numerous technologies to ensure the integrity of data. Replication is one of the methods the DB uses. These replicas are rebalanced based on the available number of nodes in the cluster. Replication not only ensures availability in the event a node is down but also improved performance as applications can read and write to multiple sources.
The DB also incorporates functionalities repair data in the event of server failure.

Postgres on Data Repair

Postgress does not support data repair

CockroachDB terminologies and Meaning

TERM	MEANING
Cluster	This is an instance of a CoachroachDB deployment that has numerous nodes and acts as a single application.
Nodes	These are physical computing modules that are running instances of coachroachDB
Range	This refers to user data stored in the database. By default coachroachDB splits the data automatically into two ranges when a threshold of 512MB is reached
Replica	These are exact copy of user data that ensure availability in the event a node is offline. By default it is set to 3 as the number represent the minimum number to achieve a quorum. $tolerance = \frac{Replication factor -1}{2}$ By using a replica of 3, the database can tolerate unavailability of one node.
Raft	This is an algorithm that cockroachDB uses to ensure that there is a consensus on who is the leader in a group. The followers will replicate data from the leader[9].

You can check out the complete comparision in [https://www.cockroachlabs.com/docs/v22.1/cockroachdb-in-comparison]

SORTing => The weird parts

John Muthua — Wed, 12 Oct 2022 15:10:26 +0000

As you realize the sort function performs mutations on the original array. This more often than not leads to bugs that are difficult to pin-point their origin and produce erroneous results.

There are various methods that one can apply to ensure that bugs do not arise in the process as using test, but in this article, we are solely interested in the possible programming errors that might arise when using sort.
Lets elaborate this using a simple method of sorting arrays in both ascending and descending order with the assumption that the array contains only numbers.

Pit Fall 1: In Functions

One of the simplest method is the use of the sort function directly as:
Given the array [12,21,56,1,88,3,2,45] to sort from the largest to the smallest

let arr = [12, 21, 56, 1, 88, 3, 2, 45];
const largeToSmall = (arr) => {
  return arr.sort((a, b) => a - b);
};
console.log(largeToSmall(arr)); //[1,2,3,12,21,45,56,88]

The code works as expected, lets take the code a little further by adding a smallest to largest conversion

let arr = [12, 21, 56, 1, 88, 3, 2, 45];
function fnOrderArr(arr) {
  const smallToLarge = arr.sort((a, b) => a - b);
  const largeToSmall = arr.sort((a, b) => b - a);
  console.log(largeToSmall); //[88,56,45,21,12,3,2,1]
  console.log(smallToLarge); //[88,56,45,21,12,3,2,1]
}
fnOrderArr(arr);

Notice that largeToSmall is working fine as the array is arranged from the largest to the smallest but as soon as we hit the smallToLarge as we expect the results to be [1,2,3,12,21,45,56,88] but we got [88,56,45,21,12,3,2,1]. Whats going on?

Note that sort() function performs a mutable operation on our array. This means the function literally reorders the array elements in the array.

In our program:

Step 1: Original Array

Our original array is [12, 21, 56, 1, 88, 3, 2, 45]

Step 2: Arrange by ascending Order

After our smallToLarge operation the original array changes to [1,2,3,12,21,45,56,88]

Step 3: Arrange by Descending Order

Now the original array is [1,2,3,12,21,45,56,88] and by trying to order the function in descending order, there seem to develop a bug as it still resorts to [1,2,3,12,21,45,56,88] showing clearly that the sort function fails to perform as expected.

Pit Fall 2: In Classes using Static Methods

The sort function display similar erroneous performance when used in classes with static methods

class OrderInt {
  constructor(arr) {
    this.arr = arr;
  }
  static highToLow(arr) {
    const tempArr = arr;
    const highLow = tempArr.sort((a, b) => a - b);
    return highLow;
  }
  static lowToHigh(arr) {
    const tempArr = arr;
    const lowHigh = tempArr.sort((a, b) => b - a);
    return lowHigh;
  }
}

const arr = [23, 745, 166, 333, 221];
const orderDecreasing = OrderInt.highToLow(arr);
const orderIncreasing = OrderInt.lowToHigh(arr);
console.log("Order in Decreasing Order ", orderDecreasing); //[745,333,221,166,23]
console.log("Order in Increasing Order ", orderIncreasing); //[745,333,221,166,23]

Using Classes without Static Methods

Strangely, using classes with normal method seem to work with the sort function working as expected.

class OrderInt {
  constructor(arr) {
    this.arr = arr;
  }
  highToLow(arr) {
    const tempArr = arr;
    const highLow = tempArr.sort((a, b) => a - b);
    return highLow;
  }
  lowToHigh(arr) {
    const tempArr = arr;
    const lowHigh = tempArr.sort((a, b) => b - a);
    return lowHigh;
  }
}
const Order = new OrderInt()
const arr = [23, 745, 166, 333, 221];
console.log("Order in Decreasing Order ", Order.highToLow(arr)); //[23,166,221,333,745 ]
console.log("Order in Increasing Order ", Order.lowToHigh(arr)); //[745,333,221,166,23]

Although the sort function works both when ordering in ascending or descending order, it still mutates the original array

Leave a like ❤️ if you found this useful
Happy coding 🔥 🔥

Ordering arrays in Javascript

John Muthua — Fri, 23 Sep 2022 18:58:17 +0000

The ordering of arrays is a common task while working with data. JavaScript provides numerous methods of accomplishing this task.

Method 1: Using `sort` function

NOTE: when using sort function to sort numbers in javascript it may be tempting to use it directly as:

const arr = [2, 13, 4, -75, 22, 5];
arr.sort(); //[ -75, 13, 2, 22, 4, 5 ]

You realize that the results are not what you expected. Direct use of the sort function only works with strings as:

const arr2 = ["father", "mother", "children", "adam", "eve"];
arr2.sort();
//[ 'adam', 'children', 'eve', 'father', 'mother' ]

Although the method provides the expected output, one should not that capital and small letters are treated differently. For example:

const arr3 = ["Eve", "adam"];
arr3.sort(); //[ 'Eve', 'adam' ]

Notice in the array one would expect the a in adam to come before the E in Eve but that not the case with the sort function as uppercase letters always take presidence.
To solve this issue we may decide to convert the letters to lowercase then perform the sort as:

const arr3 = ["Eve", "adam"];
arr3.sort((a, b) => a.toLowerCase().localeCompare(b.toLowercase));
//[ 'adam', 'Eve' ]

Now we get the expected results. Although this is a solution, there are concerns raised againist using toLowerCase expecially as they do not work with certain local languages.

Intl.Collator provides one with the ability to specify the sort order incomparision to the locales.

const arr3 = ["Eve", "adam"];
arr3.sort(Intl.Collator().compare);
//[ 'adam', 'Eve' ]

As in the documentation example when dealing with Germany locale

const a = ["Offenbach", "Österreich", "Odenwald"];
const collator = new Intl.Collator("de-u-co-phonebk");
a.sort(collator.compare);
console.log(a.join(", "));
// → "Odenwald, Österreich, Offenbach"

Furthermore, Intl.Collator provides additional customizations as Intl.Collator('de', { sensitivity: 'base' }). Learn more here

Sorting Numbers

Method 1: Using the `sort` function

Using sort simplifies the work of arranging numbers in certain orders.
sort is used as below to arrange numbers

//smallest to Largest
function smallToLarge(arr) {
  return arr.sort((a, b) => a - b);
}

//largest to smallest
function largeToSmall(arr) {
  return arr.sort((a, b) => b - a);
}

Note that rearranging from largest to smallest and vice versa may be simplified by using the reverse() method after performing a sort()

Method 2: Using a `for` loop

One may also use a for loop to arrange numbers within arrays in javascript

//Ordering from largest to smallest
function minMax(arr) {
  let tempArr = arr;
  let minMaxArr = [];
  for (let i = 0; i < arr.length; i++) {
    let min = Math.min(...tempArr);
    tempArr = tempArr.filter((item) => item !== min);
    minMaxArr.push(min);
  }
  return minMaxArr.pop();
}

Here, we use the pop function to remove the last element of the array which in our case would be Infinity.
Finding the maximum would be simply replacing the min function with a max function as follows:

function maxMin(arr) {
  let tempArr = arr;
  let maxMinArr = [];
  for (let i = 0; i < arr.length; i++) {
    let max = Math.max(...tempArr);
    tempArr = tempArr.filter((item) => item !== max);
    maxMinArr.push(max);
  }
  return maxMinArr.pop();
}

Leave a like ❤️ if you found this useful
Happy coding 🔥 🔥

Finding the Minimum and Maximum Values of an Array in JavaScript

John Muthua — Fri, 23 Sep 2022 17:10:00 +0000

In javascript it is possible to find the minimum and maximum value of an integer in an array

This is among the most common coding interview question that interviewers use to test the skills of developers.

Chapter 1 Using in built library

The simplest method of finding the minimum value of an array is by using the in built Math library that has both Math.min and Math.max functions for finding minimums and maximums.

//Find the maximum in an array
let maxValue = Math.max(...arr);

//Find the minimum in an array
let minValue = Math.min(...arr);

Chapter 2 Using in `for` loops

One can also accomplish this by the use of a for loop as shown

//Find the maximum in an array
function arrMax(arr) {
  let maxArr = Number.NEGATIVE_INFINITY;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] >= maxArr) {
      maxArr = arr[i];
    }
  }
}

The same can be used in finding the smallest number

//Find the minimum in an array
function arrMin(arr) {
  let minArr = Number.POSITIVE_INFINITY;
  for (let i = 0; i < arr.length; i++) {
    if (arr[i] <= minArr) {
      minArr = arr[i];
    }
  }
}

Number.NEGATIVE_INFINITY and Number.POSITIVE_INFINITY are used in javascript to represent the lowest and highest number representation of the language.

Chapter 3 Using in `reduce` function

Alternatively, one may opt to use the Array.prototype.reduce() function in finding the minimum and maximum values of an array. The reduce function simply uses a provided callback to return a single element. In our case, this is either the minimium value or the maximum value.

//Find the minimum in an array
function arrMin(arr) {
  return arr.reduce((a, b) => (a < b ? b : a));
}

//Find the maximum in an array
function arrMax(arr) {
  return arr.reduce((a, b) => (a < b ? a : b));
}

The (a, b) => (a < b ? b : v) expression works as an if.. else statement. In javascript it is referred to as the Ternary operator with a method signature as

variable = Expression1 ? Expression2: Expression3

Leave a like ❤️ if you found this useful
Happy coding 🔥 🔥

DEV Community: John Muthua

CockroachDB vs PostgreSQL

Table Of Contents

Chapter 1 Introduction

Chapter 2 What is CockroachDB

Why choose cockroachDB over postgresql

1. Scaling

Case of postgres on scaling

2. Data Integrity

Postgres on Data Repair

CockroachDB terminologies and Meaning

SORTing => The weird parts

Pit Fall 1: In Functions

Step 1: Original Array

Step 2: Arrange by ascending Order

Step 3: Arrange by Descending Order

Pit Fall 2: In Classes using Static Methods

Using Classes without Static Methods

Ordering arrays in Javascript

Method 1: Using sort function

Sorting Numbers

Method 1: Using the sort function

Method 2: Using a for loop

Finding the Minimum and Maximum Values of an Array in JavaScript

Chapter 1 Using in built library

Chapter 2 Using in for loops

Chapter 3 Using in reduce function

Method 1: Using `sort` function

Method 1: Using the `sort` function

Method 2: Using a `for` loop

Chapter 2 Using in `for` loops

Chapter 3 Using in `reduce` function