Forem: Uthsob Chakraborty

How I made my own Operating System (OS)

Uthsob Chakraborty — Sun, 05 Oct 2025 12:01:01 +0000

I made my Own Operating System named “NO OS”; Here is the log of NO OS.

Why is this done?

The main reason behind building NO OS is learning.

In our Operating System course, we were told that the best way to understand how an OS really works is to try building one. While NO OS is not a fully functional operating system, it helps in understanding:

Boot process: how a CPU starts and how the control passes from bootloader → kernel.
Kernel basics: setting up memory, stack, and jumping into C code from assembly.
Memory management: simulating frame allocation, freeing memory, and showing system usage.
Low-level programming: working without libraries, writing directly to hardware like VGA text memory.

For programmers (especially students like me), it’s very easy to forget what we were trying to do after a few weeks/months.

That’s why documenting why this project exists is almost more important than the code itself — so future contributors (or even my future self) know the intention:

This project is not meant to be a production OS, but a playground for learning OS concepts step by step.

What is this?

Imagine turning on your computer: you see the screen light up, the operating system loads, and then you can open apps, browse the internet, or play music.

NO OS is a baby version of that idea.

But instead of doing all those complicated things, NO OS only does two very simple things right now:

Shows text on the screen — so the system can "say hello" when it starts.
Manages memory in a toy way — like keeping track of which parts of your desk are empty and which parts are already used.

That’s it. NO OS doesn’t run apps, doesn’t connect to the internet, and doesn’t have graphics. It’s called “NO OS” because it’s really a Non-Operational Operating System, a joke name to remind us that it doesn’t do much yet.

But it’s a stepping stone: with this base, future improvements like adding keyboard input, handling files, or running small programs could be built.

So for someone who has never programmed:

Think of NO OS as a blank notebook with the first two pages written.
It doesn’t have stories yet, but the notebook is ready for you (or others) to start filling it.

Background:

In this semester (Summer 2025), I got the course Operating System. And in the Lab of same course we required to build a project. Our Faculty said - "If you really want to understand how a Operating System Works you should build it." So here i'm building my own Operating System called "NO OS";

Just like the name suggests, No OS has no work. It’s truly “Non Operational” OS. But what i learned from building this-

Firstly we need to know what a Operating System is and what it does-

Definition: A operating System is a system software that manages computer hardware and software resources, providing common services for computer programs.

Work:

An Operating System basically does following works;

Resource Management
Process Management
File Management
User Interface
Input/Output (I/O) Management
Security

But building such a fully working OS with all functions is very hard; especially single-handedly and when you have time constrains and you also have other work and personal life. So in that meantime possibly i built tiny portion or base of a Operating System.

Here is how NO OS works and what it does-

First look at the file structure. We have following files;

NoOS/
├── bochsrc.txt
├── iso/
│   └── boot/
│       └── grub/
│           └── grub.cfg
├── kernel.c
├── link.ld
├── loader.s
├── Makefile
├── memory.c
├── memory.h
├── README.md
└── types.h

Here in if you look at the github repo you’ll find the boot-loader folder as well; i thought about creating the boot loader from scratch but didn’t have the courage to build that too. So just used grub.cfg that just points to boot from /boot/kernel.elf file; Oh also speaking of grub we used Bochs to emulate and run our OS in development mode. That's what the configuration file kept in bochsrc.txt it simulates an x86 architecture PC. In out config we just pointed and gave 32 Megabyte (MB) of RAM and uses SDL as display library to display.

Loader Script: Anyway, loader.s It’s the real entry point for this operating system after the boot-loader (GRUB) passes control to the kernel. This file takes care of the low-level setup before calling C kernel code. This is assembly code that normally has 4 core responsibilities-

Multiboot Header:
Stack Setup:
Calls the Kernel:
Halts the CPU:

global loader

extern kernel_main

MAGIC_NUMBER equ 0x1BADB002     
FLAGS        equ 0x0            
CHECKSUM     equ -MAGIC_NUMBER  

section .text
    align 4                     
    dd MAGIC_NUMBER             
    dd FLAGS                    
    dd CHECKSUM               

loader:
    mov esp, kernel_stack_top      ; Set up the stack pointer
    call kernel_main               ; Call the C kernel entry point

    cli                            ; Disable interrupts
.hang:
    hlt                            ; Halt CPU
    jmp .hang                      ; Infinite halt loop

section .bss
    align 4
    kernel_stack_bottom:
        resb 16384                 ; Reserve 16KB for the stack
    kernel_stack_top:

Kernel and Memory Management:

Kernel is the MAGIC file the core of an OS. It’s the main file that does all the magic of a OS in the behind. Including all the core job of OS. The NO OS kernel is written in C.

As i have explained what are the issue for me to build a full kernel. But to call it a OS i have included only 3 things.

Managing or Showing Output/Display Management.
User Interface though just static
And Memory Management (to be specific how it’s allocating memory)

Let’s discuss on more detailed about each one;

As its allocate memory so i have created a separate code file for manage memory on memory.c and memory.h that simulates-

Physical memory frame allocation using bitmap
Simple heap allocator for kernel memory
Memory information display

void *allocate_frame(void)
{
    for (uint32_t i = 0; i < pmm.total_frames; i++)
    {
        uint32_t byte = i / 32;
        uint32_t bit = i % 32;

        if (!(pmm.bitmap[byte] & (1 << bit)))
        {
            pmm.bitmap[byte] |= (1 << bit);
            pmm.used_frames++;
            return (void *)(i * FRAME_SIZE);
        }
    }
    return NULL; // Out of memory
}

This function is a helper function for frame allocation

and then this code check the Free frame-

void free_frame(void *frame)
{
    uint32_t frame_num = (uint32_t)frame / FRAME_SIZE;
    uint32_t byte = frame_num / 32;
    uint32_t bit = frame_num % 32;

    pmm.bitmap[byte] &= ~(1 << bit);
    pmm.used_frames--;
}

And this is for the UI to show memory information. and finally get the free memory block.

void show_memory_info(void)
{
    uint32_t free_mem = get_free_memory();
    printf("Memory Info:\n");
    printf("  Total: %d KB\n", pmm.memory_size / 1024);
    printf("  Used:  %d KB\n", (pmm.memory_size - free_mem) / 1024);
    printf("  Free:  %d KB\n", free_mem / 1024);
    printf("  Frames: %d total, %d used\n", pmm.total_frames, pmm.used_frames);
}

uint32_t get_free_memory(void)
{
    return (pmm.total_frames - pmm.used_frames) * FRAME_SIZE;
}

All these memory management code come handy to current memory management simulation and future memory related task.

Let’s get back to the kernel.c-

#include "types.h"
#include "memory.h"

#define VGA_WIDTH 80
#define VGA_HEIGHT 25
#define VGA_MEMORY 0xB8000

static uint16_t *vga_buffer = (uint16_t *)VGA_MEMORY;
static size_t vga_row = 0;
static size_t vga_column = 0;
static uint8_t vga_color = 15;

void clear_screen(void);
void putchar(char c);
void print(const char *str);
void printf(const char *format, ...);
void print_number(uint32_t num);
void print_hex(uint32_t num);
void demonstrate_memory_operations(void);

On the entry of the kernel we just called all the required function including memory file; And then defined our UI/display size with VGA (Video Graphics Array) that does the display management and the basic display usage. How it shows with the display are in code if you read it carefully you will understand. And then finally the UI; So to make it minimal kept just as CLI UI

void kernel_main(void)
{
    clear_screen();

    print("====================\n");
    print("  Welcome to NO OS!\n\n");
    print("====================\n");
    print("This is NO OS that has no work! That does nothing currently but simulate-\n");
    print("- Display text on screen\n");
    print("- Handle basic memory management\n");
    print("\n");

    print("Initializing memory manager...\n");
    init_memory_manager(32 * 1024 * 1024);
    print("Memory manager initialized successfully!\n\n");

    demonstrate_memory_operations();

    print("\nSimulation of Memory management!!\n");
    print("Debug: NoOS is running successfully! The system is alive and operational.\n");
    while (1)
    {
        asm volatile("hlt");
    }
}

As there is no code implemented to interrupt handling here so it’s just static screen showing basic UI and dynamic memory allocation part. Here is a screenshot of the working NO OS.

That’s the whole overview of NO OS;

Makefile and Linker:

As we have left with these 2 file now lets discuss about them briefly.

link.ld tells the linker how to arrange the kernel binary in memory, sets the load address to 1MB, aligns sections to 4KB, and specifies the entry point so the OS boots and runs correctly.

and then the Makefile is the custom make command that creates the ISO, it has some other commands to clean, run and generating the ISO.

Totally completed the system.

OHHH
**

Contribution

NO OS is a learning project, and there’s a lot of room to grow. If you’re interested in operating system development or just want to experiment with low-level programming, you’re welcome to contribute!

Here are some ideas for contributions:

Add Interrupt Handling – implement a simple Interrupt Descriptor Table (IDT) and handle basic hardware interrupts (keyboard, timer).
Improve Memory Management – extend the frame allocator into a proper paging/virtual memory system.
Scheduler – add process structures and a round-robin (or any) scheduling algorithm.
Filesystem – experiment with a basic in-memory filesystem or integrate FAT12/16 for disk I/O.
Drivers – simple keyboard, timer, and screen drivers.
Documentation & Tutorials – improve explanations, add diagrams, or create step-by-step setup instructions for beginners.

If you’d like to contribute:

Fork the repository. — https://github.com/uthsobcb/NoOS
Open a Pull Request.

Understanding Web Servers by Building One in C

Uthsob Chakraborty — Mon, 02 Jun 2025 16:18:47 +0000

Web servers — the magical thing.
Is it really magical? Pretty much, yes. But let’s break down this magic today. For fun, I’ve built a basic one using C and the socket library. You can find the backstory and full code here.

Before diving into code, let’s first understand: what is a web server?

By reading this blog, you're already interacting with a web server — specifically, the one hosting this blog. But how does it actually work?

When you access this page through a browser, communication happens over HTTP (Hypertext Transfer Protocol).
Your browser sends a request to a remote cloud server where the blog is hosted.
The web server receives that request and responds with content — like an index.html or blog.html file.

This process is built on two main protocols:

TCP/IP – for establishing connections and transmitting data.
HTTP – for structuring the exchange of web content (pages, APIs, etc.).

Sounds pretty simple, right?
But what’s happening under the hood?

Let’s explore this using a real example — a web server built using C. You can find the full code in the repo:
https://github.com/uthsobcb/esspress

Note: This server doesn’t use a real database — it reads from a .txt file as a data source.

Setting Up: Required Libraries

Since we’ll interact with HTTP, sockets, and the network layer, we need to include the following C standard libraries:

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<unistd.h>

1. Preparing the Response

The server serves an HTML file (index.html) as the homepage. First, we open the file, read its content, and attach it to a basic HTTP 200 response header.

FILE* html_data;
html_data = fopen("index.html", "r");

char response_data[1024];
fgets(response_data, 1024, html_data);

char http_header[2048] = "HTTP/1.1 200 OK\r\n\n";
strcat(http_header, response_data);

This builds a minimal HTTP response like:

HTTP/1.1 200 OK

<html>...</html>

2. Setting Up the Server

In this part, we define the server socket, specify the IP and port, and bind it to the machine:

int server_socket;
server_socket = socket(AF_INET, SOCK_STREAM, 0);

struct sockaddr_in server_address;
server_address.sin_family = AF_INET;
server_address.sin_port = htons(8001);
server_address.sin_addr.s_addr = INADDR_ANY;

Then bind the socket and start listening for connections:

bind(server_socket, (struct sockaddr *) &server_address, sizeof(server_address));
listen(server_socket, 5);

Look closely at this line:

server_address.sin_port = htons(8001);

We're serving the web on port 8001.

3. Receiving Requests and Sending Responses

Inside an infinite loop, the server accepts incoming client connections and responds based on the requested path.

For example, if the browser sends a request for /, we return the HTML page:

if (strncmp(request_buffer, "GET / ", 6) == 0) {
    send(client_socket, http_header, strlen(http_header), 0);
}

Similarly, when the client requests the /data path, we read data from a db.txt file and send it as plain text:

else if (strncmp(request_buffer, "GET /data", 9) == 0) {
    FILE* db_file = fopen("assets/db.txt", "r");
    ...
    send(client_socket, data_response, strlen(data_response), 0);
}

And if the path is unknown, we send a standard 404 response.

Final Thoughts

This isn’t a production-ready server — it’s a learning project. But it does give you a crystal-clear understanding of how a browser talks to a server, how requests are handled, and how responses are structured.

If you've made it this far, congrats — you now understand the core mechanism behind every website you’ve ever visited.

Feel free to clone, run, and even improve the project:
https://github.com/uthsobcb/esspress

I Built an AI-Powered Journaling App That Understands Your Emotions — Meet Echo ☁️

Uthsob Chakraborty — Fri, 11 Apr 2025 15:04:04 +0000

Hey devs 👋

After months of building solo, I just launched my passion project — it’s called Echo, and it’s an emotional journaling app that adapts to how you feel.

Let me tell you the story.

🧠 Why I Built Echo

A few months ago, I hit a rough patch — burnout, overwhelm, total emotional fog. I stepped away from social media and started writing again. Just raw thoughts, emotional check-ins, mood scribbles. And it helped.

But the more I journaled, the more I realized how disconnected digital tools were from real human feelings.

So I built Echo — a journaling space that feels like it’s listening.

☁️ What Is Echo?

Echo is a journaling app with a twist:

It features an emotional AI companion — a small, fluffy cloud — that reflects your moods visually and grows with your entries.

✨ Features:

Emotion-aware journaling prompts
Mood tracking that adapts to your patterns
Visual cloud that shifts shape based on your check-in
AI insights from your writing (totally private, unless you opt-in for research)

- Clean UI, privacy-first design, no selling data

⚙️ How I Built It

Stack:

Frontend: Next.js, TailwindCSS
Backend: MongoDB, NextAuth, Gemini API
AI: Gemini API
Mood logic: Lightweight NLP + rule-based scoring, integrated with visuals
Hosting: Vercel, Resend for transactional emails
Image upload: ImgBB

And yes — I did it all solo. From UX to backend routes, from modal animations to content writing.

💬 What Makes It Different?

Most journaling apps either feel too clinical (like mental health checklists) or too plain (just a textarea).

Echo bridges the gap. It's expressive. It's private. And it treats journaling like a relationship — between you and your mind.

🚀 It’s Live on Product Hunt

I just launched Echo on Product hunt:

👉 https://www.producthunt.com/posts/echo-e657689c-f521-42ce-9dec-904ae6fd47ac
Though Echo, couldn't gain lot of upvote or many user from product hunt (i will erite about this later) But still product hunt is a way to reach me If it resonates, I’d love your feedback, support, or just a kind word. Launching something solo is scary. But it’s also what makes it special.

Thanks for reading! If you’ve ever thought of journaling — or building something that blends empathy + code — I’d love to chat.

buildinpublic #mentalhealth #ai #nextjs #solodev #echoapp

Creating an IoT Device Frontend: A High-Level Overview

Uthsob Chakraborty — Sun, 27 Oct 2024 18:27:52 +0000

Recently, I had the opportunity to work on a university project focused on building a Smart Dustbin. Although I can't share specific code snippets or show the actual device nor the frontend screenshot due to project restrictions, I’m excited to provide a high-level overview of how the project was structured, the technologies we used, and the challenges we faced. Below, you’ll find the high-level architecture that guided our work:

Project Overview

The idea behind the Smart Dustbin is simple yet powerful: to create an intelligent waste management system that monitors the fill level of a dustbin, measures various environmental parameters, and alerts stakeholders when the dustbin needs to be emptied. Here's how we approached the project.

Tech Stack Breakdown

Our project was divided into three main components: the IoT device, the server, and the frontend dashboard. Let’s dive into the details of each component:

1. IoT Device

The IoT device was designed and managed by a friend of mine, who did a fantastic job handling the hardware aspect of the project. Here's what was involved:

Hardware: We used a NodeMCU microcontroller, which provides built-in Wi-Fi support, making it ideal for connecting to the MQTT server.
Programming Language: The entire code for the device was written in C++.
Data Transmission: The NodeMCU collected data such as trash level, gas concentrations (CO2, O2, NH4), and GPS coordinates. This data was then sent to an MQTT server over a wireless connection.

2. Server

The server played a pivotal role in our project. Its main functions were to manage real-time data, store it in a database, and communicate with the frontend.

Server Setup: We used Node.js to build the server, which allowed us to handle multiple connections efficiently.
Real-Time Communication: For real-time data updates, we leveraged Socket.IO, enabling the server to push data directly to the frontend.
Database & Authentication: We chose Firebase as our backend service for both data storage and authentication. Firebase's flexibility allowed us to store sensor readings and manage user authentication seamlessly.

3. Frontend

The frontend was the core of the project, where most of the data visualization and user interactions were handled. It involved extracting meaningful data from server responses and presenting it in a user-friendly manner.

Data Handling: The server sent a string of data through MQTT and Socket.IO. I extracted the necessary information and stored it in variables for further processing.
Data Visualization: The data received from the device and server included:
1. Level of Trash: Displayed using a gauge meter to visually represent how full the dustbin was.
2. Coordinates (Latitude and Longitude): Used to pinpoint the exact location of the dustbin on a map.
3. Gas Levels (CO2, O2, NH4): Each gas level was shown in separate sections using individual gauge meters for clarity.
Key Functionalities:
- Trash Level Monitoring: The trash level was constantly checked to see if it exceeded 75%. If it did, an automated email was triggered to notify the relevant parties, including the current location of the dustbin.
- Mapping: Using the Leaflet.js library, I integrated the latitude and longitude data to display the dustbin's location on an interactive map using OpenStreetMap.
- Gas Monitoring: Each gas sensor reading was visualized using distinct gauges to allow easy monitoring of environmental parameters.

Challenges and Solutions

Parsing String Data: The server sent data as a single string, so I had to develop custom logic to parse it and extract each data type (trash level, coordinates, gas levels). Careful parsing was crucial for maintaining data accuracy.
Real-Time Updates: Displaying real-time data while ensuring smooth user interaction was challenging. Leveraging Socket.IO allowed me to deliver instantaneous updates without affecting the UI's responsiveness.
Visualizing Sensor Data: Making sensor data comprehensible required well-thought-out visual elements. Using gauge meters provided an intuitive way to present real-time changes, especially for trash levels and gas concentrations.

Results and Achievements

The final product was a fully functioning Smart Dustbin system that provided live updates on the trash fill level, monitored various environmental parameters, and used map integration to show its exact location. Here's a summary of what we achieved:

Here is how it looks. As i mentioned earlier i can't really add device picture nor the code.

Live Data Monitoring: Real-time monitoring of trash levels and gas concentrations.
Automated Alerts: Email notifications when the trash level exceeded a certain threshold.
Geolocation Tracking: Real-time location updates of the dustbin on an interactive map.
User-Friendly Dashboard: A clean and informative UI that made it easy to monitor and manage data.

Conclusion

This project was a fantastic opportunity to work with real-time data and build an IoT application from the ground up. It provided valuable hands-on experience with technologies like MQTT, Node.js, Socket.IO, Firebase, and React. Each component brought unique challenges, but by leveraging the strengths of each technology, we were able to create a seamless system that effectively managed and displayed real-time IoT data.

Building a Smart Dustbin might sound simple, but the complexity lies in ensuring all the moving parts work together efficiently. It was an enriching project, and I hope this overview gives you an idea of how you can approach similar IoT projects with a real-time data focus.

How to find problem in Codeforces

Uthsob Chakraborty — Sun, 24 Dec 2023 09:55:17 +0000

Hello, nice people! How are you? I hope everything is well.

As a programmer, I hope you are already familiar with Codeforces. If you don’t know about Codeforces, well, it is an online judge where you can find and solve programming problems by running your code. The online judge will then display the result, and this is the primary function of an online judge. Codeforces is a popular online judge, boasting over 14000 registered Bangladeshi problem solvers.

When you visit Codeforces problemset, you will find a list of all problems. If you are a beginner in problem-solving and come across a problem, you might feel intimidated by programming. However, don't worry because you may encounter challenging problems as well as easier ones. While you're here, you don't need to feel tense because we are here to help you.

Now, let's get to the main point. When you visit Codeforces problems, you will initially find them in the default order.

To make it easier, you can sort these problems in three ways.

Way 1: Difficulty Sorting:

Click here, and you will find problems sorted by difficulty. Initially, it will display hard to easy problems. Check the problem difficulty; if it is <3500, it is considered a hard problem. Click the sign again, and it will arrange them from easy to hard. Now you can find a suitable problem for you.

Way 2: Sorting by Most Solved:

Click here, and it will sort problems by the most accepted solutions by users. If many people have tried a problem, it might be easier. This way, you can find a suitable problem for you.

Way 3: Sort with Rating and Tags:

In the first blank box, you can input the minimum rating of the problem, and in the second box, you can input the maximum rating of the problem. For example:

You can also add tags for topics you have recently learned, such as math, binary search, dp, etc.

I hope these methods will help you find a problem that suits your skill level. Now you can start solving problems. Don't give up, and best of luck!

Happy_Problem_Solving

August 2019

[Important Footnote: This note/article was written in 2019; when i started my coding journey. So my written was not polished and did lot of mistake back then. I haven't got any time to rewrite this article. So posting all this in this forum blog post. I believe still this post would help a lot of newcommers.
Uthsob]

Advent of Code: Intro to Programming Puzzles and Problem-Solving Delights

Uthsob Chakraborty — Thu, 30 Nov 2023 13:22:10 +0000

Advent of Code is an annual programming event that takes place in the month of December. It starts from December 1 and Ends on the 25th. It consists of 25 small programming puzzles that are released one day at a time. The puzzles are designed to be challenging but solvable, and they cover a wide range of topics, from algorithms and data structures to mathematics and cryptography.

How does Advent of Code work?

To participate in Advent of Code, you will need to create an account on the Advent of Code website. Once you have an account, you can log in each day to view the new puzzle. Each puzzle consists of a description of the problem and a set of input data. Your task is to write a program that produces the correct output for the given input data.

Why to participate in Advent of Code?

Advent of Code is not a competition with others. Rather its a game for programmer.As mentioned earlier, it's just puzzle-solving with programming. By solving complex puzzle you can sharp your brain for learning complex things. You will learn new algorithms and data structures and improve your problem-solving and complex thinking skill. This teaches not only how to code well but also how to think well. Advent of Code is mainly designed for getting into spirit of coding in holiday. Since it's designed for the holiday season, many people learn new programming languages and apply their knowledge by solving puzzles. And most importantly AOC(Advent of Code) make us realize that code is for fun and how to enjoy coding.

What makes different than Competitive Programming:

Competitive programming and Advent of Code are both programming events, but they have different goals and formats. Competitive programming is a sport in which programmers compete to solve algorithmic problems as quickly and efficiently as possible. AOC is a more casual event that is designed to be fun and accessible to programmers of all skill levels.

How to Participate:
Advent of Code is a web-based event that is open to anyone who can write code. There is no registration or fee required to participate. The puzzles are released at midnight UTC each day, and you have until the next day to submit your solution.

How to participate in Advent of Code:

If you are interested in participating in Advent of Code, the first thing you need to do is create an account on the Advent of Code website https://adventofcode.com/ Once you have an account, you can log in each day to view the new puzzle.

Here are some additional tips for getting started with Advent of Code:

Choose a programming language that you are comfortable with. You can use any programming language that you like, but it is important to choose a language that you are familiar with. This will make it easier to focus on solving the puzzles, rather than on learning a new language.
Start with the early puzzles. The early puzzles are typically easier than the later puzzles. This will give you a chance to get used to the format of the puzzles and to learn the basic concepts that you will need to solve the later puzzles.
Don't be afraid to ask for help. If you are stuck on a puzzle, don't be afraid to ask for help. There are many online forums and communities where you can ask for help from other participants.
Check previous years puzzles To get complete idea of the format of Advent of Code and get started grinding you should check out old puzzles first. To checkout old problems- https://adventofcode.com/2022/

So Start your Adventure on Coding Puzzles with Advent of Code. I wish you best of luck.

Happy coding!

Decoding DALL-E 3: Unraveling the Text-to-Art Algorithm

Uthsob Chakraborty — Sat, 11 Nov 2023 14:19:22 +0000

Today spotlighting the marvels of DALL-E 3, the AI that transforms words into stunning visuals.

You might have experimented with DALL-E 2, or at least you’ve heard about it. To jog your memory, DALL-E 2 is a state-of-the-art "text-to-image" generation AI developed by OpenAI. It has the uncanny ability to convert textual descriptions into images that can be astonishingly lifelike. If you are curious about the inner workings of this AI and how it crafts images that almost defy reality, I recommend giving this article a read—though it's currently penned in Bengali. Dev.to Bengali Article on DALL-E 2

The process is straightforward yet awe-inspiring: you provide a text prompt, and DALL-E 2 generates an image in response. For instance, for the prompt “A cat is playing guitar, a digital art”, DALL-E 2 conjured up this creative piece of digital art:

(Generated with DALL-E 2, Prompt: A Cat is playing guitar)

Despite its brilliance, DALL-E 2 had its share of limitations, notably the challenge of incorporating text within the images it created. That's where its successor comes into play. OpenAI's recent announcement of DALL-E 3 has brought an exciting development: the ability to draw text within art.
But how does DALL-E 3 accomplish this feat? Let's dive into the technical symphony behind DALL-E 3's new capability.

Encoding and Latent Spaces

The first step involves encoding the text into a "latent space". Think of this space as a complex map that captures the essence of the text’s meaning. This encoded information then guides the image generation process, ensuring that text elements are incorporated accurately.

And this is a visual representation of latent space-

But here instead of taking image as input it take and work with Text and convert to image.

The Role of Attention Mechanisms

At the heart of DALL-E 3's capability to draw text is a mechanism known as "attention". This mechanism empowers the AI to zoom in on specific portions of the text during the image creation process. When the prompt includes text, like "a cat with the word 'meow' written on it", the model hones in on "meow" to ensure it appears naturally and consistently within the image.

A cat is saying "Meow" Generated by DALL-E 3

Back-Translation for Contextual Understanding

To deepen its grasp of textual context, DALL-E 3 employs "back-translation". This process translates the text into a different language and then back again. This roundabout translation enriches the AI’s understanding of the text's meaning, providing a more nuanced interpretation that can be conveyed visually

(Visual Representaion of Attention Mechanism)

Combining Technologies for Enhanced Creativity

By integrating attention mechanisms, back-translation, and the sophisticated use of latent spaces, DALL-E 3 is not just a text-to-image model but a conduit for complex and realistic visual storytelling. It's a step forward in AI creativity, one that expands the horizons of what we can imagine and bring to visual life with mere words.

Awesome Developer Program for students

Uthsob Chakraborty — Thu, 07 Sep 2023 15:59:48 +0000

As an undergrad student you should explore your opportunity over the internet to grow your network. Here is an awesome list of developer/volunteer programs for students. Apply and grow your network. Make your network networth.
I made a list of few developer program/volunteer program so you don't have to search it for everywhere.

TensorFlow User Group - https://www.tensorflow.org/community/groups
Gitlab Heros - https://about.gitlab.com/community/heroes/
Github Campus Experts - https://education.github.com/experts
Cloud Native Bangladesh - https://community.cncf.io/cloud-native-bangladesh/ (this link is for Bangladesh only but there are global program also. check out in their website)
AWS Community Builder - https://aws.amazon.com/developer/community/community-builders/
GitKraken Ambassador - https://www.gitkraken.com/ambassador
Hackclub- https://hackclub.com/
Auth 0 Ambassador - https://auth0.com/ambassador-program
Postman ambassador - https://www.postman.com/student-program/student-leader/
KodeKloud Ambassador - https://kodekloud.com/pages/ambassador-program
Gold Microsoft Learn Student Ambassador - https://mvp.microsoft.com/studentambassadors
AWS Cloud Club - https://aws.amazon.com/developer/community/students/cloudclubs/?community-captains-all.sort-by=item.additionalFields.sortPosition&community-captains-all.sort-order=asc&awsf.filter-location=*all&awsf.filter-year=*all
Facebook Developer Circles - https://www.developers.facebook.com/developercircles/join/
Apple WWDC Scholarships- https://developer.apple.com/wwdc23/swift-student-challenge/
IBM Students Z Ambassador- https://community.ibm.com/community/user/ibmz-and-linuxone/blogs/melissa-sassi1/2021/08/11/z-ambassador-cohort-2-call-for-applications
Adobe Creative Residency Community Fund-
https://www.adobe.com/about-adobe/creative-residency/community-fund.html
Trailblazer Connect-
https://trailhead.salesforce.com/trailblazerconnect/

If you know any other program please comment down below. I will add this on. Thanks

How to Add an SSH Key for GitHub on Linux

Uthsob Chakraborty — Fri, 01 Sep 2023 07:54:12 +0000

GitHub is a popular platform for version control and collaborative software development. To securely access and interact with your GitHub repositories from a Linux machine, you can use SSH keys for authentication. This article will guide you through the process of generating and adding an SSH key to your GitHub account on a Linux system.

Step 1: Check for Existing SSH Keys:

Before generating a new SSH key, it's essential to check if you already have one. Open a terminal and use the following command to list your SSH keys:

ls ~/.ssh/

If you see files named id_rsa or id_dsa in the output, you likely already have SSH keys. You can skip to Step 4 to add your existing key to GitHub. If not, continue to generate a new SSH key.

Step 2: Generate a New SSH Key:

To generate a new SSH key, open a terminal and enter the following command, replacing <your_email@example.com> with the email associated with your GitHub account:

ssh-keygen -t ed25519 -C "<your_email@example.com>"

You can also use the RSA algorithm (-t rsa) instead of Ed25519 if you prefer.

The command will prompt you to choose a location to save the key (press Enter to accept the default location ~/.ssh/id_ed25519 or specify a different location) and set a passphrase for added security. Make sure to remember this passphrase or store it securely.

Step 3: Add the SSH Key to SSH-Agent:

To ensure your SSH key is actively used, add it to the SSH-Agent:

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_ed25519

Replace ~/.ssh/id_ed25519 with the path to your generated SSH key if it's different.

Step 4: Add the SSH Key to GitHub:

Log in to your GitHub account.
Click on your profile picture in the upper-right corner and select "Settings."
In the left sidebar, click on "SSH and GPG keys."
Click the "New SSH key" button.
Provide a title for your SSH key (e.g., "Linux Workstation") and paste your public key (usually found in ~/.ssh/id_ed25519.pub) into the "Key" field.
Click the "Add SSH key" button.

Step 5: Test the SSH Key:

To make sure your SSH key is working correctly, run the following command in your terminal:

ssh -T git@github.com

You may see a warning message regarding authenticity; type "yes" to confirm. If everything is set up correctly, you should receive a "Hi ! You've successfully authenticated..." message.

Adding an SSH key for GitHub on a Linux system enhances the security and convenience of accessing your repositories. By following the steps outlined in this article, you can securely connect to your GitHub account, making it easier to manage your code and collaborate with others in the GitHub community.

DALL-E:2 যেভাবে বাস্তবের মতো ছবি আঁকে?

Uthsob Chakraborty — Wed, 24 May 2023 09:54:35 +0000

নিচের যেসব ছবিগুলা দেখছেন এগুলা কিন্তু কোনো মানুষ আঁকেনি বা বানায় নি সবগুলো কৃত্রিম বুদ্ধিমত্তা দিয়ে তৈরি করা হয়েছে। শুধু একটা বর্ণনা দেয়া হয়েছে কেমন ছবি চাই বাকিটা কৃত্রিম বুদ্ধিমত্তা বা এআই(AI) এঁকে দিয়েছে। এখানে থাকা ছবিগুলা Open AI এর সর্বশেষ রোবট বা এআই(AI) DALL-E 2 দিয়ে জেনারেট করা।

প্রথমেই DALL-E এর নাম সম্পর্কে বলি DALL-E নাম টা মুলত বিখ্যাত স্প্যানিশ আর্টিস্ট Salvador Dalí এবং ২০০৮ এ মুক্তি Disney এর থেকে মুক্তি পাওয়া Wall-E নাম দুটি থেকে বানানো হয়েছেে। এটি Wall-E এর মতোই একটি কৃত্রিম বুদ্ধিমত্তা সম্পন্ন রোবট এবং একই সাথে ভালো আর্টিস্ট সে হিসেবে এই নামটি ব্যাবহার করা হয়েছে।

২০২১ এর প্রথম দিকে DALL-E সম্পর্কে প্রথম ঘোষনা করে OpenAI। তখনও সেটা কারো পরীক্ষার জন্য উন্মুক্ত করে নি OpenAI। তবে এবছর OpenAI DALL-E 2 নামে এর সর্বশেষ ভার্সন প্রকাশ করে। এবং এবারই প্রথম যেখানে ডেভেলপার,আর্টিস্ট,ইনফ্লুয়েন্সারদের DALL-E 2 পরীক্ষা করার জন্য আমন্ত্রণ পাঠায়। এখনো সর্বসাধারনের জন্য উন্মুক্ত করেনি OpenAI।

এই রোবটটি অনেক ক্ষেত্রে মানুষের থেকে ভালো ছবি আঁকে। চলুন জেনে নেই কিভাবে এই কঠিন কাজটি করে DALL-E 2।

কিভাবে আঁকল?

আপনার দেয়া ডেস্ক্রিপশন বা বর্ণনা অনুযায়ী প্রয়োজনীয় ছবি গুলা আগে বুঝার চেষ্টা করে। মনে করুন আমার ডেস্ক্রিপশন হলো-

“A penguin riding a scooter in Dhaka City” আগে সে তার ডেটা সেট থেকে খুজে অব্জেক্টিফাই করার চেষ্টা করে কোনটা কী?

যেমন- একটা পেনগুইন আসলে দেখতে কেম্ন?

স্কুটার কি? ঢাকা শহর দেখতে কেমন? স্কুটারে চড়ে কিভাবে?
আপনার দেয়া কি-ওয়ার্ড থেকে DALL-E 2 একটি টেক্সট এনকোডার এর মাধ্যমে এনকোড করে। তারপর ডেস্ক্রিপশন অনুযায়ী বস্তুগুলোকে চিহ্নিত করে একটি মানচিত্র বা ম্যাপ জেনারেট করে। ম্যাপ থেকে একটি ছবি তৈরি করে এআই টি এই প্রক্রিয়ার নাম prior
এই prior থেকে একটা প্রকৃত ছবিতে রুপান্তর করতে একটি image decoder কাজ করে

ডিকোডার টি ব্যাসিকালি সব ছবিকে এম্বেড করার চেষ্টা করে। এম্বেড হলো কি-ওয়ার্ডগুলোকে একটা ম্যাথমেটিকাল রুপ বা ভেক্টরে রুপ দেয়ার চেষ্টা করা। সেই থেকে একটি ইমেজ ম্যাপ তৈরী করে।

এ প্রক্রিয়ায় কাজ করে CLIP (Contrastive Language-Image Pre-training) নামে OpenAI এর আরেকটি মডেল। যার কাজ হলো কোনো ছবির জন্য একটা সঠিক ও মানানসই ক্যাপশন দেয়া। যেটাকে মুলত আমরা DALL-E 2 এর করা কাজ এর উল্টা প্রক্রিয়াও বলতে পারি। CLIP মুলত দুটি নিউরাল নেটওয়ার্ক দিয়ে তৈরি। একটি টেক্সট এনকোডার এবং আরেকটি ইমেজ এনকোডার। CLIP কে এক বিশাল ছবি ও তার ক্যাপশনের ডেটাসেট দ্বারা ট্রেইন করা হয়।

একটা উদাহরণ দেই- যখন আমরা ইন্সটাগ্রাম বা ফেসবুকে একটা পেনগুইন এর ছবি দিয়ে ক্যাপশন দেই “A Penguin” CLIP সেই ক্যাপশন অনুযায়ী ট্রেইন হয় আসলে একটি পেংগুইন আসলে দেখতে কেমন।

ট্রেইন হওয়া CLIP মডেলটি prior প্রক্রিয়ায় পাওয়া টেক্সটগুলোর সাথে মিলিয়ে বস্তুগুলোকে নিউরাল নেটওয়ার্কের মাধ্যমে সাবজেক্ট,আর্ট স্টাইল বা টেক্সচার, স্কেল, সম্পর্ক এবং দুরত্ব পরিমাপ করে সমগ্র আর্টের একটি মানচিত্র বা ম্যাপ জেনারেট করে ম্যাপ থেকে *Visual Semantics* তৈরি করে। এই ভিজ্যুয়াল সিমান্টিক্স কে ছবিতে রুপান্তরের কাজটি করে GLIDE নামের আরেকটি মডেল। যার কাজ CLIP এর ভিজ্যুয়াল সিম্যান্টিক্স থেকে সর্বোচ্চ গ্রহনযোগ্য ছবিতে রুপান্তর করা।

GLIDE আবার আবার কাজ করে ডিফিউশন বা diffusion মডেল ব্যবহার করে।

এই diffusion জিনিসটা আবার কি? পদার্থবিজ্ঞানের তাপগতিবিদ্যার থেকে অনুপ্রাণিত হওয়া একটি মডেল। এর কাজ CLIPE এর দেওয়া ডাটা অনুসারে আস্তে আস্তে ছবিতে noise যুক্ত করতে থাকে। এই noise যুক্ত করা চলে Gaussian Noise হওয়া পর্যন্ত তার পর সেটি রিভার্স প্রক্রিয়ায় পুনরায় De-noising করা হয়। ফলে এক পর্যায়ে এটি একটি পরিষ্কার ও সুন্দর ছবি দিতে সক্ষম হয়।
**diffusion মডেল টি মূলত GLIDE কে ট্রেনিং করানোতে কাজে লাগে। ট্রেইনড হলে সে ডেটাসেটের বাইরে নিজেই কিছু ছবি জেনারেট করতে পারে। যেমন আপনি যখন অবাস্তব কিছু ডেস্ক্রিপশন এ লিখবেন সেটি সে এই মডেলের মাধ্যমে সেই জিনিসটা আসলে কেমন তার একটা রেফারেন্স নিয়ে নতুন ছবি তৈরী করবে।

DALL-E 2 এখানে GLIDE এর মার্জিত সংস্করণ ব্যবহার করে। মার্জিত GLIDE মডেল সর্বোচ্চ সম্ভাব্য ছবির ভিজুয়্যাল সিম্যান্টিক্স এর মাধ্যমে ম্যাপ উপস্থাপন করে। তা ব্যবহার করে সব ডাটা prior কে দেয়া হয় তার উপর ভিত্তি করে image encoding এর মাধ্যমে সব ফ্রেম মিলিয়ে কয়েকটি ছবি জেনারেট করে থাকে।আর এভাবেই DALL-E 2 কাজ করে।

DALL-E 2 এর এখনো বেশ কিছু সীমাবদ্ধতা রয়েছে। সেগুলো-

১। DALL-E কে একের অধিক মানুষ আঁকার দায়িত্ব দিলে সে তা পারে না পারলেও চেহারা নষ্ট করে দেয়।

২। DALL-E গণনা করতে এখনো দুর্বল। ধরুন আপনি একটি prompt দিলেন যেখানে চাচ্ছেন “একটি বিড়াল ৫ টি মাছ খাচ্ছে” সেক্ষেত্রে DALL-E গণনা করে বিড়াল আর মাছৈর সংখ্যা নিয়ে ঝামেলা পাঁকাবে।

৩। DALL-E টেক্সট জেনারেটিং এ দুর্বল। ধরুন আপনি একটি সাইনবোর্ডে একটা নির্দিষ্ট লেখা দিয়ে চাইলেন তার ছবি পেতে কিন্তু সেই রেজাল্ট আপনার মোটেও মনমত পাবেন না। লেখালেখির ক্ষেত্রে DALL-E দুর্বল।

৪। কিছু সেন্সেটিভ ওয়ার্ড(যেমন: রক্ত,খুন,নগ্নতা ইত্যাদি) থাকলে DALL-E কোনো ছবি জেনারেট করতে পারেনা। বরং ভায়োলেশন হিসেবে ধরে রিপোর্ট করে।

এমন আরো কিছু ঝুকি ও সীমাবদ্ধতা আছে DALL-E তে। যদিও OpenAI টিম সেটা সাড়াতে কাজ করছে। ঝুকি ও সীমাবদ্ধতাগুলো পড়তে চাইলে দেখে আসুন-https://github.com/openai/dalle-2-preview/blob/main/system-card.md

পরিশিষ্ট:

DALL-E কিভাবে কাজ করে জানাটা থেকে ভিতরে কি কি প্রক্রিয়া হচ্ছে সেটা বুঝাটা বেশ কঠিন। আমি চেষ্টা করে যত সহজে ব্যাপারটা কে বোধগম্য করার কিন্তু টেকনিকাল টার্মগুলো বেশ খটমটে এবং কঠিন। ভুল হতেও পারে কিছু তাই যারা বুঝেন একটু ভেরিফাই করে দিয়েন দয়া করে। মূল সোর্স সংযুক্ত করলাম এখানে সোর্স-
https://www.assemblyai.com/blog/how-dall-e-2-actually-works/