DEV Community: Biraj

Empty Strings and Zero-length Arrays: How do We Store... Nothing?

Biraj — Mon, 24 Jun 2024 06:53:25 +0000

In high-level languages like Python and JavaScript, we are pretty used to initializing strings and arrays like this:

let myStr = ""; // an empty string
let myArr = []; // an empty array

We're saying that these are empty, which implies they contain zero bytes of data. So we are storing zero-bytes of data? Huh? Tf is this paradoxical nonsense?

Storing Nothing

An empty array or string doesn't contain any elements or characters, yet it exists. This can feel as paradoxical as carrying an invisible suitcase that weighs nothing. But how do we make sense of this? drumrolls Actually, it's NOT really empty.

Strings: The C Language Perspective

To unravel this mystery, let's take a trip to the world of C programming. In C, strings are typically handled as arrays of characters ending with a null character ('\0'). But what happens when you want an empty string?

When you create an empty string in C, you are essentially allocating a string that points to a memory location that stores the null character. This is akin to reserving a seat at a table for a ghost. The chair is there, the place is set, but nobody's coming to dinner. Reminds me of my last date.

Here's a simple representation in C:

char emptyString[1] = "";

In this example, emptyString is an array with a single element (notice the [1]in the declaration), which is the null terminator. The length of the string is zero, but the array emptyString itself is very much real and occupies memory. It's like having an address to an empty house.

In C, the length of a string is determined by iterating through each character until the null terminator ('\0') is encountered. This is exactly what the strlen() function does. It counts characters until it finds the null byte, excluding the terminator itself.

The strlen() function calculates the length of the string pointed to by s, excluding the terminating null byte ('\0').

So strlen(emptyString) will start the counter with 0 but immediately reach the null byte, resulting in a length of 0.

Zero-Length Arrays

In C, arrays are typically fixed in size once declared. So first let's C (ok sorry, see) how we can implement a dynamic or growable array of integers using a struct:

struct IntArray {
  int *data;     // pointer to the array's data
  int length;    // current number of elements in the array
  int capacity;  // maximum capacity of the array
};

Here, IntArray represents a C struct that manages an array of integers. It consists of:

data: A pointer to the array's data (which can dynamically grow).
length: The current number of elements in the array.
capacity: The maximum capacity of the array, indicating how many elements can be stored before needing to resize.

Unlike traditional fixed-size arrays, instances of IntArray can dynamically adjust their size as elements are added or removed, akin to how arrays work in higher-level languages like Python or JavaScript. However, in C, this flexibility comes with added responsibility. Developers must manually manage memory allocation and resizing. They need to track the array's length when pushing or popping elements.

When an IntArray is initialized, memory is allocated based on the capacity in bytes, and the address of the allocated memory is stored in the data pointer. The length field is then set to zero. This process is analogous to what higher-level languages like JavaScript do internally when you create an empty array.

Why This Matters

Knowing that an empty string in C is just a pointer that points to '\0' character feels good. Curiosity is reason enough! Here's what I tweeted today:

go underneath those abstractions anon, and you'll experience wonders.

Understand JavaScript Array Methods By Implementing Them

Biraj — Fri, 20 Jan 2023 19:18:46 +0000

When I started learning modern JavaScript (or ES6 😏), array methods were one of the most challenging things for me to wrap my head around. I had no idea what to do with these maps, filters, reduce & stuff. And now that I understand them, I believe that the best way to understand them properly would be to try to implement them on our own.

To understand this post, you'll need an understanding of for loops, arrays (duh), functions (also arrow functions), callbacks & ability to interpret code 🌝. You should be able to read the example code & understand what each method does under the hood. Btw if you don't know what callbacks are, here's my explanation.

Callback Functions (a crash course)

A callback function is just a function that is passed as an argument to another function, and this callback function will be then called back (callback get it? 🤯) internally when it's needed.

function cb() {
  console.log("this is my callback function...");
}

function someStuff(cb) {
  // doing some stuff...
  console.log("done with it...");
  // maybe doing some more stuff...
  cb();
  // again doing something...
}

someStuff(cb);

Output:

done with it...
this is my callback function...

Or you can write it like:

someStuff(() => {
  console.log("this is my callback function...");
});

someStuff(function () {
  console.log("this is my callback function...");
});

All three of these ways are equivalent & will produce the same output. Basically you just pass a function as an argument to another function, and it's being called internally when it's needed. That's it.

Now coming to array methods, this is how I want you to think about them:

An array method will take a callback function.
Now internally, this method will create a new array.
Then it will 'run a for loop' & iterate over each element of this array.
For each iteration, the current element will be passed as an argument to the callback function, which will then do something with that value.
Then the value that is returned by the callback function is used by the method in some way to add the current new value to the resultant array. (specifics differ for each method)
After it's done with all the elements, it will return the new array.

Notes:

Most of the array methods will not change the original array & will return an entirely new array.
This was just a general & informal way to understand the process.
The callback function will also get the index of current element as its second argument.

Now let's look at some example implementations 🚀. Btw each example will have these:

Me blabbering something 🤡
Implementation code 🧑‍💻
Output 💻
Code's explanation 🧠

Example 1: map() method

The JavaScript map method 'transforms' an array to into an new array by calling a callback function on each element, and populating the resultant array with it's return value. The reason I enclosed 'transforms' in quotes because it does not actually modify the original value.

function map(arr, callback) {
  const result = [];
  for (let i = 0; i < arr.length; ++i) {
    result.push(callback(arr[i], i));
  }

  return result;
}

const numbers = [2, 4, 9, 10];
const squares1 = numbers.map((num) => num ** 2);
const squares2 = map(numbers, (num) => num ** 2);

console.log(squares1);
console.log(squares2);

Output:

[ 4, 16, 81, 100 ]
[ 4, 16, 81, 100 ]

Explanation:

result = [] (initially)

 2 ** 2 =   4 [4]
 4 ** 2 =  16 [4, 16]
 9 ** 2 =  81 [4, 16, 81]
10 ** 2 = 100 [4, 16, 81, 100]

returns [4, 16, 81, 100]

Example 2: filter() method

The filter method is essentially used to filter out some elements based on some test. The callback function for filter should return a boolean, which will be used to determine which elements will be there in the resultant array. If the callback return true for the current element, only then it will be added to the resultant array.

function filter(arr, callback) {
  const result = [];
  for (let i = 0; i < arr.length; ++i) {
    if (callback(arr[i], i)) {
      result.push(arr[i]);
    }
  }

  return result;
}

const numbers = [0, -1, 4, -10, 5, 10, 100, -22];
const negatives1 = numbers.filter((num) => num < 0);
const negatives2 = filter(numbers, (num) => num < 0);

console.log(negatives1);
console.log(negatives1);

Output:

[ -1, -10, -22 ]
[ -1, -10, -22 ]

Explanation:

result = [] (initially)

  0 < 0 = ❌ []
 -1 < 0 = ✅ [-1]
  4 < 0 = ❌ [-1]
-10 < 0 = ✅ [-1, -10]
  5 < 0 = ❌ [-1, -10]
 10 < 0 = ❌ [-1, -10]
100 < 0 = ❌ [-1, -10]
-22 < 0 = ✅ [-1, -10, -22]

returns [-1, -10, -22]

Example 3: reduce() method

The reduce method is used to perform some operation on the array & somehow 'reduce it' to a single value. Basically just take an array, do something on it & just return a single value. The callback for this method would take 2 arguments: accumulator & current value. The current value argument is the same old element at current index, but what is this accumulator though?

What is accumulator?

The accumulator is just a variable which is given some initial value (or it would set to the first element in the array by default) which then stores (or accumulates 🌝) the value that is returned by the callback. Finally, this value is then returned by reduce(). The most common example for this would be to calculate the sum of all the elements in an array, and I think that reading the code would be better than reading my words.

function reduce(arr, callback, initialValue) {
  let accumulator = initialValue;
  let start = 0;
  if (arguments.length !== 3) {
    accumulator = arr[0];
    start = 1;
  }

  for (let i = start; i < arr.length; ++i) {
    accumulator = callback(accumulator, arr[i], i);
  }

  return accumulator;
}

const numbers = [-1, 5, 2, -3, 10];
const sum1 = numbers.reduce((a, c) => a + c, 10);
const sum2 = reduce(numbers, (a, c) => a + c, 10);

console.log(sum1);
console.log(sum2);

Output:

23
23

Explanation:

Here the initial value of the accumulator would be 10.
Now here's what's gonna happen (I'm gonna refer to accumulator as acc:

acc = 10 (initially)

acc = 10 + -1 =  9
acc =  9 +  5 = 14
acc = 14 +  2 = 16
acc = 16 + -3 = 13
acc = 13 + 10 = 23

returns 23

Btw if we hadn't provided the initial value to reduce(), then it would've been:

acc = -1 (default: first element of the array)

acc = -1 +  5 =  4
acc =  4 +  2 =  6
acc =  6 + -3 =  3
acc =  3 + 10 = 13

returns 13

You can read more about JavaScript Array at MDN. Thank you for reading my post. Your honest feedback (if any) is appreciated 🤝.

Introduction to NumPy

Biraj — Wed, 04 May 2022 08:49:25 +0000

NumPy is a Python library that is mainly used to work with arrays. An array is a collection of items that are stored next to each other in memory. For now, just think of them like Python lists.

NumPy is written in Python and C. The calculations in NumPy are done by the parts that are written in C, which makes them extremely fast compared to normal Python code.

Installation

Make sure Python & Pip are installed in your computer. Then open command prompt or terminal and run

pip install numpy

Creating Arrays

We can create a NumPy array by using the numpy module's array() function.

import numpy as np

arr = np.array([3, 5, 7, 9])
print(type(arr))

Output:

<class 'numpy.ndarray'>

We just created a NumPy array from a list. The type of our arr variable is numpy.ndarray. Here ndarray stands for N-dimensional array.

Dimensions or Axes

In NumPy, dimensions are called axes (plural for axis). I like to think of an axis as a line along which items can be stored. A simple list or a 1 dimensional array can be visualized as:

We will now look at the following:

Scalars (0D Arrays)
Vectors (1D Arrays)
Matrices (2D Arrays)
3D Arrays
4D Arrays

1) Scalars (0D Arrays)

A scalar is just a single value.

import numpy as np

s = np.array(21)
print("Number of axes:", s.ndim)
print("Shape:", s.shape)

Output:

Number of axes: 0
Shape: ()

Here we have used 2 properties of a numpy array:

ndim: It returns the number of dimensions (or axes) in an array. It returns 0 here because a value in itself does not have any dimensions.
shape: It returns a tuple that contains the number of values along each axis of an array. Since a scalar has 0 axes, it returns an empty tuple.

2) Vectors (1D Arrays)

A vector is a collection of values.

import numpy as np

vec = np.array([-1, 2, 7, 9, 2])
print("Number of axes:", vec.ndim)
print("Shape:", vec.shape)

Output:

Number of axes: 1
Shape: (5,)

vec.shape[0] gives us the number of values in our vector, which is 5 here.

3) Matrices (2D Arrays)

A matrix is a collection of vectors.

import numpy as np

mat = np.array([
    [1, 2, 3],
    [5, 6, 7]
])

print("Number of axes:", mat.ndim)
print("Shape:", mat.shape)

Output:

Number of axes: 2
Shape: (2, 3)

Here we created a 2x3 matrix (2D array) using a list of lists. Since a matrix has 2 axes, mat.shape tuple contains two values: the first value is the number of rows and the second value is the number of columns.

Each item (row) in a 2D array is a vector (1D array).

4) 3D Arrays

A 3D array is a collection of matrices.

import numpy as np

t = np.array([
    [[1, 3, 9],
     [7, -6, 2]],

    [[2, 3, 5],
     [0, -2, -2]],

    [[9, 6, 2],
     [-7, -3, -12]],

    [[2, 4, 5],
     [-1, 9, 8]]
])

print("Number of axes:", t.ndim)
print("Shape:", t.shape)

Output:

Number of axes: 3
Shape: (4, 2, 3)

Here we created a 3D array by using a list of 4 lists, which themselves contain 2 lists.

Each item in a 3D array is a matrix (1D array). Note that the last matrix in the array is the front-most in the image.

5) 4D Ararys

After looking at the above examples, we see a pattern here. An n-dimensional array is a collection of n-1 dimensional arrays, for n > 0.
I hope that now you have a better idea of visualizing multidimensional arrays.

Accessing Array Elements

Just like Python lists, the indexes in NumPy arrays start with 0.

import numpy as np

vec = np.array([-3, 4, 6, 9, 8, 3])
print("vec - 4th value:", vec[3])

vec[3] = 19
print("vec - 4th value (changed):", vec[3])

mat = np.array([
    [2, 4, 6, 8],
    [10, 12, 14, 16]
])
print("mat - 1st row:", mat[0])
print("mat - 2nd row's 1st value:", mat[1, 0])
print("mat - last row's last value:", mat[-1, -1])

Output:

vec - 4th value: 9
vec - 4th value (changed): 19
mat - 1st row: [2 4 6 8]
mat - 2nd row's 1st value: 10
mat - last row's last value: 16

NumPy arrays also support slicing.

# continuing the above code

print("vec - 2nd to 4th:", vec[1:4])
print("mat - 1st rows 1st to 3rd values:", mat[0, 0:3])
print("mat - 2nd column:", mat[:, 1])

Output:

vec - 2nd to 4th: [4 6 9]
mat - 1st row's 1st to 3rd values: [2 4 6]
mat - 2nd column: [ 4 12]

In the last example, [:, 1] tells "get 2nd value from all rows". Hence, we get the 2nd column of the matrix as the output.

Example: Indexing in a 4D Array

Let's say we want to access the circled value. It is located in the 2nd 3D array's last matrix's 2nd row's 2nd column. It's a lot so take your time. Here's how to access it:

arr[2, -1, 1, 1]

Python VS NumPy

At the beginning of the post, I said that calculations in NumPy are extremely fast compared to normal Python code. Let's see the difference. We will create two lists with 10 million numbers from 0 to 9,999,999, add them element-wise and measure the time it takes. Then we will convert both lists to NumPy arrays and do the same.

import numpy as np
import time

l1 = list(range(10000000))
l2 = list(range(10000000))
sum = []

then = time.time()
for i in range(len(l1)):
    sum.append(l1[i] + l2[i])

print(f"With just Python: {time.time() - then: .2f}s")

arr1 = np.array(l1)
arr2 = np.array(l2)

then = time.time()
sum = arr1 + arr2
print(f"With NumPy: {time.time() - then: .2f}s")

Output:

With just Python:  2.30s
With NumPy:  0.14s

In this case, NumPy was 16x faster than raw Python.