DEV Community: Gabriella Amaefule

Understanding The Operating System - The Brain Behind Your Computer

Gabriella Amaefule — Fri, 04 Apr 2025 20:38:40 +0000

What is an Operating system

An operating system (OS) acts as a resource manager, where 'resources' refer to computer hardware such as the CPU, RAM, disk storage, and I/O devices. It simplifies program execution by allocating memory and facilitating communication between software and hardware. In reality, a computer has only one set of these physical resources yet hundreds of programs rely on them simultaneously. The OS efficiently distributes these resources among all running applications.

Additionally, the operating system ensures smooth and effective performance through three key functions:

i. Virtualization
ii. Concurrency
iii. Persistence

Virtualization: The Art Of Creating Illusions

Imagine you have a single apple but need to share it among five children at the same time. To make this work, you create a visual copy of the apple for each child. Now, all five happily believe they’re eating their own apple unaware of the illusion.

In computing terms:

The apple represents a single core CPU (or any physical resource like memory).
The children are programs demanding simultaneous processing.
The visual copies are virtualized resources.

Example - CPU virtualization

const process = require("process")

function virtualizationExample(){
    for(let i = 0; i < 5; i++){
        console.log(`PID- ${process.pid} ${i}` )
    }
}

virtualizationExample()

in our terminal, run the command

node visual.js & node visual.js & node visual.js & node visual.js

the following will be displayed in the terminal

macbook@Gabriella-Macbook tt % node visual.js & node visual.js & node visual.js & node visual.js 
[1] 10125
[2] 10126
[3] 10127
PID- 10126 0
PID- 10128 0
PID- 10125 0
PID- 10127 0
PID- 10126 1
PID- 10127 1
PID- 10125 1
PID- 10126 2
PID- 10127 2
PID- 10125 2
PID- 10126 3
PID- 10127 3
PID- 10126 4
PID- 10125 3
PID- 10127 4
PID- 10125 4
PID- 10128 1
PID- 10128 2
PID- 10128 3
PID- 10128 4
[1]    done       node visual.js
[3]  + done       node visual.js
[2]  + done       node visual.js

An interesting insight to see. even though we only have one CPU, our system still manages to run 4 programmes at once and we can see a mix of process id's from each of the diffrent process - (A process is a running program)

How does this work? The operating system employs clever scheduling policies to rapidly switch between processes, creating the seamless illusion of parallelism. (We’ll dive deeper into these policies in a future article!)

Concurrency: The Art of Juggling Processes

Let’s revisit our apple analogy. When we created virtual instances of the apple for each child, it seemed like every child had their own apple. But in reality, we were quickly passing a single apple between them so fast that no one noticed the switch.

In computing terms, this is exactly how the operating system handles multiple processes on a single CPU. For example, when you run four instances of a program, the OS rapidly cycles between them allocating resources to PID-10126, then PID-10128, then PID-10125, and so on.

This lightning fast switching happens in milliseconds and is called context switching. It’s the magic behind the illusion that your computer is running dozens of programs simultaneously, even with just one CPU core.

Persistence: How Data Survives Power Off

In systems, memory is volatile especially memory associated with a running program (process). when our system is abruptly shut down or turned off, all the data stored in the memory of the process is lost and so, our system need a means to store data persistently.

In modern systems, a hard drive (HDD - Hard Disk Drive) or an SSD (Solid State Drive) is used to store data permanently.

The software in the operating system that manages how data is stored on the disk is called the File System. it handles storage and easy retrieval of files in an efficient manner.

Unlike the CPU and Memory, The Operating system does not create a virtualized form of the disk storage.

In a Nodejs context, whenever we use the fs library, system calls are routed to the file system of the operating system.

The operating system sends I/O request to the storage device through the device driver - (A code in the operating system that deals with the operation of a device in a system) in order to figure out where this new data will be stored in the file system and ensures it keeps track of the structure currently maintained in the file system.

Summary

In this article we covered the major functionality of the operating system and how it accomplishes it. we started with virtualization - how the operating system creates an illusion of abundant resources and how it uses concurrency to share this single resource among running programs and how it ensures persistency of data using the file system.

Together, these three pillars enable your computer to run smoothly, efficiently, and reliably.

Thank you reaching this far!. Dont forget to like ❤️, share 🔃 and comment 💬

Understanding the concept of caching in software developement

Gabriella Amaefule — Wed, 29 Jan 2025 22:07:07 +0000

What is caching ?

Caching is a technique used to store the results of frequently accessed requests or database queries in an auxiliary data store. This allows the data to be quickly retrieved the next time it is requested, reducing the need to recompute or fetch it from the original source. By leveraging caching, systems can improve performance, reduce latency, and decrease the load on primary data sources.

Why is Caching Important?

Caching is a critical technique used in developing scalable systems and applications. One of the key factors that determine the scalability of an application is its ability to compute and return responses in as little time as possible. Caching plays a vital role in achieving this by reducing the amount of computation and workload handled by the application. Specifically, it minimizes the number of database calls, which are often resource-intensive.

By reusing previously computed or fetched data, caching helps to optimize resource utilization, including CPU, memory, and network bandwidth. This not only improves the efficiency of the system but also ensures that resources are available for other critical tasks.

Lastly, caching significantly enhances the user experience by delivering faster and more consistent responses to end-users. This is especially important in high-traffic applications where latency can negatively impact user satisfaction.

Types of Caching
Below, we explore how caching is implemented across different layers of an application:

i. Client-Side Caching
On the client interface, responses for frequently requested calls to the server can be cached in the browser cache, local storage, or session storage. This ensures that the data is readily available when requested again, reducing the need for repeated server calls. Examples include:

Search Tools: In platforms like Google, responses for frequently searched queries are cached.
Social Media Apps: Profiles of popular celebrities or frequently accessed user data are cached.
E-Commerce Apps: Product details from the inventory are cached to speed up page loads.

ii. Server-Side Caching
On the server side, caching is used to reduce the load on primary data sources and improve response times. Common use cases include:

Database Queries: Caching the results of frequently executed database queries.
Third-Party API Calls: Storing responses from external APIs to avoid repeated calls.
File Reads: Caching data read from files to minimize disk I/O operations.

iii. CPU Caching
Modern CPUs utilize caching to bridge the gap between the processor and the main memory. CPU caches store frequently accessed program instructions and data, enabling faster access and improving overall system performance.

In this article, we will focus on how caching can be effectively implemented on both the server side and client side of an application.

How Client-Side Caching Works

When a user visits a web application for the first time, the client (e.g., a browser) initiates a GET request to fetch data, such as the entire product inventory. Here's how the process unfolds:

Request Initiation:
At the marker (i), the client sends a request to the server to retrieve the required data.
Data Retrieval:
At the marker (ii), the server processes the request and returns the requested data (e.g., the product inventory) to the client.
Data Caching:
Upon receiving the data, the client saves it at the marker (iii) into a cache. This cache could be the browser cache, local storage, or session storage, depending on the implementation.

Subsequent Requests
If the user makes another request for the same data (e.g., the product inventory), the client follows these steps:

Cache Check:
The client first checks its cache to see if the data is already available locally.
Cache Hit:
If the data is found in the cache (a cache hit), the client retrieves and returns the data directly without making another round trip to the server. This significantly reduces latency and improves performance.
Cache Miss:
If the data is not found in the cache (a cache miss), the process starts over:

The client sends a new request to the server.
The server processes the request and returns the data.
The client stores the newly fetched data in the cache for future use.

How Client-Side Caching Works

When a client makes its first request (i) to fetch data from the server, the server follows these steps:

Request Processing:
The server receives the request and identifies the required data.
Data Retrieval from Storage:
At the marker (ii), the server retrieves the data from its storage, which could be a database (as in this example) or a file directory.
Data Caching:
Once the data is retrieved, the server stores it in its cache at the marker (iii). This cache could be an in-memory store like Redis or Memcached.
Data Return:
Finally, the server sends the requested data back to the client.

Subsequent Requests

If the client requests the same data again, the server follows these steps:

Cache Check:
The server first checks its cache to see if the data is already available.
Cache Hit:
If the data is found in the cache (a cache hit), the server retrieves and returns the data directly to the client without making another trip to the database. This reduces latency and minimizes the load on the database.
Cache Miss:
If the data is not found in the cache (a cache miss), the process starts over:

The server retrieves the data from the database or file directory.
The server stores the newly fetched data in its cache for future use.
The server returns the data to the client.

By understanding caching you can design systems that are faster, more scalable, and resource-efficient. However, caching should be implemented thoughtfully, considering the specific requirements and trade-offs of your application.

Please don't forget to comment, like or share this article ❤️

Load Testing For API With Apache Benchmark On Windows

Gabriella Amaefule — Sat, 18 Mar 2023 18:43:31 +0000

I recently had the need to carry out load testing on some endpoints that I created for a project on my Windows OS. Setting this up was part of a herculean task because most tutorials were done on an Ubuntu machine.

What is Load Testing

Load Testing is a type of performance testing that gives you insight into how your web application or HTTP server would react when more demand is placed on it.

For this article, we will focus on testing an HTTP server using Apache Benchmark on a Windows OS.

Requirements

Vs-code
Apache Benchmark

Installing Apache Benchmark

The latest version of Apache Benchmark for windows can be installed here

Move into the Apache24/bin directory and copy both the ab and abs executable files to your project directory (optional).

Making a GET request to our server

Run the following command in your terminal, in the directory where your ab and abs executable files are located:



./ab -c 10 -n 20 http://localhost:8080/

-c Concurrency
This indicates the number of multiple requests to make at a time. For this test, we are sending 10 requests to our server concurrently at the same time.
-n Request
This indicates the number of requests to perform.

More of this flags and there descriptions can be found in the Apache Benchmark site

For this test, below is our expected response.



this is ApacheBench, Version 2.3 <$Revision: 1903618 $>
Copyright 1996 Adam Twiss, Zeus Technology Ltd, http://www.zeustech.net/
Licensed to The Apache Software Foundation, http://www.apache.org/

Benchmarking localhost (be patient).....done


Server Software:
Server Hostname:        localhost
Server Port:            8080

Document Path:          /
Document Length:        23 bytes

Concurrency Level:      10
Time taken for tests:   0.033 seconds
Complete requests:      20
Failed requests:        0
Total transferred:      19240 bytes
HTML transferred:       460 bytes
Requests per second:    606.58 [#/sec] (mean)
Time per request:       16.486 [ms] (mean)
Time per request:       1.649 [ms] (mean, across all concurrent requests)
Transfer rate:          569.85 [Kbytes/sec] received

Connection Times (ms)
              min  mean[+/-sd] median   max
Connect:        0    0   0.4      0       1
Processing:     3   12   3.9     13      18
Waiting:        2   10   4.0     10      17
Total:          3   13   3.8     13      18

Percentage of the requests served within a certain time (ms)
  50%     13
  66%     15
  75%     16
  80%     17
  90%     17
  95%     18
  98%     18
  99%     18
 100%     18 (longest request)

This provides a detailed insight into how our server performs when 10 concurrent requests are sent. It shows the amount of time it takes to process a certain percentage of our requests and provides in-depth analysis of our server's performance.

Making a POST request to our server using Apache Benchmark

When making a POST request that requires a request body, we need to pass the data to our benchmark request. This is done by creating a .txt file that should contain our request body data. The file should be in the same location as our ab and abs executable files.

For this test, I created a post.txt file that contains a JSON object representing our request body.

The request body should be in one line with no extra end-of-line spaces.

TIP: To place data in one line on VS Code, select the whole content and use this command CTRL + SHIFT + J.

Proceed to run the following line of command in your terminal.



./ab -p post.txt -T application/json  -c 5 -n 5 http://localhost:8080/v1/product

-p Post File
This indicates the file containing data to POST.
-t Content Type
Content-type header to use for POST/PUT data, eg. application/x-www-form-urlencoded. Default is text/plain.

To test a server that requires an authentication header with Apache benchmark, the following command can be used:



ab -p post.txt -T application/json -H 'Authorization: Token abcdbdhbuhfrhv' -c 10 -n 200 http://localhost:8080/v1/product

-H Custom header - This appends extra headers to the request. The argument is typically in the form of a valid header line, containing a colon-separated field-value pair (i.e., "Accept-Encoding: zip/zop;8bit").

Note: Apache Bench only uses one OS thread irrespective of the concurrency level (specified by the -c flag). Therefore, when benchmarking high-capacity servers, a single instance of Apache Bench can be a bottleneck. To completely saturate the target URL, use additional instances of Apache Bench in parallel (if your server has multiple processor cores).

Don't forget to like, share and let me know if you found this helpful.

How to convert a PDF page to an image using Nodejs

Gabriella Amaefule — Mon, 25 Jan 2021 20:55:15 +0000

Recently, I had to work on a project where I was required to get the the cover page of pdf being sent to the server on each request. It was quite challenging because there were not enough resources to learn how to automate this task. I found a package which helped me, so I decided to share with the community!.

Project setup

RootFolder --
            |-pdfFileFolder --
                             |-myFile.pdf
            |-pdfImageFolder
            |-converter.js
            |-package.json

Install third party library

To effectively carry out this task, we need to install a third party library called pdf-poppler

npm i pdf-poppler

Code

copy the following line of code into the file labelled convert.js

import {default as pdfConverter} from 'pdf-poppler'
import path from 'path'

function convertImage(pdfPath) {

    let option = {
        format : 'jpeg',
        out_dir : 'C:\\Users\\user\\Desktop\\RootFolder\\pdfImageFolder',
        out_prefix : path.basename(pdfPath, path.extname(pdfPath)),
        page : 1
    }
// option.out_dir value is the path where the image will be saved

    pdfConverter.convert(pdfPath, option)
    .then(() => {
        console.log('file converted')
    })
    .catch(err => {
        console.log('an error has occurred in the pdf converter ' + err)
    })

}

export default convertImage

The convertImage function contains an argument which is the path to the PDF file to be converted to an image. This function with it's argument can be called in any file where needed.

Thank you for taking the time to read this post. If you've found this useful, please give it a ❤️ or 🦄, share and comment.