DEV Community: Tomislav Kraljic

Switches, Hubs, Bridges, and VLAN's

Tomislav Kraljic — Mon, 26 Jul 2021 02:10:58 +0000

In this article, I will go over switches, hubs, and bridges. I will explain what these devices are, how they work, use-cases and advantages and disadvantages. I will also explain what a VLAN is, how it works and why we would use them

Hub

This is a networking device that connects PC's to a single network.
This stores multiple ports, so when a packet arrives at one port, every other port also receives it.
This uses the Bus Topology Network as seen below.
If Computer 1 sends data to Computer 2, Computer 3, 4, and 5 will also receive that data.
This is commonly used in LAN(Local Area Networks) like in an office or campus.
This device is half-duplex. This means that PC's can not send and receive data at the same time. If this does happen, this would cause a collision.
This operates on the Physical Layer, also known as Layer 1.

How Does A Hub Work?

The implementation of a hub is fairly straight-forward.

Let's say you have a 5 PC's that you want to connect to the network.

You would plug each PC with a ethernet cable into the port of the hub.

Once, you plugged them all in, they can communicate to each and every one of the PC's connected to the switch.

Switch

This is a networking device that connects various devices to a single computer network.
This is commonly used in LAN (Local Area Network) as well!
Operates in Data Link Layer, or also known as Layer 2.
Maintains a MAC Address Table of each device.
Uses Frames and Packets
Commonly used in SOHO(Small Office/Home Office) as well!
Uses Full Duplex. This means each device can send and receive at the same time.
Uses the star topology network as seen below.
The big difference between a switch and a hub, is that when PC1 sends data to PC2, only PC2 will get it. No other devices on the network will receive that data.
This is super important because if that data is sensitive, we don't want anyone else to see it as well.
Switches also allow for VLANS (Virtual Local Area Networks)

Bridge

Bridges are used to connect two or more subnetworks.
It combines two LAN's to form an extended LAN.
It stores all the MAC Addresses of each device into a table.
When PC1 sends data over to PC2, it will first go to the bridge.
The bridge will determine which MAC Address it needs to go to and it will send it to the appropriate one.
This is used to reduce network traffic and increase performance because the LAN is now divided into segments.

VLAN

VLAN (Virtual Local Area Network) is when you break up a LAN into smaller subnetworks.
This can be accomplished by using a Switch or Router.
VLAN's are great for security as well.

How Does This Work?

Imagine we are using a LAN at an office.
There are several departments: Sales, Management, Engineering, Marketing, Etc.
We do not want the Sales department to know about any network traffic or data flowing inside the Engineering Department. That is only for Sales. It could have sensitive data as well that only Sales should know about.
This is where we break the LAN up.
We can designate 5 ports for Sales, 3 Ports for Engineering, 7 ports for Management and 2 ports for Marketing.
Each department basically is within it's own "virtual" network. It's like they have their own independent network that no one else can see.
This is the idea behind VLAN's.
This also reduces network traffic. You do not want to see traffic from every single department.

I hope this article has helped you in understanding these various network devices and how they work along with VLAN. If you have any questions, comments, or concerns, please feel free to let me know!

TCP vs UDP

Tomislav Kraljic — Sun, 25 Jul 2021 00:40:32 +0000

In this article, I will go over what TCP and UDP are, the differences between them, use-cases for each, how they work and the three-way handshake.

To understand TCP and UDP, we need to first understand what the Internet Protocol Suite is.

In Short, the Internet Protocol Suite is a collection of different protocols that the internet uses so devices can talk to one another.

TCP and UDP are two major protocols that the internet uses. Some other protocols within the Internet Protocol Suite that you may have heard of include: FTP (File Transfer Protocol), SMTP (Simple Mail Transport Protocol), and HTTP (Hyper Text Transfer Protocol).

Now, lets learn about TCP and UDP!

TCP

TCP stands for Transmission Control Protocol
It is the most common protocol used on the internet to transmit data
It is extremely reliable and guarantees that data will be transferred.
Has error-recovery features

When Is TCP Used?

TCP is used in situations where it is necessary that all data being sent is received by another device and it is guaranteed to do so.

How does TCP Work?

TCP is a connection-based protocol. This means that a connection is established between two devices before transferring data and maintains it throughout the transfer process.
To establish a connection between two devices, a three way handshake is initiated between the client and server.

For example, to read this article, your device, which could be a smartphone, tablet, or laptop will send a message to the server of this site.

This message is called a Synchronized Sequence Number (SYN).

Then, the message will get to the server and the server will acknowledge that the message was sent and received. It will send back an acknowledgement back to the client machine called SYN-ACK.

Then, the client machine will receive that SYN-ACK message from the server and send back a ACK (acknowledgement) message, resulting in a connection being established.

Once this connection is established, the protocol guarantees all data will be transmitted.

How Does TCP Do Error Recovery?

TCP has a mechanism called Windowing to control the flow of data.
A Window is the amount of data that can be sent before an ACK message is received.
The ACK message will have a forward looking acknowledgment number with the next expected data segment.
If this is wrong, the client will sent back the lost/dropped data segment back to the server before moving forward.
This will ensure no data is forgotten or lost.

UDP

UDP stands for User Datagram Protocol
Less reliable than TCP but lighter and faster.
Has way less features than TCP.
Does not care if data was sent successfully or not
Known as "fire and forget" protocol

When is UDP Used?

UDP is used for situations when data loss is acceptable and performance is highly criticle.
Great examples include: Online Gaming, Live Video/Audio, VoiP

How does UDP Work?

UDP is a connection-less protocol. This means that no connection is established beforehand, unlike TCP with the three-way handshake.
UDP will just send the data segments. It doesn't care if the server actually receives it and it doesn't do any error recovery either. This is why it is called the "fire and forget" protocol.

What is Cloud Computing?

Tomislav Kraljic — Tue, 06 Jul 2021 05:44:10 +0000

In this article, I will explain what Cloud Computing is, and the differences between Cloud Providers and On-Premise.

What is Cloud Computing?

The practice of using a network of remote servers hosted on internet to store, manage, and process data, rather than on a local server on a personal computer.

On Premise vs Cloud Providers

Before Cloud Computing existed, you had to have your own servers, data centers, maintain them physically, hire people to rack, stack and power those servers.

On Premise

You own the servers.
You hire the IT people.
You pay for the real-estate.
You assume all the risk.

Cloud Providers

With Cloud Computing, you pay the cost of utilizing a cloud provider and they do all the work for you! It's amazing, isn't it?

Someone else owns the servers.
Someone else hires the IT people.
Someone else pays for the real-estate.
You are only responsible for configuring the cloud services and the code that you deploy. Everything else is handles by someone else.

How To Configure and Run Nexus OSS on a Remote Server

Tomislav Kraljic — Mon, 28 Jun 2021 02:07:35 +0000

In this tutorial, I will teach you the two ways to configure/run the Nexus Repository Manager on a remote server.

For the remote servers, I will be using Digital Ocean.

Let's get started!

Running Nexus Directly on Server

1) First, we want to create our remote server on Digital Ocean.

2) Configure the Firewall Rules as such:

Do not forget to add the droplet to the firewall as well.

3) SSH into your remote server through the terminal.

ssh root@<ipv4_address>

4) Update the package manager

apt update

5) Change directories into opt

cd /opt

6) Get the Nexus OSS tar file

wget https://download.sonatype.com/nexus/3/latest-unix.tar.gz

7) Untar the file

tar -zxvf latest-unix.tar.gz

8) Create a new user because we do not want to run a service as root.

adduser nexus

9) Grant ownership of Nexus folders/files to the new user

chown -R nexus:nexus nexus-3.28.1-01
chown -R nexus:nexus sonatype-work

10) Open nexus.rc and add the new user you created

vim nexus-3.28.1-01/bin/nexus.rc

11) Uncomment and add the user inside the quotes and exit.

12) Switch to new user

su - nexus (or whatever you named the new user)

13) Start Nexus

/opt/nexus-3.28.1-01/bin/nexus start

14) Enter the IPv4 address of the remote server you created and add the port in the URL search bar.

 <ipv4_address>:<port>

Congratulations! You have successfully configured Nexus on your remote server!

Running Nexus Repository Manager via Docker

1) Pull the image from DockerHub

docker pull sonatype/nexus3

2) Create a volume

docker volume create --name nexus-data

3) Run the image in a container

docker run -d -p 8081:8081 --name nexus-data -v nexus-data:/nexus-data sonatype/nexus3

4) Enter the IPv4 address of the remote server you created and add the port in the URL search bar.

<ipv4_address>:<port>

Congratulations! You have successfully started Nexus on your remote server using Docker!

How IP Addresses Work

Tomislav Kraljic — Thu, 24 Jun 2021 21:49:49 +0000

In this article, I will go over what IP addresses are, types of addresses, class-full vs class-less addresses, classes of networks, subnets and CIDR (Classless Inter-Domain Routing) notation.

What is an IP Address?

In the most simplest terms, an IP (Internet Protocol) Address is a unique local address used to locate a computer/device via a network.

There are two types of IP Addresses:

1) IPV4 (32 bit)

192.168.0.100

2) IPV6 (128 bit)

FD3B:F15C:C672:34B8::100

In this article, we will focus on IPV4 addresses as they are the ones most commonly used.

Let's take a look at an example of an IPV4 address

192.168.0.100

Each number is called an octet because it is an 8 bit value.

192: 1100 0000
168: 1010 1000
0: 0000 0000
100: 0110 0100

8 bits means these number can range from 0-255.

0: 0000 0000
255: 1111 1111

This means an IP address starts at 0.0.0.0 and ends at 255.255.255.255.

This range of IP addresses is called the IP Space.

IP Addresses are actually comprised of 2 addresses in one.

Network Address
Host Address

Let's take a look at an example:

176.16.0.1

172.16: Network Address
0.1: Host Address

Is it always the first two as the network address and last two as the host address?

No. It is dependent on the class of address. We will take a look at them in the following section.

Class-full Networking and Classes of IP Addresses

There are a total of 5 classes: A, B, C, D, E

For this article, I will only go over classes A, B, and C because they pertain to devices and are the ones most commonly used.

Class A: Large Networks

Range: 1.0.0.1 - 126.255.255.254

Example:
1.2.3.4

The first number (octet) is for the network and the remaining three are for hosts.

1: Network
2.3.4: Hosts

Class B: Medium Networks

Range: 128.1.0.1 - 191.255.255.254

Example:
129.2.3.4

The first two numbers (octets) are for the network and the last two are for hosts.

Class C: Small Networks:

Range: 192.0.0.1 - 223.255.254.254

Example:
130.2.3.4

The first three numbers (octets) are for the network and the last number is for the hosts.

Note: You may notice that 127 is not included in these ranges. The reason is because that is a special one reserved for localhost.

This was called "class-full networking". This was the architecture used from 1981 until 1993. In 1993, CIDR(Class-less Inter-Domain Routing) was invented and we switched over.

Why?

Well, let's take a closer look at an IP Address.

172.16.0.0.

This allows for 65,000 hosts per network. If we have a bunch of small offices, we don't need to reserve 65,000 hosts per office. That is over-kill. Thus, we switched over to class-less networking.

Class-less Networking

Class-less networking relies on sub-netting and sub-net masks instead of classes now. We abandoned class-full networking and use class-less networking instead.

What is sub-netting?

Sub-netting is breaking up a large network into smaller ones.

What is a sub-net mask?

A sub-net mask tells us which part of the IP Address is for the network and host.

Example 1:4.3.2.1 -> 255.0.0.0

The 0's are reserved for hosts and the 255 (1) is reserved for the network.

Example 2: 183.6.22.9 -> 255.255.0.0

Example 3: 203.4.9.6 -> 255.255.255.0

With sub-netting, let's take a look at a previous IP Address used: 172.15.0.0

172.15.0.0 would be 255.255.0.0

This would allow for about 65,000 hosts in our network as mentioned previously.

We can break our network class into something smaller using our subnet mask.

So, instead of 255.255.0.0, it could be 255.255.255.0.

This would now only allocate 256 hosts per network. That is a lot better, and more manageable than 65,000.

CIDR Notation

CIDR Notation is a way for us to include the IP Address and the subnet mask.

172.16.1.0/24

/24 is the same as 255.255.255.0

This just means the first 24 bits of the subnet mask are turned on.

24 / 8 = 3 (first three octets of IP Address).

How To Install NPM and Node.js in Jenkins

Tomislav Kraljic — Thu, 24 Jun 2021 05:06:46 +0000

This article will be a continuation of my previous article (Configuring and Running Jenkins on a Remote Server with Docker).

If you haven't read it, here is the link:
https://dev.to/tomislavkraljic/configuring-and-running-jenkins-on-a-remote-server-with-docker-1cdl

In that tutorial, I went over how to create a remote server on Digital Ocean, configuring, and run Jenkins in a Docker Container on that server.

In this article, I will be teaching you how to install npm and Node.js inside a Jenkins Container. Let's get started!

Step 1: Make sure you remote server is up and running.

Step 2: SSH into your remote server via the command line.

 ssh root@<ipv4_address>

Step 3: Grab the container id of Jenkins:

docker ps

Step 4: Enter inside the container that is running Jenkins as root user

docker exec -u 0 -it <container_id> bash

Step 5: Check Linux Distribution running in your Container

cat /etc/issue

Step 6: Update APT

apt-update

Step 7: If not already, install Curl

apt install curl

Step 8: Run curl command to get scripts to install Node.js and NPM

curl -sL https://deb.nodesource.com/setup_14.x -o nodesource_setup.sh

Step 9: Execute script

bash nodesource_setup.sh

Step 10: Install Node.js and NPM

apt install nodejs

Congratulations! You successfully installed NPM and Node.js for Jenkins!

The OSI Model and How It Works

Tomislav Kraljic — Thu, 24 Jun 2021 03:13:28 +0000

In this article, I will go over what the OSI Model is and what each layer does along with its responsibilities.

What is the OSI Model?

The OSI (Open Systems Interconnection) Model is a reference guide to how devices/computers communicate with one another across a network.

It contains 7 layers. Each layer plays a crucial part in transmitting data across a network.

Layers of the OSI Model

We will go over each layer and their responsibilities.

Layer 7: Application Layer

The application layer is the human-computer interaction layer. This is where the applications accesses the network.

This would include web browsing, sending emails, file transfers.

Layer 6: Presentation Layer

The presentation layer is responsible for encrypting data (if necessary), data conversion and formatting. This is where you would find file formats like pictures and videos.

The application may contain lots of data that might not make sense to the rest of the network. This layer takes care of that issue.

Layer 5: Session Layer

An application/program may need to talk to several endpoints. It is important to track where these "conversations" occur. Each conversation is called a session. Each session is tagged with a session id as well.

Ultimately, this layer will create a session between two applications.

Layer 4: Transport Layer

The transport layer is responsible for breaking the data down into smaller chunks/blocks. We do not want to send all our data at once if there is a lot of data. Therefore, we break it up into smaller parts. Here, this layer will either use TCP or UDP.

With TCP, each block is called a data segment.

With UDP, each block is called a datagram.

This layer decides how much data is being sent and the rate of which the data is being sent at.

This layer uses port numbers to track where the data is going. Each flow of data has a port number associated with a source and destination host. These values are added to the header for each block of data.

Layer 3: Network Layer

The network layer is responsible for the routing and where exactly the data will be sent. It adds the source and destination IP addresses and puts that information into another header.

As of now, the data has two headers (one for ports, the second for IP addresses). This is called a packet.

This layer does not check for errors. Essentially, it blindly sends this packet down to the Data Link Layer.

Layer 2: Data Link Layer

This layer is responsible for getting data from once device to another by creating a logical link between devices.

This layer is comprised of two sub-layers: LLC(Logical Link Control) and MAC(Media Access Control).

The LLC is responsible for doing the translation between the Network Layer and the Data Link Layer.

The MAC is responsible for adding headers and trailers to the packet, making it a "frame" now.

The header will contain the source and destination MAC addresses.

The trailer will contain information regarding error detection.

Layer 1: Physical Layer

This layer is responsible for converting the frames into bits, encoding the data into physical signals and the actual physical connection between the devices.

Common Docker Commands

Tomislav Kraljic — Mon, 21 Jun 2021 04:22:38 +0000

Hey y'all! In this article, I will go over a lot of the main/common docker commands and what they do.

Let's get started!

docker images - This displays all the images installed on your machine. It contains a lot of important information such as tag, size, image id, and the repository installed.

docker ps - This displays all the containers currently running at the moment. This is super helpful if we want to go inside the container and access/configure some data.

docker pull <image> - This will pull a docker image from a repository. This could be from DockerHub, Nexus, AWS ECR, etc.

docker run -d - This will run the docker image in "detached" mode. This means that it will be running in the background.

docker stop <container_id> - This will stop the container from being executed.

You should be aware that if the container is running a application with data saved/configured, all the data will be lost when you stop the container. To fix this, use Docker Volumes.

docker run <image> - This will create a new container to run an image and execute the container.

docker start <container_id> This will launch the already existing container.

docker log <container_id> - This will retrieve logs of the container running. This is great for debugging!

docker exec -it <container_id> bin/bash - This enables you to go inside the container that is running and run commands, check configs, environment variables, etc.

If /bin/bash doesn't work, use /bin/sh

docker run -p <new_port>:<container_port> - This allows you to run the container on a separate host port.

docker build -t <name_of_image>:<tag> - This will build the image.

docker push <repository>:<tag> - This will push your docker image.

docker tag <image>:<tag> <new_image>:<new_tag> - This will allow you to rename your image and create of copy of it.

docker volume create --name <name> - This will allow you to create a volume and give it a custom name.

Configuring and Running Jenkins on a Remote Server with Docker

Tomislav Kraljic — Sun, 20 Jun 2021 03:26:31 +0000

In this article, I will go over how you can start Jenkins up on a remote server using the official image from Docker.

In this tutorial, for our server, I will use DigitalOcean.

I do want to preface this by saying, running a remote server on DigitalOcean is not free. However, it is relatively cheap to start one up.

Let's get started!

Creating/Configuring The Server

1) Create an account with Digital Ocean.

Type "https://www.digitalocean.com/" in your browser
Click the "Sign Up" button on the top right of the website.
You can either create an account with your email, Github, or Google.
After you create an account, you will need to verify that it's you.

2) Next, you want to create a Digital Ocean (Droplet)

3) After creating a Digital Ocean Droplet, you want to configure some settings. Lets break it down!

First, we will choose an image based on our current distribution. Currently, my machine is Linux Mint, so it is Ubuntu-based. Therefore, I will select "Ubuntu"

Second, we will select our plan. I will go with the cheapest and select "Basic".

Third, in our CPU Options, we will select "Regular Intel with SSD" and select the $20/month plan.

Fourth, select the region closest to you.

Fifth, we will select our authentication option as SSH.If you don't have an SSH already configured, let's configure it!

Click "New SSH Key". A prompt will open up. On the right pane, you will see a command of "ssh-keygen" Follow the instructions given.

Finally, click "Create Droplet"

3) Let's rename our droplet to something meaningful. I will be renaming mine to jenkins-tutorial-server.

4) Copy the IPV4 address because we will need it when configuring our firewall rules.

5) Click on networking link and scroll down to Firewall and click "Edit"

6) Next, we click the button that says "Create Firewall".

7) We can name our firewall whatever we want. I will be naming mine "jenkins-tutorial-firewall".

8) Next, we will paste our IPV4 address in the source of PORT 22.

9) We also want to add a custom port of 8080 to our Inbound Rules

10) Finally, add the droplet we created to the Firewalls Rules at the bottom and click "Create"

Accessing The Remote Server Via Terminal

Now, that we have created and configured our server on DigitalOcean, it is time to access it.

1) Open the terminal and ssh into your server by using the IPv4 address..

2) Once you hit enter, you will be given a prompt of



Are you sure you want to continue connecting (yes/no/[fingerprint])?

Type in "Yes" and hit enter again.

Now, you are inside your remote server.

3) Run apt update

4) After that is complete, we need to install Docker by running the command run apt install docker.io

5) Then, to install Jenkins, we need to run the command docker run -p 8080:8080 -p 50000:50000 -d -v jenkins_home:/var/jenkins_home jenkins/jenkins:lts

With p 8080:8080 we are binding the port that we specified in our Firewall of our server. This will allow us to access the UI of Jenkins.

With -p 50000:50000, we are specifying the port that the controller and agent nodes speak to each other on. Jenkins runs on a Controller-Agent architecture (that's a lesson for another day).

With -d, we are running it in detached mode. This means that it will be running in the background.

With v jenkins_home:/var/jenkins_home we are using Docker Volumes to reference a volume name to bind where the data is being stored to the local machine. This insures that when we stop our container, all the data and configurations we make is not lost.

Finally, with jenkins/jenkins:lts, we are pulling and executing the official Jenkins latest image.

6) After running this command, you want to type your IPv4 address, add a : and port 8080. Once you do, you will be greeting with a Jenkins Page

7) We need the initial password to login. To do this we need to do the following steps:

In the terminal run docker ps.
Copy the Container ID
Run docker exec -it <container_image> /bin/bash
Now, we are inside the docker container that is running Jenkins.
Run cat /var/jenkins_home/secrets/initialAdminPassword
Copy the password and paste it into the field of the Sign In Page.

8) Next, after logging in successfully, we will select Install Suggested Plugins

10) Now, we wait until all the plugins are installed

11) Next, we create our own admin user.

12) Congratulations, you successfully setup Jenkins on your own remote server on DigitalOcean using Docker!!

Now, you can poke around, create jobs, install plugins, etc in Jenkins!

How Does Docker Work?

Tomislav Kraljic — Sat, 19 Jun 2021 03:32:47 +0000

What is Docker?

Docker is a containerization tool that enables developers to easily pack, ship, deploy and run their applications.

If your application requires the installation of Node.js, Express, MongoDB, and Redis, you have to manually install these on your machine. Depending on the OS, this can get tedious and many things can go wrong.

However, with Docker, all those configurations, services, dependencies are installed and all you have to do is run the image in a container. You no longer have to directly install anything yourself.

Image vs Container

Image

File that holds the source code, configurations, dependencies, tools, etc needed to actually run the program
This is the actual package/artifact that can be moved around.

Container

A virtualized environment created during runtime that actually runs the image.
The container actually runs the image in its own virtual environment.

Docker vs Virtual Machine

To understand Docker, we need to understand the Operating System and it's layers.

The application layer is everything you interact with. This would include any desktop applications, IDE's, internet, etc. This application layer runs on top of the Kernel.

This OS Kernel handles device management, memory management, resource management, and accesses computer resources. It communicates with the hardware that includes the RAM, CPU, etc.

Docker

With Docker, the application layer is virtualized.
Docker Containers run/start faster!
Images are smaller.

Virtual Machine

A VM virtualizes both the application layer AND Operating System Kernel.
A VM can run an operating system on any host machine. However, with Docker, you can't.

Docker Engine

When you install Docker, you install the Docker Engine under the hood.

The Docker Engine is comprised of three components:

Server
- Responsible for pulling images
- Responsible for managing images and containers
API
- Responsible for interacting with docker server
CLI
- This is the client that is responsible for executing docker commands

Docker's Architecture

Docker uses a client-server architecture.
Docker's client (CLI) talks to the Docker server(daemon) which does the heavy lifting of building, running, distributing your containers.
When we talk about the daemon, it is simply a process called dockerd running in the background waiting for any requests by the API
The docker daemon (dockerd) listens for Docker API requests and manages docker objects(images, containers, networks, and volumes).
A daemon can also communicate with other daemons to manage the services.

Docker Server's Responsibilities:

Container Runtime
- Responsible for pulling images and managing container life-cycle.
Volumes
- Responsible for persisting data in containers when a container stops running or something goes bad.
Network
- Responsible for configuring networks for container communication
The functionality of building docker images.

Storage Classes in C

Tomislav Kraljic — Sun, 16 May 2021 06:51:44 +0000

In this article, I will go over the four storage classes in C: auto, extern, static and register. I will explain how to use them and the specifics of each storage class.

What is a Storage Class?

A storage class is a way to describe the features of a variable or function.

This includes:

Scope, visibility, and life-time.
Help us trace the existence of a particular variable during the run time of a program.

What Storage Classes Does C Provide?

C provides 4 storage classes:

auto
extern
static
extern

These can be divided into 2 storage duration's:

automatic storage duration
static storage duration

Auto Storage Class

The keyword auto is used to declare variables of automatic storage duration.
It means it is a local variable.
Every local variable created, is implicitly 'auto'
Created when the block in which they are defined is entered.
Destroyed when the block is exited.

Why use Auto?

Automatic storage is a way of conserving memory. We do not want every variable to be global.
We only want to use these variables when absolutely necessary.

Example 1

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){
    auto int age = 23; // same as int age = 23;
    printf("%d\n", age);

    return EXIT_SUCCESS;
}

Extern Storage Class

The extern storage class simply tells us that a variable is defined somewhere else.
We are telling the compiler "Hey, don't freak out. The variable is defined somewhere else and I am gonna use it.
The main purpose of using extern variables is that they can be accessed between different source files in a large program.
Functions contained in separate files can communicate through extern variables.
Functions are implicitly 'extern' as well.

Example 1

main.c

#include <stdio.h>
#include <stdlib.h>

extern int x;
extern int b;
extern void print_x();
extern void print_b();

int main(int argc, char * argv[]){
    print_x(); //32
    print_b(); //8

    x = 50;
    b = 99;

    print_x(); //50
    print_b(); //90

    return EXIT_SUCCESS;
}

extern.h

int x;
int b;
void print_x();
void print_b();

extern.c


int x = 32;
int b = 8;

void print_x() { printf("%d\n", x); };

void print_x() { printf("%d\n", b); };

Static Storage Class

The static storage class can be used on local and global variables and functions.
When applied to local variables, it instructs the compiler to keep the variable alive during the lifetime of the program (just like a global variable).
When applied to global variables, it instructs the global variable to only be able to be used/accessed in that file that it was declared in.
When applied to functions, it instructs the function to only be able to be called from the same file where it appeared.

Example 1

#include <stdio.h>
#include <stdlib.h>

void print_and_increment();

void print_and_increment_with_static();

int main(int argc, char * argv[]) {
    print_and_increment(); //1
    print_and_increment(); //1

    print_and_increment_with_static(); //1
    print_and_increment_with_static(); //2


}

void print_and_increment(){
    int value_one = 0;
    ++value_one;
    printf("%d\n", value_one);
}

void print_and_increment_with_static(){
   static int value_two = 0;
   ++value_two;
   printf("%d\n", value_two);
}

Here, we are seeing two different results.
The variable value_one only exists within the block of the function print_and_increment. When it leaves the scope, the variable is destroyed. No matter how many times we call it, we will get the same result.
The variable value_two is static. Therefore, it exists throughout the entire program. It is not local. Every time we call it, the value changes.

NOTE: Static variables should not be declared inside a struct. The C compiler requires the entire struct element to be placed together.

Register Storage Class

A processor register is a local storage space within the CPU that holds instructions, storage addresses, or any kind of data.
The register storage class is used to define local variables that should be stored in the register instead of the RAM
Makes the use of register variables faster than variables stored in RAM.
The keyword 'register' suggests to the compiler to put the variable inside the register.
Sometimes the compiler will listen, other times it wont. It is largely dependent on hardware and implementation restrictions.
Generally, the compiler will do it by itself regardless if you use this keyword or not.
You can not get the address of a register variable.
Register variables have the same life-span as an auto variable(local variable).
Therefore, register variables can not be declared globally, only locally.

Example 1


#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]) }
    register int age = 23;

    printf("Your age is %d\n", age);
}

Portability Bug in Window OS for STDIN

Tomislav Kraljic — Sat, 15 May 2021 03:29:44 +0000

I recently made a switch to Emacs and I stumbled upon a "bug" in the Windows OS when it comes to writing portable code in C. I will explain this bug in great detail in this article.

Let's first examine the bug.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char * argv[]){
    int age;

    printf("Enter age: ");

    scanf("%d", &age);

    printf("You are %d years old.", age);

    return EXIT_SUCCESS;
}

So, I ran this code in Emacs on Windows. This should work right?

It doesn't.

How so?

When you run the program, the printf() statement does not show up in the console. It immediately is reading input. Then, when you enter the age, you get:

23
Enter Age: You are 23 years old

The problem is how Windows handles I/O.

On Unix-like systems, inclusing MacOS, stdout has line based buffering. This means that stdout is flushed after seeing a newline.

However, Windows does not support line-based buffering. Newlines are no longer special and and full buffering is used.

stdout on Windows is either always unbuffered when attached to the console or fully buffered.

This is the options for stdout on Windows:

This stems from the expectation that stdout buffering should behave like in POSIX systems, which is not necessarily the case on 'windows-nt.

MacOS and Linux are mostly POSIX compliant while Windows is not.

Under "stderr, stdin, stdout - standard I/O streams", POSIX standard reads:

At program start-up, three streams shall be predefined and need not be opened explicitly: standard input (for reading conventional input), standard output (for writing conventional output), and standard error (for writing diagnostic output). When opened, the standard error stream is not fully buffered; the standard input and standard output streams are fully buffered if and only if the stream can be determined not to refer to an interactive device.

Windows uses pipes to communicate with subprocesses, while on Posix platforms use PTYs, which are a kind of console device.

However, Windows came out with WSL to solve this. WSL is POSIX compliant. But if you were to not use WSL, you would run into this portability issue. The resolution to this problem is to explicitly flush using:

fflush() or
setvbuf(stdout, NULL, _IONBF, 0); // turn off buffering for stdout