• Basic knowledge of Python

A data structure is a way to organize and store data. A queue is a linear data structure that handles data sequentially. It uses a first-in-first-out (FIFO) approach, meaning elements are processed and removed in the order they were added. A real-life example of a Queue is the line or queue in a banking hall, where the person in front of the cashier is served before others.

The process of removing an element in a queue is called dequeue while adding a new element is called enqueue. Insertion occurs in the rear while deletion is from the front.

Queues are practically used in a variety of domains and scenarios, for example, the instruction set of an operating system and e-commerce. Let's explore these examples:

1. Operating Systems: Queues play a crucial role in managing and scheduling tasks in operating systems. Tasks or instructions can be organized in queues based on priority or other scheduling algorithms. Then the operating system executes these tasks in the order they were inserted.

2. E-commerce: During peak periods, like sales or promotional events, simultaneous requests can overwhelm the system. To address this, a queue manages incoming requests, processing them in the order of arrival. By placing requests in a queue, the system avoids overload and ensures all requests are eventually handled. While customers may experience a short wait in the queue, it helps maintain system stability and reliability during high-traffic periods.

Here is a simple implementation of a queue:

class Queue:
    def __init__(self):
        self.queue = []

    def enqueue(self, item):
        self.queue.append(item)

    def dequeue(self):
        if len(self.queue) < 1:
            return None
        return self.queue.pop(0)

    def getFirstElement(self):
        return self.queue[0]

    def size(self):
        return len(self.queue)

However, this implementation can be inefficient in certain cases. For instance, when we want to handle a certain number of requests at a time due to multiple requests.

Enter the circular queue.

By employing a circular queue, it is possible to achieve simultaneous processing of limited requests during periods of high traffic. This allows for improved performance and throughput.

A circular queue utilizes a fixed-sized array, two pointers to indicate the start and end positions, and the last position is connected back to the first position to make a circle.

Here is an implementation of a circular queue:

class MyCircularQueue:

    def __init__(self, k: int):
        self.queue = [None] * k
        self.start = -1
        self.rear = -1
        self.maxSize = k

    def enQueue(self, value: int) -> bool:
        if self.isFull():
            return False
        if self.isEmpty():
            self.start = 0
        self.rear = (self.rear + 1) % self.maxSize
        self.queue[self.rear] = value
        return True

    def deQueue(self) -> bool:
        if self.isEmpty():
            return False
        if self.start == self.rear:
            self.start = -1
            self.rear = -1
            return True
        else:
            self.start = (self.start + 1) % self.maxSize
            return True

    def Front(self) -> int:
        if self.isEmpty():
            return -1
        else:
            return self.queue[self.start]

    def Rear(self) -> int:
        if self.isEmpty():
            return -1
        else:
            return self.queue[self.rear]

    def isEmpty(self) -> bool:
        return self.rear == -1

    def isFull(self) -> bool:
        return (self.rear + 1) % self.maxSize == self.start

In conclusion, queues are essential data structures for managing and processing data sequentially. They find practical applications in various domains, including e-commerce and operating systems. By utilizing queues, e-commerce platforms can efficiently manage order processing, handle high traffic situations, and ensure a smooth customer experience.

A feature of HTTP is that it is stateless. This means that HTTP does not store data related to the request or the server response. After the server responds, that connection is lost. Thus, for each request to fetch a resource, HTTP would make a new connection to the server to fetch resources. This will be problematic for users that have to interact with certain pages. For example, i would have to log in every time i want to view my Twitter profile or feed. But, HTTP cookies solve this by allowing the creation of a session. This cookie is then shared between the client and server on each request.

All devices that can connect to the internet utilize HTTP. It is simple and it allows computers to communicate and transfer data across the internet

There are two sets of data types in JavaScript: primitive and object

According to MDN, primitives are simple and immutable values, meaning they are less complex and cannot be changed.

Primitive data types

• Boolean values are either true or false. They can represent the evaluation of a condition. e.g

  if (a === 1) {
  // do something
  } else {
  // do another thing
  }
  

  let's imagine a is a variable defined someplace, then for the if block to run then (a === 1) must evaluate to true, a must be exactly the number 1, note that this evaluation is implicit, meaning that you can't see it. if a is not equal to 1 then the else block runs. the literal form of Boolean values is true and false
• Number is any integer or floating-point number. e.g let count = 2 or let weight = 60.5
• String is any text that is surrounded by either single or double quotes. e.g let name = 'Olalekan' or let fruits = "berry"
• Null is a type that has only one value, null. e.g let total = null
• Undefined is also a type that has only one value, undefined. e.g let age = undefined

Although null and undefined can mean an absence of other values, they are different because a variable is undefined when it has been declared but not yet assigned a value. while null represents no value.

Some primitive values also behave like objects because they have methods. e.g strings, numbers, and Booleans. null and undefined have no methods

Objects

Ok, this part really confused me at first, I will refer to the object data type as reference types. These values include Objects, Functions, Array, RegExp, Date etc. object types are different because they can hold other data types.

They also have methods and properties attached to them. The object data type can be referred to as reference type because a variable is not actually holding the object data type but a pointer or reference to the value. A variable will only store a reference to an array, function or object, not the value itself

According to Nicholas Zakas, an object is an unordered list of properties and value. These properties are mostly strings while the value can be any other data type. When the value of a property is a function, it is called a method.

Reference types can be created either by using the new constructor e.g

let obj = new Object()

let getInfo = new Function()

or using their literal form

let obj = {
  name: 'Eren';
  age: 99;
}

function getInfo() {
  return 'something'
}

But creating a function with the new keyword is not recommended.

In the example below, am assigning a pointer to the object to the dad variable.

let dad = { 
  name: "Lee" 
};

let son = user; // son shares the same reference with dad 

console.log(son) // Object { name: "Lee" }

Changing the object value through one variable will affect the other because they point to the same object in memory. In order to change or access the value of a reference type, we have dot notation

let dad = { 
  name: "Lee" 
};

son.name = "Armin";

console.log(dad) // Object { name: "Armin" }

and so also is bracket notation

let dad = { 
  name: "Lee" 
};

son["name"] = "Armin"

console.log(dad) // Object { name: "Armin" }

Other than the common object, we also have other specialised object types such as

Array: an ordered list of numerically indexed values

let score = [2, 4, 54, 343];

Date: represents the date and time

let count = new Date();

Function:

function getData(value) {
  return value;
}

RegExp: represents a regular expression

// literal form
var numbers = /\d+/g;

Further reading

Nicholas Zakas book on OOP

Js.info on object referencing