• Core & OOP: methods, recursion, classes/objects, inheritance, abstract classes, interfaces, inner classes, static/final, packages, java.lang, annotations & Javadoc
• Java 8 Crash Course: lambdas & functional interfaces, streams (intermediate/terminal, primitive, parallel, pipelines), Optional, CompletableFuture, collectors, I/O & StringTokenizer
• Collections Deep Dive: List/ArrayList, LinkedList, Vector/Stack; Map family (HashMap internals, LinkedHashMap & LRU, TreeMap/Red-Black, Identity/Weak/ConcurrentHashMap); Set & Sorted/ Navigable; Queue/Deque, Blocking queues, priority queues — with internals, images & notes
• Concurrency & Threading: threads, synchronization, locks (reentrant/RW), deadlocks, thread pools & Executors, CountDownLatch/CyclicBarrier, CompletableFuture use-cases, virtual threads (Loom) visuals
• Generics: generic classes/methods, wildcards, bounds, interfaces, exception caveats
• Exceptions & Resources: checked vs unchecked, custom exceptions, try-with-resources patterns
• Date/Time API: core classes, formatting, zones, practical snippets
• Networking & JDBC (SQLite): UDP echo servers/clients, multiclient reverse-echo; JDBC drivers, DDL/DML, prepared/callable statements; schema & SQL notes
• Versions Atlas: focused notes & examples for Java 8, 11, 12, 14, 17, 21, 24 (feature PDFs & demos)
• Tooling & Site: GitHub Pages (Jekyll) + Actions, Telegram notify workflows, CONTRIBUTING, LICENSE/NOTICE

• A cleanly architected Todo Management Platform that helps users capture tasks, track progress, and stay organized in everyday workflows
• Designed using Java + Spring Boot with a neat separation of responsibilities across controller and service layers — simple to maintain, flexible to extend
• Smart payload handling through DTOs (CreateTodoRequest / UpdateTodoRequest) to ensure reliable data flow and safe state changes
• Unified, developer-friendly error responses with GlobalExceptionHandler — improving API predictability and debugging clarity
• Self-contained UI included (static/index.html) allowing instant interaction with features without external tooling
• Thoughtful engineering notes inside the System Design folder — LLD diagrams, principles, and decisions documented for real-world reasoning
• Docker-packaged for effortless deployment across environments, showcasing readiness for cloud and container ecosystems
• Well-structured project hygiene: pom.xml, LICENSE, clear README — engineered for collaboration and future enhancements

• Comprehensive collection of Java AWT programs demonstrating GUI design fundamentals and event handling
• Covers multiple modules: Adapter Classes, Event Delegation Model, Frame-Based Applications, Layout Managers, Painting & Color, and more
• Implements practical demos — ButtonDemo, CheckBoxDemo, TextFieldDemo, ScrollbarDemo, KeyEventDemo, MouseEventDemo, and WindowEventDemo
• Visual assets (PNG diagrams and comparisons) explain AWT layouts like FlowLayout, BorderLayout, GridLayout, and CardLayout
• Demonstrates all four approaches to event handling: Frame as Listener, Inner Class, Anonymous Class, and Lambda Expression
• Animation folder includes gravity, shape-fall, and space simulations written using AWT drawing and threading
• Includes LICENSE and structured source folders for modular understanding and easy navigation

• Interactive reference project showcasing ASCII and Unicode character mappings
• Includes downloadable ASCII - Binary Character Table.pdf for quick offline lookup
• Explains differences between ASCII (128-character encoding) and Unicode (143K+ characters covering all scripts)
• Web-based interface (index.html) displaying characters, binary codes, and descriptions with light/dark theme toggles
• Assets (sun.png, moon.png, favicons) and vercel.json for seamless Vercel deployment
• Perfect resource for developers learning text encoding, binary representation, and web deployment fundamentals
• Contains README.md and LICENSE — open-source and educationally focused

• Visually rich guide covering essential Docker commands for development and maintenance
• Organized tabs for Operations, Monitoring, Cleanup, and Best Practices
• Demonstrates core actions like building, running, and cleaning containers with concise command blocks
• Clean dark-themed interface designed for quick reference and hands-on learning

• Comprehensive repository demonstrating Java Swing concepts — the foundation of Java-based desktop GUI programming
• Organized into interactive modules covering all major Swing components: JButton, JTextField, JList, JComboBox, JTree, JSlider, JProgressBar, and more
• Includes real-world UI examples: Menus & Toolbars, Tabbed & Split Panes, Internal Frames, and Layered Panes
• Each folder demonstrates distinct topics — borders, sliders, spinners, look & feel, trees, layout management, and event-driven behavior
• Provides comparative visual resources (AWT vs Swing.png, Look and Feel Swing.png) to explain design and framework evolution
• Implements advanced GUI structures such as JInternalFrame and JLayeredPane to manage complex window hierarchies
• Tree component modules illustrate hierarchical models with logical variations and textual documentation
• Menu and toolbar module integrates icons, shortcuts, and color actions — mirroring real application interfaces
• Comprehensive and modular — excellent for learners exploring event handling, component customization, and layout optimization in Swing
• Includes LICENSE and visual assets to ensure complete reproducibility and educational reference

• A comprehensive learning repository on JavaFX, illustrating the fundamentals and advanced constructs of modern Java GUI programming
• Begins with StructureOfFXApplication — detailing the core architecture of a JavaFX app including Application, Stage, and Scene lifecycle
• CommonPropertiesofControls explores shared control attributes like text alignment, color, font styles, and event listeners
• Controls & Input Elements: practical implementations of CheckBox, RadioButton, ComboBox, DatePicker, ColorPicker, FileChooser, and TextArea — each paired with annotated diagrams and screenshots
• EventHandling demonstrates multiple approaches — from simple event methods to custom event classes and handler interfaces — visualized with Event Handling.png for clarity
• Layouts & Panes: rich demonstrations of layout managers such as BorderPane, GridPane, FlowPane, VBox, HBox, StackPane, TilePane, Accordion, TabPane, ScrollPane, and SplitPane
• Each layout example visually shows how nodes, panes, and containers interact to form hierarchical scene graphs, with supportive logic notes and layout diagrams
• Interactive Examples: modules like ComboBoxFormApplication and BugFixComboBoxApp integrate logic with form design, dynamic item selection, and user input validation
• Includes explanatory text files and logic images (Logic.png, Layouts.png, etc.) that connect code behavior to underlying UI architecture
• Designed as a visual–code hybrid reference for mastering scene graph design, component properties, and JavaFX event-driven programming
• Licensed and modular — a complete educational package for students, developers, and educators seeking a structured deep dive into the JavaFX ecosystem

• A compact Java AES File Encryption Tool showcasing real-world use of the Java Cryptography Architecture (JCA)
• Supports key generation, file encryption, and decryption via a simple CLI
• Implements secure 256-bit AES with modular methods and safe stream handling
• Lightweight design — fast, functional, and perfect for learning practical cryptography

• Built complete English-Hindi Transformer translator from scratch in PyTorch — implementing encoder-decoder architecture, multi-head attention, positional encoding, and layer normalization without pre-trained models
• Developed custom tokenization pipeline with trained SentencePiece models (400+ vocab) for both languages, handling morphologically rich Hindi text and understanding subword tokenization strategies
• Implemented self-attention mechanism with mathematical foundations: Query-Key-Value projections, softmax normalization, and weighted aggregation — visualized through interactive notebooks
• Created comparative tokenizer study benchmarking BERT, GPT-2, and RoBERTa on bilingual datasets to analyze vocabulary efficiency, OOV handling, and tokenization behavior differences
• Designed comprehensive system architecture diagrams (encoder-decoder flow, multi-head attention structure, ML system design) for technical documentation and presentations
• Gained deep understanding of why Transformers replaced RNNs: parallel processing advantages, attention for long-range dependencies, computational efficiency, and gradient flow in deep architectures
• Mastered PyTorch fundamentals: custom nn.Module design, Dataset/DataLoader patterns, GPU optimization, model serialization, and debugging attention weights
• Explored research-level concepts: positional encoding (sinusoidal embeddings), backpropagation through time, trade-offs between model capacity and compute, low-resource language handling

• A comprehensive practical collection of Digital Image Processing (DIP) algorithms implemented in Python
• Explores essential concepts such as smoothing, sharpening, frequency filtering, and edge enhancement
• Low&HighPassFilter.py demonstrates Fourier-based low-pass and high-pass transformations with clear visual results
• MorphologicalOperations.py applies erosion, dilation, opening, and closing to extract or refine object structures
• BoundariesExtractionImage.py isolates object contours and highlights region boundaries from grayscale inputs
• Smoothing&SharpeningImage.py shows the impact of kernel operations and gradient-based sharpening filters
• Each module is supported with paired input/output image sets for intuitive understanding of visual transformations
• DIP Overview directory includes annotated images and videos explaining the effect of each transformation
• Features a live static site hosted on GitHub Pages — Explore Online ↗ — for interactive preview of results
• Cleanly structured repository with README.md, modular Python scripts, and educational visuals for students and practitioners

• Hands-on learning project demonstrating the fundamentals of Artificial Neural Networks
• Builds perceptron models from scratch to classify AND, OR, and NOT gates (no frameworks — pure math)
• Implements Multilayer Perceptron (MLP) with backpropagation to solve the nonlinear XOR problem
• Visuals included (and_gate.png) to show convergence and decision boundaries
• Python scripts show feedforward, weight updates, activation functions & loss behavior step-by-step
• Great foundational reference for interviews, ML courses, or transitioning into deep learning frameworks

• End-to-end image classifiers with TensorFlow/Keras (clean training/validation workflow)
• Transfer learning & fine-tuning notebook for rapid convergence on small datasets
• Autoencoder implementation for representation learning & reconstruction demos
• Supporting notebooks: basic perceptron, regression, vector ops, and a simple LSTM for sequence intuition
• Reproducible runs (seeds), core metrics (accuracy/loss), quick visualization hooks
• Organized as Jupyter notebooks: Image Classifier.ipynb, Implementation of image classifier using CNN.ipynb, Implement Transfer Learning with Fine Tuning.ipynb, Implementation of Autoencoder.ipynb, etc.

• Comprehensive collection of Generative Adversarial Network (GAN) architectures exploring image generation and translation tasks
• Begins with Basic_GAN.ipynb — an introduction to adversarial learning between generator and discriminator models
• Includes Deep Convolutional GAN (DCGAN) for high-quality image synthesis using convolutional feature hierarchies
• Conditional_GAN.ipynb and Conditional GAN.txt demonstrate label-conditioned image generation for multi-class control
• Implements Pix2Pix for paired image-to-image translation and CycleGAN for unpaired domain mapping (e.g., photo ↔ sketch)
• Covers Progressive Growing of GANs — generating high-resolution outputs through staged network expansion
• Organized with explanatory text files and Jupyter notebooks for conceptual and visual understanding
• Each subproject focuses on practical intuition — training workflow, loss dynamics, and visual output progression
• Well-suited for learners exploring generative modeling, adversarial optimization, and modern deep learning architectures

• Deep learning pipeline that classifies human emotions from speech signals (anger, happy, sad, fear, etc.)
• Extracts powerful audio features using MFCCs and Spectrograms for emotion-specific acoustic patterns
• Includes training notebooks (Emotion Recognition.ipynb) + inference-ready prediction workflow
• Data augmentation folder to improve generalization and reduce overfitting on small speech datasets
• Evaluation assets like confusion matrices and test predictions for model performance insights
• Strong use-case for human–computer interaction, call-center analytics, mental health monitoring & more

• Demonstrates real-world NLP by summarizing long text using Hugging Face Transformers
• Uses the facebook/bart-large-cnn model — a powerful encoder–decoder architecture for abstractive summarization
• Simple Python inference script (Main.py) → tokenize → generate → decode → clean output
• Includes discussion notes (HFT.txt) explaining how transformer-based models understand language context
• Easily extendable into Streamlit/Flask API or dataset-based evaluation workflows
• Dependency-managed through Requirements.txt — ready for GPU/Colab deployment

• A comprehensive repository exploring core computer vision and pattern recognition techniques
• Implements supervised and unsupervised classification using Random Forests and K-Means clustering for multi-class problems
• Deep learning experiments include CNN architectures trained on CIFAR-10 and digit classification datasets
• Features a notebook on applying Deep CNNs to solve NLP-style problems — bridging vision and language domains
• Includes step-by-step notebooks: supervised binary/multi-class classification, Naive Bayes, and CNN-based pattern analysis
• Ideal educational reference for understanding classical vs. deep learning approaches in pattern recognition

• Educational repository demonstrating the core principles of Information Retrieval (IR) and Text Mining using Python
• Covers end-to-end text preprocessing — tokenization, stop-word removal, and stemming for document normalization
• Implements CountVectorizer.ipynb and Representing a Text Document in Vector Space Model.ipynb to build and compare vector-based document representations
• Demonstrates similarity computation techniques using cosine and Euclidean metrics for document matching
• Includes Naive Bayes Classifier.ipynb and Classification of Text Documents into Known Classes.ipynb for supervised categorization of text data
• Web Crawling and Searching for News Stories.ipynb illustrates basic crawling and content retrieval from live news sources
• Additional notebook provides a hands-on example of XML parsing (employee.xml) for structured document processing
• Comprehensive conceptual coverage bridging classical IR, feature extraction, and machine learning for text understanding