ABOUT
•
PROJECTS
•
AI / ML
•
ROBOTICS
•
CS CORE
•
MATHEMATICS
•
TECH STACK
•
COURSEWORK
•
GITHUB
┌─[ rohaan2802@github ]────────────────────────────────────────────────────┐
│ │
│ $ whoami │
│ > Mohammad Rohaan │
│ > BS Computer Science │
│ > FAST-NUCES Islamabad │
│ │
│ $ primary-languages │
│ > C++ • C • Python • Java • MATLAB │
│ │
│ $ engineering-focus │
│ > AI / ML • Computer Vision • Robotics • Software Engineering │
│ │
│ $ systems │
│ > Algorithms • OS • Databases • Networks • Parallel Computing │
│ │
│ $ current-mission │
│ > Agentic AI • Security • Statistics • FYP │
│ │
│ $ status │
│ > Building. Learning. Experimenting. █ │
│ │
└──────────────────────────────────────────────────────────────────────────┘
|
Machine Learning Deep Learning Computer Vision NLP Neural Networks Agentic AI |
Algorithms Backend Databases Operating Systems Networks Software Design |
Embedded Systems ESP32 Arduino Sensors Robot Control ML for Robotics |
Linear Algebra Probability Statistics Calculus Differential Equations Numerical Computing |
I'm a Computer Science student at FAST-NUCES Islamabad interested in engineering systems at the intersection of artificial intelligence, software, mathematics, data, and physical computing.
My work spans C/C++ systems programming, Python-based AI/ML, Java/Spring Boot backend development, computer vision, databases, parallel computing, and embedded robotics.
I particularly enjoy projects where multiple CS domains meet — for example, applying computer vision to robotics, using data structures and algorithms to build software systems, or combining concurrency, hardware, sensors, and control logic.
From algorithms → to software → to intelligence → to real-world systems.
┌─────────────────────┐
│ COMPUTER SCIENCE │
└──────────┬──────────┘
│
┌──────────────────────┼──────────────────────┐
│ │ │
▼ ▼ ▼
┌────────────────┐ ┌────────────────┐ ┌────────────────┐
│ INTELLIGENCE │ │ SOFTWARE │ │ HARDWARE │
└───────┬────────┘ └───────┬────────┘ └───────┬────────┘
│ │ │
AI • ML • DL DSA • OS • DB ESP32 • Arduino
CV • NLP • Stats Networks • SE Sensors • Robots
│ │ │
└──────────────────────┼──────────────────────┘
│
▼
┌─────────────────────┐
│ INTELLIGENT SYSTEMS │
└─────────────────────┘
Also work with
SQL • T-SQL • x86 Assembly
|
AI • Computer Vision • Robotics
Computer-vision system for real-time shuttlecock detection as part of an autonomous badminton service robot. Engineering Stack ▸ Object Detection ▸ Dataset Preparation ▸ Image Annotation ▸ Model Training ▸ Model Evaluation ▸ Real-Time Inference ▸ Computer Vision ▸ Robotics Integration |
Backend • Database • Software Engineering
Structured library platform covering borrowing, fines, administrative operations, reporting and persistence. Engineering Stack ▸ MVC ▸ Dependency Injection ▸ Repository Pattern ▸ Service Layer ▸ Entity Modelling ▸ Transactions ▸ Reporting ▸ Database Integration |
|
Algorithms • DSA • Systems
Mini version-control system based on fundamental data structures and repository concepts. Engineering Stack ▸ Commit Trees ▸ Graph Structures ▸ Hashing ▸ File Processing ▸ Diff ▸ Merge ▸ History Traversal ▸ Unit Testing |
Desktop • Database • Analytics
Database-backed travel platform supporting trips, bookings, payments, service providers and reporting. Engineering Stack ▸ ERD / EERD ▸ Relational Modelling ▸ Normalization ▸ Constraints ▸ Database Logic ▸ Application Architecture ▸ Reporting ▸ Analytics |
|
Embedded • Robotics • Sensors
Multi-robot project focused on coordinated movement and hardware/software interaction. Engineering Stack ▸ Embedded Programming ▸ ESP32 ▸ Sensor Integration ▸ Ultrasonic Sensors ▸ IMU / Gyroscope ▸ Robot Coordination ▸ Control Logic ▸ Hardware Integration |
OS • Concurrency • Systems Programming
Concurrent airline simulation applying operating-system synchronization concepts. Engineering Stack ▸ POSIX Threads ▸ Mutexes ▸ Semaphores ▸ Critical Sections ▸ Race Conditions ▸ Shared Resources ▸ Synchronization ▸ Concurrent Transactions |
🧪 More Software & Experimental Work
Plagiarism Checker
Chess
Space Shooter
Console Notepad
Shopping Portal
NLP Experiments
Machine Learning Notebooks
Parallel K-Means
Sparse Matrix / HPC Experiments
Responsive Web Interfaces
Database Applications
Robotics Experiments
🧠 Artificial Intelligence
Intelligent Agents
State Spaces
Problem Formulation
Search Trees
Search Graphs
Breadth-First Search
Depth-First Search
Uniform-Cost Search
Heuristics
Greedy Best-First Search
A* Search
Game Trees
Minimax
Alpha-Beta Pruning
Constraint Satisfaction
Knowledge Representation
Reasoning
Decision Making
📈 Machine Learning
Supervised Learning
Unsupervised Learning
Regression
Classification
Clustering
Raw Data
│
▼
Preprocessing
│
▼
Feature Engineering
│
▼
Train / Validation / Test
│
▼
Model Training
│
▼
Evaluation
│
▼
Hyperparameter Tuning
│
▼
Inference
Feature Selection
Cross Validation
Overfitting
Underfitting
Bias–Variance Tradeoff
Regularization
Hyperparameter Tuning
Model Evaluation
🧬 Deep Learning & Neural Networks
Perceptrons
Artificial Neural Networks
Multilayer Networks
Activation Functions
Forward Propagation
Backpropagation
Loss Functions
Gradient-Based Optimization
CNN
Feature Extraction
Transfer Learning
👁️ Computer Vision
Digital Images
Image Processing
Image Classification
Object Detection
Bounding Boxes
CNN-Based Vision
YOLOv8
Annotation
Training Pipelines
Inference
Real-Time Vision
Computer Vision for Robotics
💬 Natural Language Processing
Text Preprocessing
Tokenization
Text Representation
Feature Extraction
Text Classification
NLP Pipelines
Language-Based ML Applications
|
|
Click a module to explore the knowledge area.
🌳 Data Structures & Algorithms
Arrays
Linked Lists
Stacks
Queues
Priority Queues
Trees
Binary Trees
Binary Search Trees
Heaps
Graphs
Hash Tables
Searching
Sorting
Recursion
Divide & Conquer
Greedy Algorithms
Dynamic Programming
BFS
DFS
Shortest-Path Concepts
Minimum-Spanning-Tree Concepts
Time Complexity
Space Complexity
Big-O
Big-Ω
Big-Θ
Recurrence Relations
Algorithm Correctness
🖥️ Operating Systems
Operating Systems
│
├── Processes
│ ├── Process Creation
│ ├── fork()
│ ├── exec()
│ └── wait()
│
├── Threads
│ ├── pthreads
│ └── Multithreading
│
├── Synchronization
│ ├── Race Conditions
│ ├── Critical Sections
│ ├── Mutexes
│ └── Semaphores
│
├── IPC
│ ├── Pipes
│ ├── Named Pipes
│ ├── Signals
│ ├── dup()
│ └── dup2()
│
├── Deadlocks
├── CPU Scheduling
├── Memory Management
├── Virtual Memory
└── File-System Concepts
⚡ Parallel & Distributed Computing
Parallel Computing
Distributed Computing
Concurrency
Shared Memory
Data Parallelism
Task Parallelism
Parallel Decomposition
Synchronization
OpenMP
Parallel Loops
Work Sharing
Reductions
Scheduling
Speedup
Scalability
Load Balancing
Performance Analysis
🗄️ Database Systems
Relational Model
ERD
EERD
Primary Keys
Foreign Keys
Relationships
Functional Dependencies
Normalization
DDL
DML
JOINs
Subqueries
Aggregate Functions
Views
Stored Procedures
Triggers
Functions
Constraints
Transactions
ACID
Transaction Processing
Concurrency Concepts
Data Integrity
Data Cleaning
🌐 Computer Networks
OSI Model
TCP/IP
Application Layer
Transport Layer
Network Layer
Data-Link Layer
TCP
UDP
IP Addressing
Subnetting
Routing
Switching
DNS
DHCP
HTTP
HTTPS
Socket Fundamentals
Packet Analysis
Cisco Packet Tracer
🏗️ Software Engineering & Design
SDLC
Requirements Engineering
Functional Requirements
Non-Functional Requirements
Use Cases
Software Modelling
Software Architecture
Testing
Maintenance
Version Control
Agile Concepts
Object-Oriented Design
Modularity
Abstraction
Separation of Concerns
Coupling
Cohesion
SOLID
Layered Architecture
MVC
Design Patterns
UML
🔌 Digital Logic & Computer Organization
Binary Systems
Boolean Algebra
Logic Gates
Combinational Logic
Sequential Logic
Flip-Flops
Registers
Counters
CPU Organization
Registers
Instruction Execution
Memory Organization
Addressing Modes
Machine Instructions
Assembly Language
x86 Assembly
🔢 Discrete Structures
Propositional Logic
Predicate Logic
Sets
Relations
Functions
Proof Techniques
Mathematical Induction
Recurrence Relations
Combinatorics
Graphs
Trees
Discrete Probability
|
|
|
|
|
|
🔢 Numerical Computing
Floating-Point Computation
Numerical Error
Root Finding
Interpolation
Approximation
Numerical Linear Algebra
Numerical Differentiation
Numerical Integration
Numerical Equation Solving
Computational Problem Solving
|
|
|
|
Primary
Additional
|
|
|
💻 Programming & Software Development
Programming
├── Programming Fundamentals
│ └── Programming Fundamentals Lab
│
├── Object-Oriented Programming
│ └── OOP Lab
│
├── Data Structures
│ └── Data Structures Lab
│
├── Design & Analysis of Algorithms
├── Software Design & Analysis
└── Software Engineering
Knowledge developed: programming logic, structured programming, pointers, memory, OOP, abstraction, data structures, algorithms, complexity, software architecture and engineering practices.
🖥️ Computer Systems
Systems
├── Digital Logic Design
│ └── DLD Lab
│
├── Computer Organization & Assembly Language
│ └── COAL Lab
│
├── Operating Systems
│ └── OS Lab
│
├── Computer Networks
│ └── CN Lab
│
└── Parallel & Distributed Computing
Knowledge developed: digital systems, processor architecture, assembly, processes, threads, IPC, synchronization, networking, parallelism and distributed-computing fundamentals.
🧠 Artificial Intelligence & Robotics
Intelligent Systems
├── Robotics Technology
├── Artificial Intelligence
│ └── AI Lab
├── Embedded Control of Robotics
└── Machine Learning for Robotics
Knowledge developed: intelligent search, machine learning, perception, robot kinematics, embedded control, sensor integration and intelligent robotic systems.
📊 Data, Mathematics & Scientific Computing
Mathematical Computing
├── Applied Calculus
├── Calculus & Analytical Geometry
├── Linear Algebra
├── Differential Equations
├── Probability & Statistics
└── Numerical Computing
Knowledge developed: continuous mathematics, vectors and matrices, differential systems, probability, statistics, numerical approximation and mathematical foundations of AI.
⚡ Electronics & Physical Computing Foundations
Physical Computing
├── Linear Circuits & Electrical Networks
│ └── Lab
├── Applied Physics
├── Digital Logic Design
└── Embedded Control of Robotics
Knowledge developed: circuits, electrical foundations, digital systems, physical computing and hardware/software interaction.
📝 Communication & Professional Development
Professional Development
├── English Language
├── Communication & Presentation Skills
│ └── Lab
├── Technical & Business Writing
└── Professional Practices in IT [Current]
Knowledge developed: technical communication, documentation, presentations, professional writing and computing professionalism.
|
Agents Planning Reasoning Tool Use AI Workflows CURRENT |
CIA Triad Authentication Access Control Cryptography Secure Systems CURRENT |
Regression Estimation Inference Interpretation Evaluation CURRENT |
Green IT Energy Efficiency E-Waste Hardware Lifecycle Sustainable Computing CURRENT |
🎓 Final Year Project I
Currently progressing through Final Year Project I, applying accumulated knowledge from software engineering, AI/ML, research, data analysis and system development toward a larger computer-science project.
C / C++
│
├──────────────► Data Structures & Algorithms
│ │
│ ▼
├──────────────► Operating Systems
│ │
│ ▼
└──────────────► Parallel Computing
│
▼
SYSTEMS SOFTWARE
Python
│
├──────────────► Machine Learning
│ │
│ ▼
├──────────────► Deep Learning
│ │
│ ▼
└──────────────► Computer Vision ──────► Robotics
Java
│
└──────────────► Spring Boot
│
▼
Backend Engineering
│
▼
Databases
MATLAB + Mathematics
│
├──────────────► Linear Algebra
├──────────────► Numerical Computing
├──────────────► Robotics
└──────────────► Mathematical Modelling
| 🧠 Intelligence | 💻 Software | 🤖 Physical Computing | 📊 Computing Science |
|---|---|---|---|
| Artificial Intelligence | Backend Engineering | Robotics | Algorithms |
| Machine Learning | Software Architecture | Embedded Systems | Parallel Computing |
| Deep Learning | Systems Programming | Autonomous Systems | Numerical Computing |
| Computer Vision | Databases | Sensor Systems | Statistical Computing |
| NLP | Distributed Systems | Robot Perception | Mathematical Computing |
| Agentic AI | Software Design | Intelligent Control | High-Performance Computing |
Contribution animation appears after the corresponding GitHub Actions workflow generates the SVG.
flowchart LR
CS["💻 Computer Science"]
CS --> AI["🧠 AI"]
CS --> SE["⚙️ Software"]
CS --> MATH["📐 Mathematics"]
CS --> ROB["🤖 Robotics"]
AI --> ML["Machine Learning"]
ML --> DL["Deep Learning"]
DL --> CV["Computer Vision"]
SE --> SYS["Systems"]
SE --> BACK["Backend"]
SE --> PAR["Parallel Computing"]
MATH --> LA["Linear Algebra"]
MATH --> STAT["Statistics"]
MATH --> NUM["Numerical Computing"]
ROB --> EMB["Embedded"]
ROB --> CTRL["Control"]
ROB --> AUTO["Autonomy"]
CV --> INTEL["🚀 Intelligent Systems"]
BACK --> INTEL
PAR --> INTEL
STAT --> INTEL
EMB --> INTEL
AUTO --> INTEL
┌──────────────────── OPEN TO COLLABORATION ────────────────────┐
│ │
│ AI / Machine Learning Robotics & Autonomous Systems │
│ Computer Vision Backend Engineering │
│ Deep Learning Embedded Systems │
│ Data / Scientific Computing Parallel & Distributed Systems │
│ Software Engineering Intelligent Systems │
│ │
└───────────────────────────────────────────────────────────────┘
