Software Engineer • AI/ML • Systems

BUILDING THINGS
THAT SOLVE PROBLEMS.

I build deterministic AST static analysis engines, compiler diagnostics, high-performance algorithm visualizers, and applied machine learning tools.

PES College of Engineering
Python • C++ • AST • ML
Karnataka, India
"I don't just study software concepts. I build deterministic compilers, AST static analysis engines, memory-efficient algorithm visualizers, and backend workflows to solve tangible bottlenecks."
— Bhargav B S
Real Work Gallery

Curated Engineering Exhibits

Every project below exists as a real, working system. Explore the architectural flow, engineering decisions, and live demonstrations.

EXHIBIT 01 Applied AI & DevTools

AI Code Quality Analyzer

Machine Learning & AST-Based Static Analysis Engine

Automated code review tools often flag basic stylistic conventions while missing deeper structural complexity, nested cognitive load, and maintainability risks.

I built a dual-layer analysis engine that parses Python source into Abstract Syntax Trees in memory, extracts cyclomatic complexity and Halstead metric vectors, and uses a trained scikit-learn classifier to predict code maintainability.

Python Streamlit scikit-learn AST Analysis Code Metrics
IN-MEMORY AST INSPECTOR sub-50ms parse
def evaluate_maintainability(source_ast):
tree = ast.parse(source_ast)
metrics = compute_cyclomatic_halstead(tree)
return classifier.predict(metrics.vector)
CYCLOMATIC 1.0 (Clean)
HALSTEAD 142.6 E
PREDICTION High Quality
PHASE 01
In-Memory AST Parsing
Accepts Python source via web UI and parses syntax trees in memory without disk write overhead.
PHASE 02
Metric Computation
Traverses nodes to calculate McCabe cyclomatic complexity, Halstead volume, and nesting depth.
PHASE 03
ML Classifier Inference
Feeds normalized metric vectors to a trained model to predict maintainability class.
EXHIBIT 02 Systems & Algorithms (C++)

C++ Console Sorting Visualizer

Algorithm Engine with Real-Time ANSI Terminal Rendering

Static textbook explanations fail to convey the dynamic memory swaps, partition pivot choices, and recursive stack frames of sorting algorithms.

I implemented an in-place algorithm engine in modern C++ that renders colored vertical bar charts directly in standard terminal consoles using ANSI escape sequences, tracking exact comparisons and swaps in real time.

C++ Data Structures Algorithms ANSI Escape Codes Complexity Analysis
C++ ANSI TERMINAL BUFFER QuickSort Active
Operations: 0 swaps
EXHIBIT 03 Compiler Tools & Static Analysis

Codebase Intelligence Engine

Deterministic Codebase Analysis & Graph Diagnostics Platform

In growing software repositories, circular module couplings and unmonitored structural entropy lead to cascading regressions during refactoring.

I engineered a production-hardened platform that indexes multi-module Python codebases, resolves intra-module symbol references, and builds deterministic directed dependency graphs to detect circular import chains and architectural smells.

Python FastAPI TypeScript AST Parsing Graph Algorithms Docker
Architectural Pipeline
PHASE 01
Recursive Repository Indexer
Traverses directory trees, filtering AST-parseable Python source modules.
PHASE 02
Symbol Call Graph Resolution
Extracts function definitions, classes, global symbols, and inter-module imports.
PHASE 03
Directed Dependency Graph
Builds directed import graphs and runs cycle detection algorithms to flag circular coupling.
PHASE 04
Structured Health Reports
Outputs structured JSON reports and diagnostics suitable for CI/CD pipelines.
EXHIBIT 04 Backend & Autonomous Workflows

RECLAIM: Revenue Recovery Agent

Autonomous Payment Dropoff Recovery & Transaction Workflow Engine

Failed and dropped payment transactions in e-commerce cause revenue loss for merchants and introduce friction into the checkout lifecycle.

I engineered an autonomous revenue recovery backend in Python that analyzes transaction dropoffs, enforces deterministic safety policy guardrails, and executes automated recovery workflows with payment links while maintaining strict transaction ledger integrity.

Python Backend Architecture Payment Workflows SQLite Safety Guardrails
Architectural Pipeline
PHASE 01
Dropoff Ingestion
Captures failed transaction events, dropoff points, and checkout payload metadata.
PHASE 02
Policy & Guardrails Evaluation
Evaluates recovery eligibility against deterministic safety policies and retry limits.
PHASE 03
Recovery Dispatch
Generates dynamic payment recovery links and triggers automated customer recovery actions.
PHASE 04
Ledger State Resolution
Updates database state and records transaction resolution events in the accounting log.
Proof Over Claims

Skills Proved Through Real Code

Instead of presenting an unsubstantiated checklist of technologies, here is the exact codebase evidence where each language, tool, and concept was applied.

Core Language & AST

Python

AST node traversal, symbol call graph extraction, cyclomatic metric computation, scikit-learn model training, and autonomous payment workflow backends.

AI Code Quality Analyzer Codebase Intelligence Engine RECLAIM
Systems & Memory

C++

Contiguous array buffers, in-place memory swaps, ANSI escape sequence terminal rendering, and empirical vs theoretical Big-O complexity tracking.

C++ Sorting Visualizer
Applied AI & Predictive Models

Machine Learning

Structural feature vector engineering from AST metrics, Decision Tree / Random Forest classification pipelines, and maintainability scoring.

AI Code Quality Analyzer
Compiler Tools

Static Analysis & Graphs

Grammatical syntax tree parsing, Halstead metric calculation, cyclomatic complexity calculations, and directed graph cycle detection for circular imports.

Codebase Intelligence Engine
Backend Architecture

System Design & Backends

FastAPI, transaction recovery pipelines, database persistence, and deterministic state management with safety policy guardrails.

RECLAIM Codebase Intelligence Engine
Interfaces & DOM

JavaScript (ES6+) & WebGL

Three.js 3D WebGL node constellations, Lenis smooth scrolling physics, GSAP animations, dynamic GitHub API synchronizer, and command palette navigation.

Portfolio Canvas System
Source of Truth: GitHub Topic "portfolio"

Public Work & Repository Archive

Directly connected to github.com/Bhargav99bro. When I push a new project tagged with the portfolio topic, it surfaces here automatically.

Bhargav B S Profile Photo

Bhargav B S

Software Engineer • AI / ML
PES College of Engineering, Mandya
The Trajectory

Curiosity, Code, and Real Systems

I am a Computer Science & Engineering undergraduate specializing in Artificial Intelligence & Machine Learning at PES College of Engineering. My core drive is understanding how software works from the ground up — from compiler Abstract Syntax Trees and memory layout to training applied machine learning models.

Rather than building trivial clones, I focus on projects that solve concrete technical friction: static code quality scoring tools, dependency cycle analyzers, memory-efficient terminal visualizers in C++, and autonomous transaction recovery backends.

I am actively preparing for full-time Software Engineer, SDE, AI/ML, and Systems roles where I can contribute to high-impact production engineering teams.

FINAL SCENE • ACT 07
OPEN FOR FULL-TIME SDE / AI / SYSTEMS ROLES

LET'S BUILD
SOMETHING USEFUL.

Every project in this exhibition started with a question: how does this work under the hood, and can we engineer a better solution?

Have an engineering opening on your team?
Want to collaborate on AST compilers or systems?
Want to discuss software architecture & ML?
PRIMARY CHANNEL
Direct Email
bhargavpes9880@gmail.com

Fastest way to reach me for job inquiries, technical discussions, or collaboration proposals.

BHARGAV B S
SOFTWARE ENGINEER • PES COLLEGE OF ENGINEERING • 2026