DEV Community: Krishna Jha

My port of Python SemVer to Golang for my First Hackathon

Krishna Jha — Tue, 11 Aug 2026 03:18:28 +0000

Porting python-semver to Go on a phone, an old PC, and 41 hours

I'm Krishna, 18, in Class 12 prepping for JEE. When PORT MORTEM 2026 showed up, I didn't have a laptop for it. What I had was a Samsung A05 with Termux, and an old Core 2 Duo PC running Linux Mint Xfce that I could only get to the next morning.. But I really wanted to participate in a Hackathon, So my plan became: start on the phone doing whatever needs zero compute, move to the PC once I could sit at it, and don't pick a repo that punishes me for being resource constrained.

I picked python-semver. It parses and compares version strings like 1.2.3-alpha.1. No I/O, no state, just numbers and string rules.. It was also easy to understand, i.e. easy to get what this even does. The hackathons own examples pointed at node-semver as a good target for exactly this reason, python-semver is basically its Python sibling, and Python is the language I actually know well from every other project I've built.

Track: Open Pair, since Python to Go isn't one of the official pairings.

I did created the folder and all from my phone and used git from Termux to push the folder and asked Claude for what will I need to do, to prove the fuzzing and how to make a hashmap(my first time doing so!), after getting that, i added it to the push, also i generated that Personal Access Token (PAT) for 30 days, copied it and pinned it into my clipboard.
The next day, i did my first fuzzing test, then something broke..

What actually broke

I built a differential fuzz harness in Python that generates random and adversarial version strings, feeds them into both the real python-semver and my compiled Go binary, and diffs the results. First real run at 5000 cases came back with 5 mismatches. All of them involved a version where patch was 0 ;)

Turned out to be a bug in my own test harness, not the port. I'd set omitempty on the numeric JSON fields in the Go bridge, and omitempty silently drops any field equal to its zero value, including a legitimately zero patch number. So the bridge would send no "patch" field at all instead of "patch": 0, and my Python side read the missing key as None, which obviously didn't match 0. Removed omitempty from the numeric fields, reran, 0 mismatches ;)

The next one was a real bug. bump_build("8.35.21+V00") gave "V1" in my Go port but "V01" in python-semver. The original preserves the zero padded width when incrementing a numeric identifier inside a string, mine just parsed the digits to an int and reformatted plain, losing the padding. Fixed it by padding the result back to the original digit width instead of doing a plain integer to string conversion. Reran at 5000 cases, then again across a handful of different seeds to make sure it wasn't a one off. Stayed at 0 (Phew).

The mistake I had almost shipped

Part of this hackathon's rule is you hash the original repo's test suite at the start so nobody can quietly edit the tests to make their port pass. I did that on day one, but I cloned the default branch instead of pinning to a released version. Meanwhile my fuzz harness was running against whatever pip install semver actually gives you, which is the last published release, not main.

For most of the functions I ported this didn't matter because the code was identical between main and the release. It only became visible once I started porting next_version,which was not even in the original plan btw, but I decided to do it..which had been rewritten on main and wasn't in the published release yet. My hand traced expected output didn't match what pip's semver actually returned, and diffing the two sources side by side showed exactly why!

Fixed it by checking out the actual release tag (3.0.4) in my local clone, recomputing the test suite hash against that pinned commit, and updating the README to reference the correct commit hash. Everything I'd already fuzzed before that point was still valid since none of that logic had changed between main and the release, but the citation in my README was wrong until I caught it.

The decision I'd take back

Hashing against main instead of a pinned release tag on day one. It cost me nothing in the end because I caught it before submitting, but it easily could have been the kind of inconsistency a judge notices and starts poking at. Lesson learned: always pin to an actual release, never a moving branch, when you're making a provenance claim.

What I cut on purpose

I didn't port match(), the range syntax thing like >=1.0.0 <2.0.0. It's basically its own small parser, meaningfully more scope than everything else combined, and I'd rather ship something fully proven than something bigger with an unfuzzed corner. I did end up adding next_version() later since it turned out to just be composition of functions I'd already ported and proven, so the risk to add it was low.

Where it landed

Parse, compare, all three bump functions, bump_prerelease, bump_build, finalize_version, next_version, is_valid, all ported and passing differential fuzzing against the real python-semver 3.0.4 across roughly 30,000 generated cases and multiple random seeds, 0 mismatches on the final build.
And guess what?, it's 3.1x faster in parsing and a 363x faster in Comparing! (Ik it might be due to python being python and golang being golang, but ain't it amazing?)

I didn't had a mic for my PC, I had two options (for making the video), use DroidCam to record while speaking, but my PC setup is near street, so it would be noisy.. or (the one I did) Record audio somewhere quiet (it didn't came out that much quiet though), play it and start recording with it.

Repo's here: https://github.com/kosmoscpp/port-semver-go
Video:
https://youtu.be/SYA3pwTXHAw?si=gstEMU4o_qNAHDY9

Tagging Hackathon Raptors 🦖

RaptorFollow

We're the Hackathon Raptors Association, hosting regular #hackathons aimed at improving quality of life 🦖

I Built a Real-Time Indian Stock Market Simulator in Python — Here's How 📊

Krishna Jha — Tue, 16 Jun 2026 10:59:15 +0000

You know that feeling when you want to learn stock trading but don't want to risk actual money? Or when you want to test a trading strategy without losing your savings? That's exactly what inspired me to build NSE Live Terminal—a full-featured paper trading simulator for Indian stocks, and I'm making it open-source for everyone.

What is NSE Live Terminal?

NSE Live Terminal is a real-time stock market simulation dashboard where you can:

🛒 Execute market buy/sell orders on 12 major Indian stocks
📊 Watch live intraday charts powered by Plotly
💼 Track your portfolio with real-time P&L calculations
🏆 Compete on a live leaderboard with other traders
⚡ Get data refreshed every 15 seconds automatically

The best part? You start with ₹1 Crore (10 million rupees) in virtual cash—plenty to experiment!

Why I Built This

Paper trading is criminally underrated. Most people dive into real stock trading without practicing first. But there's a disconnect:

Traditional paper trading apps are boring or behind paywalls
You don't get real-time data for Indian stocks
Building your own means you actually understand how markets work

So I decided to build one that's modern, interactive, and free.

The Tech Stack (It's Simpler Than You Think)

Frontend: Streamlit (Python UI framework)
Database: SQLite3 (Local file-based DB)
Data Source: Yahoo Finance (yfinance SDK)
Charting: Plotly
Deployment: Railway (Docker containerized)

Why these choices?

Streamlit: Zero frontend knowledge required. Deploy in 5 minutes.
SQLite: No backend server. Perfect for projects that don't need scaling.
yfinance: Free real-time stock data for NSE instruments.
Plotly: Beautiful, responsive charts with minimal code.
Railway: Dead simple Docker deployment with a free tier.

Core Features Breakdown

1️⃣ Authentication (Clean & Simple)

# User enters nickname + 4-digit PIN
# Auto-creates account on first login
# All data stored locally in SQLite

No email verification nonsense. Just pick a username and PIN. Instant access.

2️⃣ Live Trading Engine

# Real-time price from yfinance
# Buy/Sell execution with balance validation
# Auto-calculates average buy price
# Instant P&L computation

When you buy stocks, the app automatically calculates your average cost basis. When you sell, it updates your portfolio and shows you profit/loss instantly.

3️⃣ The 12-Stock Universe

We track these major Indian blue-chips:

Tech: TCS, Infosys
Banking: HDFC Bank, ICICI Bank, SBI
Energy/Infra: Reliance Industries, Adani Ports, NTPC
Auto: Maruti Suzuki, M&M
Consumer: ITC, Hindustan Unilever

Why just 12? Focus > chaos. These are the most liquid, most traded stocks on NSE—perfect for learning.

4️⃣ Real-Time Charts

# 5-minute interval data over last 5 days
# Plotly automatically crops to tight boundaries
# No flat lines, no empty space
# Updates every 15 seconds

The charts use tight autoscaling so you actually see the volatility. No boring flat lines that waste screen space.

5️⃣ Portfolio Dashboard

Quantity held
Average buy price (weighted)
Current market price
Current value
Unrealized P&L (green if profit, red if loss)

At a glance, you know exactly how your portfolio is doing.

6️⃣ Live Leaderboard

# Net Worth = Cash + Value of Stock Holdings
# Rankings update in real-time
# Compete with friends / colleagues

Everyone starts with ₹1 Crore. Who can grow it the most? Create a friendly competition!

Getting Started (3 Steps)

Step 1: Clone & Install

git clone https://github.com/kosmoscpp/paper-trading.git
cd paper-trading
pip install -r requirements.txt

Step 2: Run Locally

streamlit run app.py

Visit http://localhost:8501 and start trading.

Step 3: Deploy (Optional)

Want to share it with friends? Deploy to Railway in 2 minutes:

Push your repo to GitHub
Connect Railway to your GitHub account
Add Dockerfile config
Deploy

(Or use my live version: https://paper-trader-kosmos.up.railway.app/)

Under the Hood: How It Works

Database Schema

-- Users table
CREATE TABLE users (
    username TEXT PRIMARY KEY,
    pin TEXT,
    balance REAL
);

-- Portfolio table
CREATE TABLE portfolio (
    username TEXT,
    ticker TEXT,
    quantity INTEGER,
    avg_price REAL,
    PRIMARY KEY (username, ticker)
);

Super simple. Two tables. That's it.

The Trading Engine

# When you BUY:
1. Validate you have enough cash
2. Deduct from balance
3. Add to portfolio (or update if you already own it)
4. Recalculate weighted average price

# When you SELL:
1. Check if you own enough shares
2. Add cash back to balance
3. Reduce quantity in portfolio
4. P&L is calculated on the fly

Background Data Sync

# Every 15 seconds:
while True:
    for each_stock in STOCK_DICT:
        fetch_live_price_from_yfinance()
        cache_in_session_memory()
    sleep(15)

This background loop keeps your charts fresh without hammering Yahoo Finance's API.

What I Learned Building This

Streamlit is ridiculously fast for MVPs. Went from zero to deployed in a weekend.
SQLite scales further than you think. For paper trading with 50+ users? Totally fine.
Real-time charting matters. When charts update live, trading feels real. Psychological engagement is everything.
Cache strategically. Don't hit the API every second. Cache + periodic refresh is the sweet spot.
UX > Features. A clean authentication screen and readable tables beat 50 features nobody uses.

Next Steps / Roadmap

📈 Advanced charts: Candlestick patterns, technical indicators (RSI, MACD)
🏅 Achievements: Badges for milestones (first 1M profit, etc.)
💬 Social features: Comment on trades, share portfolio
📱 Mobile app: React Native wrapper
🤖 Strategy backtester: Upload your strategy, backtest it historically

The Bigger Picture

This project isn't just about paper trading. It's about making financial literacy accessible. Stock market knowledge shouldn't be behind paywalls or require intimidating setup.

With an open-source simulator:

Students learn how markets actually work
Traders practice strategies risk-free
Developers see a real full-stack example
Communities (like Indian Dev communities) get a shared learning tool

Try It

Live App: https://paper-trader-kosmos.up.railway.app/
GitHub: https://github.com/kosmoscpp/paper-trading
(Might be down now!)

No signup. No BS. Just pick a username, set a PIN, and start trading with ₹1 Crore.

Have feedback? Found a bug? PRs welcome! This is open-source—contributions make it better for everyone.

Questions?

How do you build a Streamlit app? Check the app.py—it's heavily commented
How does the database work? Two simple tables—look at the schema
How do you deploy? Docker config is included
Why this stack? See my "Tech Stack" section above

Drop a comment below or open an issue on GitHub. Let's build this together! 🚀

Happy trading, and may your P&L be green! 📈