Imagine a railway system where collisions are a thing of the past and track safety is monitored automatically. That is the vision behind the Railway Anti-Collision System in Bangladesh, a new software engineering project designed to modernize train travel.
Currently, Bangladesh’s railway relies heavily on manual operations and oral communication. This human-dependent system has led to several tragic accidents. There are three main issues the project identifies:
Track Congestion: Too many trains trying to use the same space.
Collisions: Multiple trains ending up on the same track at once.
Illegal Tampering: The unauthorized removal of "fish plates" (the metal bars that join tracks together), which causes derailments.
The proposed system uses Artificial Intelligence (AI) and GPS tracking to create a safety net for everyone on the tracks. Here is how it works:
Automatic Braking: If the system detects another train approaching on the same track, it can trigger an automatic brake to prevent a head-on or rear-end collision.
GPS Monitoring: Dispatchers can see the exact location of every train in real-time, making traffic management much easier.
Fish Plate Security: By using power relays, the system can detect if tracks have been tampered with and alert the control room immediately.
Staff Coordination: Station masters and train engineers can check gate crossings and track status right from their mobile or desktop apps.
Passengers: The biggest winners, as they get a significantly safer and more reliable journey.
Train Engineers: They get a digital "second pair of eyes" to monitor traffic and track health.
Dispatchers & Station Masters: They gain powerful tools to inspect stations and manage train flow without relying only on phone calls.
While there are risks—like the need for stable funding or ensuring users are properly trained—the potential impact is huge. By moving away from manual switches and toward an AI-supported infrastructure, Bangladesh can dramatically reduce accident rates and ensure that the "lifeline" of the country remains safe for everyone.
Hello everyone! I recently completed a data science project where I explored three different datasets using R. I used three major machine learning techniques: Clustering, Classification, and Regression.
Here is a simple breakdown of what I did and how it works!
In the first part of my project, I worked with the Diamonds dataset. The goal was to see if we could group diamonds together based on their physical traits like price, carat, depth, and table.
How it works: I used a method called K-Means Clustering.
Finding the "Sweet Spot": To decide how many groups (clusters) to make, I used the Elbow and Silhouette methods.
Result: The model successfully grouped the diamonds into categories, making it easier to see the relationship between a diamond's size (carat) and its price.
Next, I analyzed a Bank Marketing dataset. The goal here was to predict a "Yes" or "No" answer: Will a customer subscribe to a bank term deposit?
How it works: I built a Decision Tree model. This model acts like a flowchart to make decisions based on customer data.
Preparation: I cleaned the data by handling "unknown" values and using a "log transformation" on the bank balance to make the numbers easier for the model to handle.
Key Insight: I discovered that the Duration of the phone call and the customer's Balance were the most important factors in predicting whether they would say yes.
Finally, I worked on a medical project to predict the likelihood of a patient having Dengue based on their blood parameters.
How it works: I used Logistic Regression. Instead of just saying "Dengue" or "No Dengue," this model gives a Probability Score between 0.0 and 1.0.
Blood Patterns: I focused on features like Hemoglobin, RBC, and Platelet counts. I even created a "Low Platelet Flag" because a low count is a major sign of Dengue.
Performance: I checked how accurate the model was using metrics like RMSE and R-Squared to ensure the risk scores were reliable.
This project taught me how different data problems require different tools. Whether it's grouping diamonds or predicting health risks, R is a powerful language for finding answers!
As a student in my 9th semester, I recently completed an exciting project for my Web Technology course: the PetCare Management System. This project was a great way to put my web development skills to the test while building something that truly helps animals and their owners.
Managing pet records, vet appointments, and adoptions can be messy for clinics and shelters. Our goal was to create a "one-stop shop" that makes communication between pet owners and veterinarians smooth and organized.
The system is built using PHP, MySQL, HTML, CSS, and JavaScript. It features three main roles to keep everything running perfectly:
The Admin: Manages users (vets and owners), oversees the adoption process, and keeps the dashboard secure.
The Pet Owner: Can book vet appointments, browse for pets to adopt, and manage their own pet's information.
The Veterinarian: Can track pet health records, manage their daily schedule, and talk directly to owners about pet care.
I am proud to have worked on this alongside my group members, MD Towfiq Bin Hasan, Md Samiul Rayan Rifat, and Faiyaz Azmaine. We also want to give a huge thanks to our instructor, Mr. Wahidul Alam Riyad, for guiding us through this process. Building this in my 9th semester has been a rewarding experience. It’s not just about the code; it's about using technology to make life better for our furry friends!
For my 7th-semester Computer Graphics course, my team and I developed a multi-scene 2D animation project. It tells the visual story of a ship’s journey across different environments, featuring dynamic weather, day-night cycles, and interactive controls.
The project is divided into 5 distinct scenes, each handled by a different team member. We used OpenGL primitives (polygons, lines, and circles) to draw every element from scratch—from the massive cargo ships to the tiny raindrops.
The project is interactive. Instead of just watching a video, the user controls the world using the keyboard and mouse. Here is a breakdown of the features:
1. Dynamic Scenes
Scene 1 & 2: Features a large cargo ship and a bridge. You can toggle between a bright morning and a dark night.
Scene 3 & 5: Includes coastal views with windmills and palm trees. Scene 5 even features a beautiful sea-side resort with a swimming pool.
Scene 4: A more "urban" transition showing a road and a human character moving along the path.
2. Interactive Weather & Physics
We implemented several "real-time" effects:
Rain System: By pressing 'R', a randomized particle system generates rain, accompanied by actual rain sound effects.
Animation: Clouds drift across the sky, windmill blades rotate, and ships move across the water using timer functions ($glutTimerFunc$) to keep the movement smooth.
Sound Effects: We integrated Windows Multimedia headers to play sounds for sea waves, ship horns, and even a helicopter.
3. User Controls
Switching Scenes: Use keys 1 to 5 to jump between different parts of the journey.
Mouse Interaction: In several scenes, clicking the Right Mouse Button starts the ship's engine, while the Left Mouse Button can slow it down or change the time of day.
Language: C++
Graphics Library: OpenGL / GLUT
Development Environment: Code::Blocks
Key Concepts: Transformation (Translation, Rotation), Coordinate Systems ($gluOrtho2D$), and Color Buffering.
This project was a great way to understand how math and code come together to create art. Moving from a blank white screen to a fully animated world with sound was a challenging but rewarding experience for our 7th semester!
University life is a rollercoaster, and for me, the 6th semester was where things got real. As part of my Object-Oriented Programming 2 course at AIUB, my team and I were tasked with building something that could actually work in the real world. That’s how our Pharmacy Management System (PMS) was born.
Here is the story of how we turned lines of code into a full-scale desktop application.
We wanted to create a Windows-Forms application that didn't just look good but actually solved problems. Pharmacies deal with a lot—medicine stocks, customer orders, and employee management. Our goal was to automate these tasks to reduce errors and make things run like clockwork.
We designed the system around three main "actors," each with their own unique powers:
The Admin (The Boss): The Admin has the bird's-eye view. They approve new users, manage salaries, and even grant leave requests for employees.
The Employee (The Engine): These are the users who manage the inventory. They can add, update, or delete products, and check the financial bonuses they earn each month.
The Customer (The User): We made it easy for customers to browse categories, add medicine to a cart, pay via bkash or MasterCard, and even print a PDF invoice.
It wasn't all just pretty buttons. We spent nights perfecting the "brain" of the project:
Database Integration: We used SQL to store everything from user credentials to transaction histories.
UI Design: We built 22 different forms to ensure the user experience was smooth and professional.
Logical Mapping: Before coding, we drew complex Use Case Diagrams and ER-Diagrams to make sure the data flowed correctly between the admin, employee, and customer.
By the end of the semester, we had a system where:
A customer could request a medicine that was out of stock.
An admin could see exactly how many people were registered through a live dashboard.
Employees could apply for leave directly through the app.
This project was more than just a grade; it was about teamwork and late-night debugging sessions. Seeing the "Login Account" screen finally work after hours of SQL errors was the best feeling ever!
University life is full of challenges, and for me, the 4th semester was all about diving deep into the world of data. As part of my Introduction to Database course at AIUB (Summer 2022-2023), my team and I were tasked with creating a system that could handle a real-world business. We chose to build the Online Bookstore Management System.
We started by imagining how a real bookstore works. We needed to connect customers, books, authors, and orders. * The ER Diagram: We used "Visual Diagram" to draw our ER model. It shows how a Customer places an Order, how Books are written by Authors, and how Publishers manage the stock.
Normalization: To make sure our database was efficient and had no "messy" data, we followed 1NF, 2NF, and 3NF rules. This helped us split the information into 10 clean tables like Books, Customers, Payments, and Address .
After the design was ready, it was time to get our hands dirty with code! Using Oracle 10g, we performed the following:
Table Creation: We wrote SQL commands to build the structure of our store. For example, the Orders table tracks the date and total amount, while the Books table keeps track of prices and stock levels.
Data Insertion: We added sample data to see our store in action—books like "Tale of Glory" and "Rise of Rivals" were added to our digital shelves.
Smart Queries: We tested the system with various queries. We practiced everything from simple SELECT commands to complex Inner and Outer Joins to see which author wrote which book. We even created Views to make it easier for a manager to see "Book Order Details" at a glance.
Building this system wasn't just about getting a grade; it was about understanding how the "backbone" of modern websites works. It taught us how a well-organized database can improve customer experience and help a business grow.
Looking back at my 4th semester, this project stands out as a big milestone in my journey as a student.
Note: You can find the full project documentation and the PDF on my GitHub.
Every computer science student remembers that one project where everything finally "clicks." For me, it was my second-semester Java project. I decided to build a Movie Ticket Management System, and I did it all using Notepad++.
I wanted to create a simple, user-friendly way for people to browse movies and buy tickets online. Here is how the system works:
User Authentication: When you open the app, you see an intro screen. You can either Login or Create an Account.
Registration: New users can sign up by entering their Name, Email, and Age. Once they set and confirm a password, they are ready to go!
The Dashboard: After logging in, you reach the dashboard. This is where the magic happens. It displays all the current movies available in the theater.
Booking & Payment: Users can select their favorite movie and pick a showtime. To keep it realistic, I added a payment section where users can pay via Card or bKash.
Building this project helped me understand how data flows from a registration form to a dashboard. It wasn't just about writing code; it was about thinking like a user. Using Notepad++ also forced me to pay extra attention to my syntax since I didn't have a heavy IDE doing the work for me!
I have uploaded the full source code and repository to my GitHub. If you are a fellow student or just curious about how the logic works, feel free to check it out:
Note: This project is a great foundation. In the future, I might add a database to save user info permanently or a more advanced GUI!
Have you ever wondered what it takes to bring a miniature sports field to life? For our Introduction to Electrical Circuit Lab course, our team took on the challenge of constructing a model cricket field equipped with a functional lighting system. Supervised by Sadia Yasmin, this project allowed us to apply classroom theory to a hands-on build.
The Team
This project was a collaborative effort by:
Md. Shamin Yasar (ID: 21-45022-2)
Fardin Hasan Anik (ID: 21-45002-2)
Hasin Aabrar Khan (ID: 21-45297-2)
Md. Towfiq Bin Hasan (ID: 22-48732-3)
Sarjil Ahmed Turjo (ID: 22-47369-2)
To build the circuit and the field structure, we gathered several essential electrical and hardware components:
LEDs: To act as the stadium floodlights.
Battery & Connector: A 9V battery to power the system.
Switch: To turn the lights on and off.
Wires: To connect all electrical parts.
Hardboard: Used as the primary base for the cricket field.
We managed to keep our project affordable while prioritizing safety. We used high-quality, safe components to ensure the circuit was stable. Here is the cost summary:
Component
Price (Taka)
Hardboard 200 tk, Battery 65 tk, Wire 30 tk, Switch 20 tk, LED 10 tk, Miscellaneous 100 tk, Total 425 tk
Final Thoughts
Building this model was a great way to understand how simple circuits work in a real-world scenario. Despite being a small-scale project, it required careful planning from budgeting for safe materials to ensuring the wiring was correct.
Have you ever forgotten to water your plants or worried about them while you were away? Our team at the American International University - Bangladesh decided to tackle this common problem. As part of our Faculty of Engineering studies, we built an Automatic Plant Watering System designed to take the guesswork out of gardening.
Meet the Team
This project was a group effort by four dedicated students from the Department of Electrical & Electronics Engineering (Section N, Group 03), under the supervision of Dr. Shuvra Mondal:
Foysal Munsy
Tasnia Ahmed
Tahasin Rana
MD. Towfiq Bin Hasan
The goal was simple: create a system that ensures plant health through precise watering. By monitoring soil moisture in real-time, the system only triggers irrigation when the plant actually needs it. This gives owners peace of mind and prevents both underwatering and overwatering.
To build this, we used several key electronic components:
Arduino Uno: The main controller (the "brain").
Soil Moisture Sensor: To check how wet or dry the soil is.
Water Pump & Pipe: To deliver the water.
5-Volt Relay Module: Acts as a switch to turn the pump on and off.
Connecting Wires: To link all the parts together.
The assembly involves two main parts: the sensor and the pump control.
The Sensor: We connected the soil moisture sensor to the Arduino. Its digital output (DO) pin goes to Arduino pin 6, and it receives power from the 3.5V pin.
The Pump: The relay module is connected to Arduino pin 3. This module then sits between a 5V power supply and the water pump, acting as the gatekeeper for electricity.
Once set up, the system follows a clear logic:
Check: The sensor constantly monitors the soil's wetness.
Signal: When the soil gets too dry, the sensor tells the Arduino.
Action: The Arduino activates the relay, which turns on the water pump.
Stop: The pump waters the plant until the sensor detects enough moisture, then the Arduino shuts it off to save water.
This project shows how simple technology can make everyday life a little easier and a lot greener!
Traffic jams are a headache for everyone, especially when four lanes of traffic suddenly have to merge into just one due to roadwork or accidents. To tackle this, a team of students from the American International University-Bangladesh designed an Adaptive Traffic Control System specifically for these tricky lane-reduction scenarios.
Why Do We Need This?
When lanes are closed, "bottlenecks" happen. This leads to longer travel times, wasted fuel, and more pollution. The goal of this project was to create a simple, low-cost way to guide cars from multiple lanes into one single lane smoothly and safely.
The team built a circuit that acts like a smart brain for traffic lights. It uses five main stages to keep things moving:
The Heartbeat (Clock Pulse): Using a 555 timer IC, the circuit creates a steady pulse that tells the lights when to change.
Custom Timing: A potentiometer (a clickable knob) allows operators to change how long the green light stays on. More resistance means a longer green light; less resistance makes it shorter.
The Counter: A 4017 IC (Decade Counter) acts as a sequencer, counting from 0 to 9 to make sure the lights change in the correct order.
The Logic Unit: This part uses transistors and diodes to ensure that only one lane has a green light at a time while the others stay red.
Visual Feedback: Bright LEDs (Green, Yellow, and Red) show drivers and researchers exactly which lane is open.
Not at all! One of the best things about this project is its affordability. The entire prototype was built for only 725 Tk (around $6–$7 USD), using common parts like resistors, breadboards, and a 9V battery.
While the prototype works great in simulations and lab tests, the team has big ideas for the future:
Adding Sensors: Right now, the system uses set timers. Future versions could use vehicle detection sensors to see how many cars are actually waiting.
AI Integration: Using Artificial Intelligence and CCTV cameras could help the system "learn" the best patterns for peak hour traffic.
Better Communication: Eventually, these systems could talk directly to smart cars to give drivers real-time updates.
This project shows that we don't always need expensive, high-tech gadgets to solve big problems—sometimes, smart engineering and simple circuits are all it takes to pave the way for a smoother commute.
Imagine a building collapses or a hazardous chemical leak occurs. Sending people into these areas is incredibly dangerous. This is exactly where DisasterX comes in a smart, remote-controlled robot designed to go where humans can't.
Created by a team of students at American International University-Bangladesh (AIUB), this project shows how affordable technology can solve massive real-world problems.
DisasterX is an IoT-based robotic rover. Think of it as a high-tech explorer on wheels. It’s equipped with a camera and a robotic arm, allowing an operator to see what the robot sees and interact with the environment from a safe distance.
The "brain" of the robot is an Arduino Uno, which coordinates all its movements. Here is the breakdown of its main features:
Real-Time Video: Using an ESP32-CAM module, the rover streams live video directly to a phone or computer over Wi-Fi.
The Robotic Arm: It has a servo-powered arm that can pick up lightweight objects or clear small pieces of debris.
Go-Anywhere Wheels: A four-wheel-drive system powered by DC motors helps it navigate rough and uneven terrain.
Wireless Control: The operator uses a remote transmitter (RC) to steer the rover and move the arm with precision.
The team didn't just build it; they put it to the test! Here is what they found:
Stability: The rover can operate continuously for up to 2 hours.
Range: It stays connected to the operator within a 30-40 meter range.
Speedy Response: There is only a tiny delay (about 100-120 milliseconds) between the operator's command and the robot's movement, making it feel very responsive.
Building advanced robots usually costs a fortune. However, the DisasterX was built for about 25,330 Tk (roughly $215 USD) using easy-to-find parts. This makes it a scalable and affordable solution for emergency teams who need reliable tools without the massive price tag.
The current version is a great start, but the team is already looking at ways to make it even better. Future plans include:
Autonomous Navigation: Adding sensors so the robot can avoid obstacles on its own.
Environmental Monitoring: Adding sensors to detect gas leaks or temperature changes.
Ruggedizing: Making it waterproof and dustproof for even harsher environments.
DisasterX proves that with a bit of creativity and the right tech, we can build tools that keep people safe and make disaster response faster and smarter.