DEV Community: Raziq Din

Getting Started with Ollama: From Installation to Testing

Raziq Din — Mon, 16 Feb 2026 21:04:35 +0000

If you want to run your AI models locally without relying on a cloud API (like ChatGPT public website) , Ollama could give you a way for that idea! In this guide , we will guide you on how to install Ollama , downloading a model and testing it with a simple prompt or message, everything in your terminal!

Before that , let’s bring you to a simple introduction about Ollama.

What is Ollama?

Ollama is an open-source framework that allows you to run Large Language Models (LLMs) like Llama 3, Mistral, and DeepSeek etc. directly on your own hardware (laptop or desktop). It handles the "heavy lifting" of AI , like managing memory, talking to your GPU, and downloading massive model files , so you can just type a command and start chatting!

Of course you're wondering , why does Ollama exists?

Why does Ollama exists?

before Ollama, running a model locally was a nightmare. You had to:

Manually download multi-gigabyte files.
Configure complex Python environments and C++ libraries.
Keep praying that your GPU drivers were compatible with the specific version of the model.

Ollama exists to simplify this into a single click or a single terminal command. It packages the model weights, configuration, and the "inference engine" into one neat bundle!

What are the benefits of running Ollama?

Privacy & Security:

Your data never leaves your computer. This is a game-changer for businesses or individuals handling sensitive medical, legal, or personal data.

Zero Cost:

No "per-token" fees. You pay for the electricity to run your computer, but the AI is free to use forever.

Offline Access:

It works on a plane, in a basement, or anywhere without an internet connection.

Developer Friendly:

It automatically sets up a local API (at localhost:11434) that mimics OpenAI's API, making it incredibly easy to build your own apps.

Performance Optimization:

It uses "quantization" (shrinking the model size) to let you run powerful AI on standard consumer laptops, not just $10,000 servers.

Without further ado, let's go through how to download Ollama , install it's models and run the model in Ollama!

1.Install Ollama

Ollama provides both a GUI app and a command-line interface (CLI) that allows you to interact with models locally.

Steps:

Go to ollama official website : Ollama
Download the installer for your own OS
Run the installer and follow the prompts , after that , ollama can be opened in your system

2.Verify installation

Run

ollama --version

in your command prompt as shown below:

3.Download a Model

In the same terminal , if you want to download a model and start using it right away, use the run command. If the model isn't on your computer yet, Ollama will automatically pull it first. Since i have installed gemma3 , i attached a llama3 model that you can download through this command below;

4.Running the Model

After that , you can use the run command with the model name that you have downloaded , the example is attached below:

If the prompt command is shown after you type the command , then congratulations! You have successfully installed and run your model locally via your command prompt!

Here is also some responses the model will give you after you type an input!

And there you have it! This is how you can run your AI models locally using Ollama. While running the model locally is convenient for data privacy and developer friendly , there are some notable fallbacks of running the models locally.

Notable Fallbacks

RAM is King:

If you try to run a model larger than your available RAM (or VRAM on your GPU), it will either be painfully slow or crash.
Rule of thumb: 8GB RAM for 3B–7B models; 16GB+ for 8B–13B models; 32GB+ for 30B+ models.

Silent GPU Fallback:

If Ollama can't find your GPU (or it runs out of VRAM), it will silently switch to your CPU. You’ll know this happened because the response speed will drop from "lightning fast" to "one word every two seconds.”

Storage Hog:

Models are HUGE in storage size. A single "medium" model (like Llama 3 8B) takes about 5GB. If you download 10 different models to "test" them, you'll lose 50GB of disk space very quickly.

No "Long-term" Memory:

By default, Ollama doesn't "remember" you between different sessions unless you use a UI (like Open WebUI) or write a script to manage the conversation history.

Even more so , Ollama plays a significant role to your future projects!

Ollama’s roles in any projects

Ollama plays two critical roles in any project: it is the Librarian and the Engine.

The Librarian (Model Management)

Ollama handles the "messy" parts of working with AI models so you don't have to.

Downloading:

It pulls the massive model files (like Llama 3 or Mistral) from the internet.

Storage:

It organizes them on your hard drive so they're ready to use.

Optimization:

It "shrinks" the models (quantization) so they can
actually run on a normal laptop instead of a giant server.

The Engine (Inference Server)

This is its main job during a project. Ollama sits in the background and waits for instructions.

The API:

It creates a local "doorway" (at localhost:11434). Your web app or script knocks on this door and sends a prompt.

Brain Power:

When a prompt arrives, Ollama "starts" the model's brain, uses your computer's RAM/GPU to think, and generates the answer.

Process Isolation:

It keeps the AI separate from your code. If the AI model crashes because it ran out of memory, your actual website or app won't crash; only the Ollama "engine" stalls.

There you have it! I'm looking forward to your upcoming projects being integrated with Ollama. Hopefully this article will be helpful to you and goodluck for your future work with Ollama! Thank you and let me know your feedback on this article. Will improve more :)

How to bulk insert your data to Supabase with CSV

Raziq Din — Sun, 25 Jan 2026 07:29:00 +0000

If you’re working with Supabase and want to import data from a CSV file, the key to a smooth import is proper CSV structure. A poorly structured CSV can lead to errors, rejected rows, or data mismatches. This article walks you through everything you need to know to prepare your CSV for Supabase.

For clarification, Supabase provides a built-in feature that lets you bulk insert data into a database table using a CSV file, making it easy to import large amounts of data without writing any code. This is especially useful when inserting data one by one is impractical and when you need to ensure that each record is linked to the correct foreign key in one whole insert chunk.

The use case might differ , but this method is very efficient and could be useful to some of the readers out there!

To go through this tutorial , we will bring you to a situation , lets say if you are building a CMS that also stores quizzes for users , there are many situations we can think about simply by going through this task. To simplify this , we will separate the csv column and data structure in two situations :

1.Questions stored in a single table ( No FK required )

Let's say we have a table column defined in our Supabase like this:

quiz_questions
--------------
id (uuid, pk)
question_text (text)
option_a (text)
option_b (text)
option_c (text)
option_d (text)
correct_option (text)

there are no foreign keys involved, to do this , you can construct your CSV files according to these columns below:

question_text,option_a,option_b,option_c,option_d,correct_option
What is the capital of France?,Berlin,Madrid,Paris,Rome,C
Which language runs in the browser?,Java,Python,JavaScript,C++,C

notice that I did not put the id values in my csv structure , this is because you don't have to provide it in the first place! You can simply leave it and let Supabase generate the id for you.

Disclaimer : ensure that your ID in Supabase is auto generated by the system itself to ensure non existence error occurence when submitting your csv file to Supabase.

2.Questions and options stored in separate tables (FK required)

This structure is used when questions and options are normalized into different tables and linked using foreign keys. In this case , our questions and options are connected using a foreign key (FK).

Questions Table

questions
---------
id (uuid, pk)
question_text (text)

Options Table

id (uuid, pk)
question_id (uuid, fk → questions.id)
option_text (text)
is_correct (boolean)

To put the data in your csv in case like this , we will put it based on this structure:

Questions.csv

question_text
What is the capital of France?
Which language runs in the browser?

Options.csv

question_id,option_text,is_correct
4f9e1a2b-3c4d-4e5f-8a9b-0c1d2e3f4a5b,Berlin,false
4f9e1a2b-3c4d-4e5f-8a9b-0c1d2e3f4a5b,Madrid,false
4f9e1a2b-3c4d-4e5f-8a9b-0c1d2e3f4a5b,Paris,true
4f9e1a2b-3c4d-4e5f-8a9b-0c1d2e3f4a5b,Rome,false
d9876543-210e-4fba-9c8d-7e6d5c4b3a21,Java,false
d9876543-210e-4fba-9c8d-7e6d5c4b3a21,Python,false
d9876543-210e-4fba-9c8d-7e6d5c4b3a21,JavaScript,true
d9876543-210e-4fba-9c8d-7e6d5c4b3a21,C++,false

Notice that we have unique ids in our question_id , in order to get these ids , you need to ensure to grab the question id from Supabase tables data and paste it respectively to your CSV files and its related data. Check out the note below for more clear clarification!

Note: For columns that have foreign key constraints, you need to provide the related primary key values in your CSV file so that Supabase can correctly associate the records and successfully insert the bulk data.

So there you have it! To wrap this up , here is a little trick and tips for you when doing this task:

Use snake_case for headers (eg , course_title, created_at) for consistency between your Supabase DB and CSV files
Keep text simple: avoid emojis or formatting.
Treat the CSV like a database migration: structured, clean, and precise.
Test a small CSV first before importing thousands of rows.

For more info , simply refer to Supabase's official documentation on this task! : Supabase CSV Data Insert

Conclusion

Getting your CSV right makes everything with Supabase so much easier. When your headers match your table, your data types make sense, and your formatting is clean, the import process becomes quick and painless. A little prep goes a long way; double-check your file, test with a small batch first, and fix any issues early. Once that’s done, you’ll be able to bulk insert data confidently without the usual headaches.

Thank you everyone! Happy weekend!

Fixing the "Ghost Folder" in GitHub: Converting a Broken Submodule to a Normal Folder

Raziq Din — Fri, 26 Dec 2025 22:53:51 +0000

If you’ve ever pushed your code to GitHub and noticed a folder icon with a white arrow on it, and found that you couldn't click into that folder to see your files, you aren’t alone. This is a common headache for developers, typically caused by a "nested repository" or a broken Git submodule.

Check the example down below ( it's my repo , a pretty interesting use case from one of my projects ) :

The Anatomy of the Problem

The arrow icon on the folder indicates that Git is treating that directory as a submodule. This usually happens when you initialize a project (like a React app using create-react-app) inside an existing Git repository.

Because the new folder that I initiated comes with its own hidden .git folder, your main repository gets confused. It thinks, "I shouldn't track these files, I should just point to this other repository instead." Since that "other" repository isn't linked correctly on GitHub, you end up with an empty, unclickable folder.

In this article , We're going to walk through how to solve this issue!

Step 1 : Locate to root project

Locate yourself to your root project , for example:

project-root/
├── backend_folder/     # Go backend
│   └── main.go
├── my-app/             # Expo / React Native app

I will navigate back to project-root/ directory

Run this command after that:

git rm --cached my-app

This command is used to stop your git ecosystem from tracking the my-app/ folder as a submodule (since the folder has the .git file). This command will remove the tracking version of the folder without losing your files

Step 2: Delete the Internal Git Data

Run this command :

Remove-Item -Recurse -Force my-app/.git

Your backend or frontend folder might have a hidden .git file to track its own folder files changes. You have to delete the file so it will stop acting as its own independent repository. In my case , the .git file is in my react native folder called my-app/.

Step 3 : Re-add and Push

Once your .git file in some of your folders are deleted , you can start tracking your folders and files under one parent git repository.

Run this command :

git add your-folder-name/
git commit -m "Fixed: converted submodule to a normal directory" 
git push origin your-branch-name

Now , your remote repository will store all your folders and files in the project on Github!

The End Results:

There you go, thank you very much for the read. Hopefully this tip is useful to you dear readers :). Have a good day and let me know your thoughts on this!

Demystifying Django Architecture : A Beginner-Friendly Guide

Raziq Din — Fri, 12 Dec 2025 18:41:13 +0000

Django has a reputation: "Powerful....but scary". You install a new project and suddenly you're staring at files and folders like urls.py , wsgi.py , settings.py , apps , models and magic commands like migrate , all before even touching your django project.

Unlike Flask’s simplicity in software architecture, Django provides a more structured, batteries-included framework that enforces clear separation of concerns and scalable architecture from the beginning.

This guide will demystify Django's structure , why it's designed this way , how each part plays a role in building your modern web applications.

1. Django's Core Pattern: MVT != MVC

While most frameworks such as Laravel , Rails and even Flask extensions follow the classic MVC method (Model-View-Controller) design pattern, Django takes a slightly different by closely related approach called MVT (Model-View-Template)

Model defines the database structure and handles data interactions.

Template handles what the user sees such as UI rendering.

View processes logic, receives requests and return responses.

A simple flow of how Django works are shown below:

User requests -> URL -> View (Logic) -> Model (Data) -> Template (Display UI) -> Browser (Chrome , Opera etc)

This separation helps developers maintain clean, scalable code. Perfect for complex application with both user features and admin management!

2. Understanding Django's multiple folder system

Let's take a broader look at a Django project. A Django project is organized into two main types of folders, each serving a distinct purpose:


myproject/
│
├── myproject/           # Project settings folder
│   ├── __init__.py
│   ├── settings.py      # Configuration for DB, apps, middleware, templates
│   ├── urls.py          # URL routing for the whole project
│   ├── wsgi.py / asgi.py# Server gateway interface
│
├── myapp/               # Application folder
│   ├── __init__.py
│   ├── models.py        # Database schema (used by both User & Admin)
│   ├── views.py         # Logic for User side
│   ├── urls.py          # Routes specific to this app
│   ├── templates/       # HTML templates (User side)
│   │   └── myapp/
│   │       └── *.html
│   ├── admin.py         # Admin interface registration
│   ├── forms.py         # Forms for both User & Admin (optional)
│
├── manage.py            # Command-line utility for migrations, running server, etc.
└── db.sqlite3           # Example database

2.1 myproject folder under myproject folder

Pretty weird concept right? Well , when you create a django project , you will begin with this command

django-admin startproject myproject

When you run this command , Django will create:

Outer folder (myproject/) – This is the project root or workspace. It holds everything related to your project, including your apps, the database, and manage.py. Think of it as the body of your project where all files live.

Inner folder (myproject/) – This is the project configuration folder. It contains all the settings and configuration files necessary to run your Django project, such as settings.py, urls.py, wsgi.py/asgi.py, and init.py. Think of it as the brain of your project.

Key files in the inner folder:

settings.py → Central place for configuration: databases, installed apps, middleware, templates, static files, and more.

urls.py → Central routing table for the project; can include app-specific URL patterns.

wsgi.py / asgi.py → Entry points for deploying your project on a web server.

init.py → Marks the folder as a Python package, enabling imports.

Think of the inner folder as the brain of the project, while the outer folder is the body or workspace that holds everything together.

2.2 myapp project in myproject folder

After creating a project, you create apps to handle different functionalities. For example:

python manage.py startapp myapp

Django creates the following structure:


myapp/
├── __init__.py       # Marks folder as a Python package
├── admin.py          # Register models to the admin interface
├── apps.py           # App configuration
├── models.py         # Database models for this app
├── views.py          # Logic / controllers for this app
├── urls.py           # App-specific routes (optional, you can create manually)
├── migrations/       # Database migrations for this app
└── templates/        # Optional HTML templates for this app

From this structure , Django suggests that :

Apps are modular → Each app is self-contained.
Reusable → You can plug an app into multiple projects.
Organized → Each app has its own models, views, and templates.
Example: You could have a blog app, a shop app, and a users app, all inside the same project.

2.3 How Project and App Work Together

myproject/ is responsible for the global settings and routing.
Each app that you created contains its own models, views, templates, and logic.
For example , a blog app that you created can register their routes in the project-level urls.py using include():


# myproject/urls.py
from django.contrib import admin
from django.urls import path, include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('blog/', include('blog.urls')),  # routes from the 'blog' app
]

This modular design keeps your code organized and scalable, especially for larger projects.

2.4 Key Takeaways

Django's architecture is designed based of separation of concerns.The project acts as the central configuration, holding global settings, URLs, and server interfaces, while each app is a self-contained module responsible for a specific feature, with its own models, views, and templates. This separation ensures that models handle data, views handle logic, and templates handle presentation, keeping the code organized and maintainable. The project + app structure dynamic also makes it easier to scale, as new functionality can be added by creating new apps without affecting existing ones.

Thank you for reading , look forward to more software engineering digest!
Happy weekend :)

Applying Object Relational Mapping (ORM) on a C# .NET application

Raziq Din — Sat, 18 Oct 2025 08:08:52 +0000

Hello everyone! In this post , we will go through about ORM implementation on a C#/.NET program, from introduction of ORM concepts all the way to CRUD demonstration.

Recently, I’ve been building an indie music player, a Terminal User Interface (TUI) application, since I love minimalistic and lightweight apps. As I worked through the project requirements, I decided to integrate an Object Relational Mapping (ORM) system into my project alongside PostgreSQL to handle database operations more efficiently.

While exploring the Microsoft Entity Framework Core documentation
, I discovered that the implementation process is surprisingly straightforward and beginner-friendly!

This walkthrough has been simplified to give a clear overview of how ORM works and how to apply it to your .NET project.

Below are the libraries you’ll need to add in order to integrate ORM into your .NET development workflow:

1. Microsoft.EntityFrameworkCore
This is the main ORM library for C#/.NET projects, This library
provides the core features of Entity Framework, including model
creations and data access in our C#/.NET projects

2. Npgsql.EntityFrameworkCore.PostgreSQL
This is our PostgreSQL provider library for Entity Framework Core. It allows our ORM setup to communicate with our PostgreSQL database.

3. Microsoft.EntityFrameworkCore.Tools
This library provides useful command-line tools that help in managing migrations, scaffolding, and database updates directly from your terminal. It’s especially handy for generating models and applying schema changes without writing manual SQL commands.

Once these packages are installed (either through the NuGet Package Manager in Visual Studio or via the .NET CLI), you’re ready to start setting up your ORM structure!

Step 1: Setting Up Your Data Model

Let’s start by creating a simple model class to represent our database entity.
For example, in a music player app, we might have a Song model:

public class Song
{
    public int Id { get; set; } 
    public string Name { get; set; } 
    public string Artist { get; set; } 
    public string Album { get; set; } 
    public int DurationInSeconds { get; set; }
}

This class will serve as our schema for the database table. Entity Framework will map this model to a Songs table in PostgreSQL automatically.

Step 2: Creating the Database Context

Next, we’ll define a DbContext, which serves as the bridge between your C# code and the database.

using Microsoft.EntityFrameworkCore;

public class MusicDbContext : DbContext
{
    public DbSet<Song> Songs { get; set; }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.UseNpgsql("Host=localhost;Database=musicdb;Username=postgres;Password=yourpassword");
    }
}

The DbSet<Song> represents your table, and the connection string inside OnConfiguring points to your PostgreSQL database. You can change the musicdb to your database name , Username and Password to your own too!

Step 3: Running the Initial Migration

After defining your model and context, it’s time to generate and apply the migration to create the database schema.

Run these commands in your terminal:


dotnet ef migrations add InitialCreate
dotnet ef database update

migrations add creates a migration file that defines your database structure. InitialCreate can be changed to your desired name of the addition.
database update applies the migration to your PostgreSQL database.

Step 4: Performing CRUD Operations

Once your database is ready, you can now perform Create, Read, Update, and Delete operations directly from your C# code using Entity Framework Core.

Create (Inserting Data)

using (var db = new MusicDbContext())
{
    var newSong = new Song 
    { 
        Name = "Landslide", 
        Artist = "Fleetwood Mac", 
        Album = "Fleetwood Mac", 
        DurationInSeconds = 220 
    };
    db.Songs.Add(newSong);
    db.SaveChanges();
}

Explanation:

db.Songs.Add(newSong) tells Entity Framework to add a new record into the Songs table.
db.SaveChanges() commits the changes to the database.
This is how you insert data without writing a single SQL INSERT statement!

Read (Retrieving Data)

using (var db = new MusicDbContext())
{
    var songs = db.Songs.ToList();
    foreach (var song in songs)
    {
        Console.WriteLine($"{song.Name} by {song.Artist}");
    }
}

Explanation:

db.Songs.ToList() retrieves all records from the Songs table and stores them in a list.
You can then loop through the results and display or process them as needed.
This is equivalent to running SELECT * FROM Songs; in SQL.

Update (Modifying Data)


using (var db = new MusicDbContext())
{
    var song = db.Songs.FirstOrDefault(s => s.Name == "Landslide");
    if (song != null)
    {
        song.Album = "The Dance";
        db.SaveChanges();
    }
}

Explanation:

FirstOrDefault searches for the first song record with the name “Landslide.”
Once found, we modify its Album property.
db.SaveChanges() applies the update automatically in the database.
This works just like a SQL UPDATE statement, but handled fully in C#.

Delete (Removing Data)

using (var db = new MusicDbContext())
{
    var song = db.Songs.FirstOrDefault(s => s.Name == "Landslide");
    if (song != null)
    {
        db.Songs.Remove(song);
        db.SaveChanges();
    }
}

Explanation:

We fetch the target record first, then call db.Songs.Remove(song) to mark it for deletion.
Finally, db.SaveChanges() removes the record permanently from the database.
This is equivalent to running DELETE FROM Songs WHERE Name = 'Landslide'; in SQL.

Final Thoughts

By using Entity Framework Core, we’ve replaced complex SQL statements with clean, object-oriented C# code. This makes database interactions safer, easier to read, and much more maintainable, especially as your project grows.

Whether you’re developing a large-scale enterprise app or a small hobby project like my indie TUI music player, integrating ORM through EF Core can drastically simplify your database workflow.

Thank you for reading, do give out your feedback and comments for further improvements of my articles writing! Happy weekend :)

How to make loops in Common Business-Oriented Language (COBOL)

Raziq Din — Sat, 20 Sep 2025 21:06:41 +0000

Hello everyone! In this article, we will explore how to create loop statements in Common Business-Oriented Language (COBOL). Again , a couple of twists and turns when it comes to this language (that's why I write a lot about this language haha).

For starters, COBOL does not have direct for or while loops. Instead, it uses the PERFORM statement to handle loops. COBOL can implement loops similar to:

Count-controlled loops (similar to for loops)
Condition-controlled loops (similar to while loops)

First, Let's go through Count-controlled Loops , a loop similar to For-Loop.

1. Count-Controlled Loops (For Loop)

Let's go through the fundamental part of the code snippet!

1.1 User Input Field

DISPLAY "Enter a number between 1 and 10: ".
ACCEPT userInput.

This is how we get input from the user in COBOL. The DISPLAY statement shows a message on the terminal, prompting the user to enter a value. The ACCEPT statement then reads the input from the user and assigns it to the variable userInput. In this example, userInput is defined to store integer values.

1.2 PERFORM VARYING STATEMENT


 PERFORM VARYING COUNTER FROM 1 BY 1 UNTIL COUNTER > userInput
    DISPLAY "Hello World " COUNTER " times."
 END-PERFORM.

This is how we do a 'for loop' in COBOL. Below are the orders:-

PERFORM VARYING is the first statement needs to be made to make a for loop in COBOL. It is used to run a block of code (eg. this for loop) in the main program.

VARYING will introduce a loop controlled variable that will change on each iteration. In this case , VARYING will change the value on COUNTER variable on each iteration. We are technically saying "VARYING is modifying COUNTER values on each loop".

COUNTER is the loop control variable. The value of COUNTER will change on each iteration. From this snippet, COUNTER will start from 1.

FROM 1 specifies the starting value of the loop control variable. From here , COUNTER starts from 1.

BY 1 specifies the increment value for each iterations of the loop. The code explains that COUNTER increases by 1 for one iteration.

UNTIL COUNTER > userInput is the exit condition of the loop. The loop will continue until the value of COUNTER is more than userInput value that we set. After that , the loop stops.

DISPLAY "Hello World" COUNTER "times" prints the message once per loop, showing the current value of COUNTER each time, until COUNTER exceeds userInput.

END-PERFORM closes the loop and tells COBOL where the repeated statements stop in the program!

Output

(NOTE: the Enter a number between 1 and 10: is an input field , I typed in 10 lol)

So there you have it! This is how you do a Counter-Controlled Loop , technically a For-Loop. Now , let's move on to another half of the article , a while loop or in COBOL terms, Condition-Controlled Loop!

2. Condition-Controlled Loop (While Loop)

Pretty similar to Counter-Controlled Loop right? Well , the algorithm is pretty much the same, through identification and declaration of variables. Let's jump to the keyword that enables the program to perform a Condition -Controlled Loop.

2.1 PERFORM UNTIL COUNTER > 10

 PERFORM UNTIL COUNTER > 10

           DISPLAY "Counter count: " COUNTER

           ADD 1 TO COUNTER

           END-PERFORM.

A definite explanation is down below!:

UNTIL is a unique keyword to enable COBOL program to perform Condition-Controlled Loop. This keyword is used to compare the current value of COUNTER to the value 100. In this case , we made a condition that the operation will perform the display message until the value of COUNTER is more than 100. If COUNTER value is more than the value 100, the loop terminates and display operation will stop.

Output

This is the only difference between these 2 loops in COBOL!

Key Takeaways

COBOL doesn’t have for or while keywords, but PERFORM covers both use-cases cleanly.
Choose PERFORM VARYING when your loop is strictly numeric and predictable.
Choose PERFORM UNTIL when the loop should continue until some business rule or external condition is satisfied.

Thank you very much for your time to read this! Stay tuned for more COBOL series and share us your thoughts and recommendations to further improve this series!

How To declare , define and display a variable in Common Business-Oriented Language (COBOL)

Raziq Din — Thu, 04 Sep 2025 21:19:54 +0000

Hello everyone! This article will guide you on how to declare and define variables in Common Business-Oriented Language (COBOL), while also explaining the logic and meaning behind each keyword used. Variable declaration in COBOL may differ from other programming languages, as it includes some special setter conditions such as initial values, conditions, or constraints in defining how the variables behave , so it’s important to understand why certain keywords exist and how they shape the structure of the program.

Take a look at this code snippet as an example , I will explain little by little!

Code Snippet Examples:

You may find some unusual keywords that you may not find in other compiled languages like C++ or Java for instance, but once you understand it, it will be simple.

Let's go through the new division headers that we haven't covered from our previous article! If you found some of these syntax unfamiliar , do check out my previous ones where I covered about the fundamental components in COBOL here.

Without further ado , let's go!

1. DATA DIVISION


 DATA DIVISION.
  *> defines the variables that are used in the program for data processing
  *> this section is where all data that will be used in the program is defined

DATA DIVISION is used to define all the data items required by the program. It specifies the variables, constants, and file structures that the program will use during execution. In other words, this division acts as the program’s data dictionary, where every piece of data to be processed must first be declared.

2. WORKING-STORAGE SECTION


  WORKING-STORAGE SECTION.
   *> describes data records that is new and unknown to the file
   *> describe data types whose values are assigned in the source program and do not change the execution of the object program

The WORKING-STORAGE SECTION is part of the DATA DIVISION where programmers declare variables and data items that exist for the entire duration of the program. These data items are created when the program starts and remain available until it ends. They are mainly used to hold temporary values, counters, flags, and constants.

3. 01 userName PIC X(20) VALUE "John Doe".


 01   userName  PIC X(20) VALUE "John Doe".
   *> declare a variable named "userName" 
   *> assign it a value named "John Doe" by putting VALUE keyword before the value

Let's break this into lists of orders (because it's gonna be quite long haha :D)

01 is a level number. It indicates that userName variable is a top-level variable. Whenever you want to declare a new variable , you have to add 01 before naming your variable.
userName is the variable name. You can name it however you want!
PIC is a picture , it tells COBOL ecosystem what kind of data that can be stored in this variable.
X(n) is a condition that enables the variable to accept letters, numbers , symbols as a value. Using X is preferable as it is more flexible!
(20) means the maximum length is 20 characters.
VALUE "John Doe" assigns a default initial value to the variable at program start. In this case, userName will be filled with "John Doe" followed by spaces until the length is 20.

4. 01 userAge PIC 9(3) VALUE 30.


 01   userAge      PIC 9(3)  VALUE 30.
   *> declare a variable names "userAge"
   *> assign a value 30

In this code , we are now declaring and defining a numeric variable!

Explanation:

PIC 9(n) defines a numeric field of length n digit. Each position can store one digit (0–9).
(3) means the variable can store up to 3 digit (000 - 999).
VALUE 30 initializes the variable with the value 30. Since the field length is 3, COBOL automatically stores it as 030 (leading zero added). If we set the variable value to 100 , COBOL will store it as 100 (no 0 at the front as 100 fulfills the 3 digit length!)

5. 01 userAddress PIC X(60) VALUE "United States".


  01   userAddress  PIC X(60) VALUE "United States".
   *> declare a variable names "userAddress"
   *> assign a value "United States"

We apply the same steps that we did for userName variable! But just for a change:

(60) is the new length for the value of this userAddress variable. We sets the maximum length of the variable to 60 characters.
VALUE "United States" , this initializes the variable with the string United States. COBOL will pad the remaining unused positions with spaces until the total length is 60.

6. DISPLAY ourVariable

PROCEDURE DIVISION.


  DISPLAY "below is your full information:".
  DISPLAY userName.
  DISPLAY userAge.
  DISPLAY userAddress.
   *> DISPLAY the variable that we have declared and defined in WORKING-STORAGE SECTION.


EXIT PROGRAM.

In the PROCEDURE DIVISION, we use the DISPLAY statement to output the values of the variables defined in the WORKING-STORAGE SECTION.

Below are the results from our snippet!

Expected Output:

And there you have it! The output above are the values that we defined from the variables. Therefore , that is how we declare, define and display variables and its values in COBOL.

Thank you for your time. If there is any suggestions, feedbacks, recommendations, do let me know and share in the comments below! See you soon!

How to print "Hello World" in COBOL (Common Business-Oriented Language)

Raziq Din — Wed, 27 Aug 2025 07:36:49 +0000

For my very first post on this platform, I’ll be guiding you through a simple “Hello World” program in COBOL, while also giving a quick breakdown of the key syntax you’ll need to make it work.

But before we dive into the code, let’s take a step back and look at COBOL’s origins, and why it still powers over 70% of legacy systems in critical sectors like finance, banking, and beyond.

What is COBOL?

Common Business-Oriented Language a.k.a COBOL is a high-level , English-like compiled programming language that is developed specifically for business data processing needs.

What led to the founding of COBOL?

In the late 1950s , each operating systems that has existed at the time has it's own programming languages. However , this somehow leads to hurdles between companies as they had to work with systems of numeral brands and made cross-company data processing difficult. Grace Hopper(1906-1992), one of the pioneers in the Computer Science field, saw this issue and therefore created the early version of the language called FLOW-MATIC to simplify business programming tasks, which later inspired Conference on Data Systems Languages (CODASYL) to create COBOL programming language. Ever since then, COBOL was integrated and used by thousands of companies all around the world, producing over 800 billion of legacy code that is consistently maintained by the people in the country all around the world until now.

Is COBOL still in use in the field today?

Well, to put this in to perspective, you are using part of COBOL's several code snippets every time you wave your debit or credit card when you want to make a payment at any stores or shops. So yes, it is being used and relevant until this day.

COBOT "Hello World" Code Snippet

The code snippet below is the full code snippet and required syntax to print a basic "Hello World". Let me guide you slowly as you cannot skip any order based on the code here, as it holds strong functionality and purpose for the program to run.

       IDENTIFICATION DIVISION.


       PROGRAM-ID. helloworld. 


       PROCEDURE DIVISION.


       DISPLAY "hello world".


       STOP RUN.

Pretty simple, right? Yes it is. That’s because COBOL was designed to make programming easier by using an English-like syntax. This approach ensures that programs are easier to read, write, and maintain, even for those who aren’t professional programmers!

Now, let's go through all the fundamental syntax and it's purpose to make the program runs smoothly.

1. IDENTIFICATION DIVISION

IDENTIFICATION DIVISION

 *> should be coded first as the first division in cobol program
 *> provides metadata about the program , such as its name , author , components required to make the cobol ecosystem recognize the syntax
 *> mandatory division in COBOL program

IDENTIFICATION DIVISION. is the first mandatory component in the COBOL program that provides documentary information , including the property of the program itself such as the name and the type of program. The syntax will recognize the date compiled , author or any relevant info about the program in the ecosystem. Take this syntax as the initializer of the whole program in your COBOL file , or simply put , a "cover page" of the program.

It does not disturb the program logic or your main COBOL code. So don't worry lol. Check out the extended example below as you can add this info to your code after IDENTIFICATION DIVISION.

Extended Example

IDENTIFICATION DIVISION.

*> below are the info about this COBOL program

PROGRAM-ID. PayrollSystem.
AUTHOR. Raziq Din.
INSTALLATION. Hospital Kuala Lumpur.
DATE-WRITTEN. August 2025.
REMARKS. Handles employee payroll and deductions.

2. PROGRAM-ID.


PROGRAM-ID. helloworld. 

*>  used to specify the program name
*>  mandatory and should be in the first entry after the IDENTIFICATION DIVISION.
*>  helloworld. is user defined alphanumeric word that identifies the program uniquely
*>  take it like a unique id for each program to make it unique

PROGRAM-ID is a required syntax after declaring IDENTIFICATION DIVISION. in your program. This is the syntax that will identify your program name uniquely. You are free to name it however you want BUT , there are certain rules:-

Length:
up to 30 characters only for a program name.

Characters:
the name must consists from alphabets (A-Z,a-z), digits (0-9), hyphens (-) or underscores (_).

Alphabetical Requirements:
At least one character in the name must be in alphabetic and the first character must be in alphabetical

Underscore Restrictions:
Cannot be at the start or end of the program name

Hyphens Restrictions:
Cannot be at the start and end of the program name

Reserved COBOL words:
Avoid using it , like really , it might cause conflict (e.g MOVE , IF)

Uniqueness:
Your program name must be different in each COBOL file, when you work with multiple COBOL files , you will need to rename it uniquely

3. PROCEDURE DIVISION.

PROCEDURE DIVISION.
  *>  defines the all operations that will be written in the cobol file

PROCEDURE DIVISION. holds that whole logic of COBOL program. This syntax will operate on the data that was defined in the DATA DIVISION. (will talk about it after this) and uses a structured format based on sections , paragraphs, or statements. Since COBOL language is procedural programming based language , the program will usually run from the top line until the last line (from top to bottom).

4. DISPLAY "Hello World".

DISPLAY "hello world".
 *>  output the string "hello world" to the terminal

DISPLAY means output. I mean , it literally mean output. To your Command Line Interface (CLI). Yes. You write DISPLAY and include your "yourmessage" after it.

5. STOP RUN.

STOP RUN.
*>  terminate the program

STOP RUN. will end your program runtime.

Expected Output

Here is the output expected from your terminal:

So there you have it, a "Hello World" display program. Now that you’ve read through it, it’s essential to understand that COBOL syntax relies on specific keywords, each carrying a very particular purpose. Missing or misplacing even one can cause the program to fail.

That said, this strict structure is also what makes COBOL so reliable for business-critical applications. Once you grasp the fundamentals, like IDENTIFICATION DIVISION, PROGRAM-ID, PROCEDURE DIVISION, and statements such as DISPLAY and STOP RUN , you’ll have the foundation to explore more advanced COBOL features, from handling data files to building complete business systems.

Hope you enjoy the reading! Apologies for any little misinformation! I'm happy to learn more!