Forem: Tariq Mehmood

Building a live electricity dashboard as a first-semester CS student

Tariq Mehmood — Fri, 27 Mar 2026 04:49:32 +0000

Hi everyone, I’m Tariq Mehmood. I’m currently in my first semester as a computer science student, and for the past few months, I’ve been building my first major production project: a Finnish electricity price-tracking website Sähkötänään.

In my university classes, we are diving deep into C++, memory management, and core algorithms. But applying those foundational concepts to a live web application with real-time data fetching has been an entirely different beast.

I wanted to share a bit about the architecture hurdles I’m facing and see how more experienced devs handle the transition from "student projects" to scalable tools.

The Project

Sähkötänään is designed to help Finnish consumers track fluctuating exchange electricity (spot) prices. The core feature is a live data dashboard that pulls hourly pricing via API and feeds that data into interactive calculators (e.g., calculating the exact cost of running a sauna or home heating based on the current hour's rate).

The Architecture Hurdle: Managing Live Data

Initially, I thought building a dashboard just meant making a fetch() call and rendering a chart. The reality hit me hard when

I started dealing with:

Rate Limits & Caching: I can't hammer the regional energy APIs every time a user loads the page. I'm currently working through the best ways to cache that hourly data on my backend and serve it efficiently to the frontend.
State Management in Calculators: The calculators need to instantly react to both user inputs (like their specific contract margin) and the live API data.
The AI Assist: As the logic got heavier, I started integrating AI tools (like Codex) to help scaffold the core data-handling logic while I focused on the overall architecture.

The Pivot: From Solo Dev to Technical Manager

The biggest lesson I've learned recently isn't even about code. It’s about scope.

To make the site an authoritative resource, it needs content—articles on optimizing home heating, contract comparisons, and daily price analyses. I quickly realized I couldn't write hundreds of articles, run a forum outreach campaign, and build a scalable backend at the same time.

I recently brought on a small team of three writers and an outreach specialist. Writing Standard Operating Procedures (SOPs) for them to ensure quality without relying on spammy AI content was my first real taste of being a technical founder. Delegating the content means I can finally step back and focus entirely on the codebase.

Questions for the Community

As I continue to build out the backend to support this new influx of traffic and content, I’d love to hear from those who have built similar data-heavy dashboards:

Caching Strategies: What is your go-to architecture for caching and serving third-party hourly API data without over-engineering it?
AI Integration: For those using AI to assist with coding, do you prefer to have the AI write your core API logic, or do you handle the data yourself and use AI strictly for frontend components?
Scaling: Any advice for a student on making sure a newly launched dashboard doesn't immediately crash when traffic spikes?

Is the RBT Exam Difficult?

Tariq Mehmood — Sun, 01 Mar 2026 11:01:26 +0000

If you’re preparing for the RBT exam, you’re probably wondering: Is it actually hard? The honest answer is: it depends on how prepared you are — but for most candidates, the RBT practice exam free is very manageable with focused study.

Let’s break it down clearly so you know exactly what to expect and how to approach it.

What Makes People Think It’s Difficult?

Here are the most common reasons candidates feel nervous:

1. The Terminology

ABA uses specific language:

Reinforcement vs. punishment
Positive vs. negative
Continuous vs. intermittent reinforcement

If you don’t clearly understand definitions, questions can feel tricky.

2. Scenario-Based Questions

The exam doesn’t just ask definitions. It gives real-world scenarios and asks:

What should the RBT do?
What is the correct procedure?
What ethical guideline applies?

This requires understanding, not memorization.

3. Ethics Section

Questions about professional conduct, supervision, and boundaries can be subtle. Many test-takers underestimate this part.

What Actually Makes It Manageable

Here’s the good news: the RBT exam is considered an entry-level certification.

You are not expected to:

Design treatment plans
Conduct functional behavior assessments independently
Make high-level clinical decisions

You are expected to:

Implement behavior plans
Collect data correctly
Follow ethical guidelines
Communicate professionally

If you completed your 40-hour training and reviewed the task list carefully, you already have most of what you need.

What Typically Causes People to Fail?

Not studying strategically.

Common mistakes:

Memorizing flashcards without understanding concepts

Ignoring ethics

Not practicing scenario questions

Cramming the night before

Not taking practice exams

How to Make It “Not Difficult”

Here’s a simple plan:

1. Master the Task List

Study each section:

Measurement
Assessment
Skill Acquisition
Behavior Reduction
Documentation and Reporting
Professional Conduct and Scope of Practice

2. Practice Scenario Questions

The more you see real-life examples, the easier the exam feels.

3. Understand Reinforcement Deeply

Most tricky questions relate to:

Identifying reinforcement vs. punishment
Determining function of behavior
Selecting correct data collection methods

4. Review Ethics Carefully

Know:

When to report concerns
Boundaries with clients
Supervision requirements
Confidentiality

So… Is It Hard?

Here’s the balanced answer:

It is not an extremely difficult exam.
It is not something you can pass without studying.
It is very passable with preparation.
Most candidates succeed on their first try.

If you understand the concepts rather than memorize definitions, you’ll likely do well.

A Confidence Check

If you can confidently answer questions like:

“What is the function of this behavior?”
“Is this positive reinforcement or negative punishment?”
“What should an RBT do if a parent asks for treatment advice outside the plan?”

You’re probably ready.

Final Thoughts

The RBT exam feels intimidating mostly because it’s your first professional certification. But it’s designed to test whether you can safely and competently implement behavior plans — not whether you’re an expert.

With structured study and practice, it becomes much more about clarity than difficulty.

How to Code Brawl Stars Private Server Logic in Node.js

Tariq Mehmood — Mon, 22 Dec 2025 10:49:37 +0000

If you’ve ever wondered what it would be like to unlock all Brawlers, enjoy unlimited gems, test custom skins, or experiment with your own game rules, then the idea of a Brawl Stars private server has probably crossed your mind. While official Brawl Stars gameplay on Supercell’s servers is locked to strict rules, many players dream of a sandbox-style experience. That’s where the concept of coding or creating a Brawl Stars private server comes in.

Before moving ahead, remember that real private servers violate Supercell’s Terms of Service. This guide is only for educational and informational purposes, helping you understand how such systems work from a programming and server-logic standpoint.

What Is a Brawl Stars Private Server?

A Brawl Stars private server is a custom environment where the restrictions of the original game are removed. Players often get:

Unlimited gems and coins
All brawlers unlocked
Custom maps and skins
Faster upgrades and gameplay control

Unlike the official Supercell servers, a private server runs on independent backend logic that mimics the game mechanics but does not connect to the real player base.

Why Do Developers Experiment With Brawl Stars Private Servers?

Developers and tech learners love these projects because they allow:

Learning server-client communication
Understanding game backend logic
Working with databases
Practicing Node.js, Python, or Java server programming
Experimenting with custom gameplay mechanics

This is why “Brawl Stars Private Server Coding” is a hot keyword in both the gaming and programming community.

How a Brawl Stars Private Server Concept Works (Developer Perspective)

A basic private server idea involves:

A Server Backend
Handles authentication, currency amounts, unlocks, and player states.
A Database
Stores user profiles, unlocked brawlers, progress, battle logs, etc.
Game Logic Layer
Controls matchmaking, battle rules, brawler stats, damage, and events.
Communication Layer
Syncs data between game client and server using networking protocols.

Example Concept: Node.js Logic for a Fake “Brawl Stars-Like” Reward Server

Again, this does NOT run the real Brawl Stars client like Nulls brawl it’s only a learning simulation to demonstrate how private server logic is structured.

Step 1 — Install Node.js

Download and install Node.js if you don’t have it.

Step 2 — Create Project Folder

mkdir brawl-stars-server
cd brawl-stars-server

Step 3 — Initialize Project

npm init -y

Step 4 — Install Express

npm install express

Step 5 — Create server.js

Create a file named:

server.js

Paste this complete working code:

const express = require("express");
const app = express();
app.use(express.json());

// Player Database Simulation
let player = {
  username: "BrawlMaster",
  trophies: 1200,
  gems: 50,
  coins: 500,
  brawlers: ["Shelly", "Nita"]
};

// Home Route
app.get("/", (req, res) => {
  res.json({
    message: "Brawl Stars Private Server Concept Running",
    player
  });
});

// Add Gems
app.post("/add-gems", (req, res) => {
  const gems = req.body.gems || 1000;
  player.gems += gems;

  res.json({
    success: true,
    message: `${gems} Gems Added Successfully`,
    player
  });
});

// Unlock New Brawler
app.post("/unlock-brawler", (req, res) => {
  const brawler = req.body.name || "CustomBrawler";
  player.brawlers.push(brawler);

  res.json({
    success: true,
    message: `${brawler} Unlocked!`,
    player
  });
});

// Reset Account
app.post("/reset", (req, res) => {
  player.gems = 0;
  player.coins = 0;
  player.trophies = 0;
  player.brawlers = ["Shelly"];

  res.json({
    success: true,
    message: "Player Reset Completed",
    player
  });
});

// Start Server
app.listen(3000, () => {
  console.log("Brawl Stars Private Server Concept Running on Port 3000");
});

Step 6 — Run the Server

node server.js

Step 7 — Test Endpoints

Use Postman or any API tool.

View Player Data

GET:

http://localhost:3000/

Add Gems
POST:

http://localhost:3000/add-gems

Body (JSON):

{ "gems": 5000 }

Unlock Brawler
POST:


http://localhost:3000/unlock-brawler

Body:

{ "name": "Spike" }

Reset Player
POST:

http://localhost:3000/reset

Final Thoughts

A Brawl Stars private server is a dream playground where you can unlock everything, customize gameplay, and explore endless creativity. While real private servers are not legal to host or distribute, learning how such systems work from a coding perspective is incredibly valuable.

If you’re passionate about gaming and programming, experimenting with Brawl Stars private server logic using Node.js or any backend technology is an amazing way to level up your skills — without breaking any rules.

Building a New York Times Connections Solver with Python

Tariq Mehmood — Sat, 08 Nov 2025 05:03:41 +0000

If you’re a fan of word games, you’ve probably come across the puzzle from The New York Times called Connections. In this game you’re shown 16 words and you must split them into 4 groups of 4, each group sharing a hidden common theme.

Recently I built a Solver for this puzzle (or at least a helper tool) and in this post I’ll walk through how I approached it, the code that underlies it, and the challenges & trade-offs you’ll face when building something like this. If you’ve got your own favorite puzzle solver tools, I hope this inspires you to build one too.

What is NYT Connections & why build a solver?

The puzzle

Here’s a quick summary of the NYT Connections mechanics:

You have 16 words, in a 4x4 grid.
You must guess 4 sets of 4 words each, where each set shares some semantic (or playful) connection.
The categories are hidden, and each category is assigned a difficulty colour: yellow (easiest) → green → blue → purple (hardest).
You get a small number of guesses (four “lives”) to get all four groups.

Why build a solver?

There are several motivating factors:

Even though the puzzle looks simple, the hidden categories and subtle mis-directions (words that could belong to more than one group) make it hard. As one commentary put it, the game “makes you feel bad” because you keep tripping on the ambiguous connections.
raphkoster.com
Building a solver is an interesting programming challenge: how do you algorithmically detect which words belong together? How do you prioritise semantically-strong clusters vs wordplay?
It gives you a chance to explore natural-language processing (NLP) heuristics, embeddings, lexical resources, and design trade-offs between “fully automated solve” vs “hint-assisted helper”.
For me, I wanted a tool I could use when I’m stuck on a day’s puzzle—but also reflectively learn from (so I get better at the game).

Approach: High-level design

Here is the architecture I settled on:

Input parsing – read the 16 words for the day (either manually entered, or scraped from a source).
Feature extraction – for each word, compute semantic embeddings (via a pre-trained model), lexical attributes (like word length, part-of-speech, morphological features), and possibly co-occurrence / category-likeness features.
Candidate grouping – generate candidate groupings of 4 words from the 16 (combinatorial: C(16,4)=1820 possibilities), then evaluate each grouping via a scoring function that estimates “how likely these 4 share a theme”.
Backtracking / covering – once you pick one group, you remove those 4 words from consideration and repeat on the remaining 12, 8, then 4. Use heuristic search to pick the best covering of the 16 into 4 groups.
Ranking & hint output – output the best groupings, optionally highlight which category is likely easiest/hardest, or even reveal one word from the category as a “hint”.
User interface – a simple web UI (or CLI) where the user can paste the 16 words, press “Solve” or “Hint”, then see suggestions.

Below is a rough roadmap to the code segments.

Code walkthrough

I’ll use Python for the core solver logic + a minimal Flask (or FastAPI) web front-end. For embedding I’ll use the sentence-transformers library.

Setup & imports

# solver.py
import itertools
import numpy as np
from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity

# Optional: morphological / lexical features
import nltk
from nltk.corpus import wordnet as wn

Install via pip install sentence-transformers flask nltk sklearn etc.

Feature extraction

# Initialize embedding model
embed_model = SentenceTransformer('all-mpnet-base-v2')

def embed_words(words: list[str]) -> np.ndarray:
    """Compute embedding vectors for each word."""
    return embed_model.encode(words, convert_to_numpy=True, normalize_embeddings=True)

def lexical_features(word: str) -> dict:
    """Compute simple lexical features (length, synsets, POS etc)."""
    # For simplicity we just count synset counts
    synsets = wn.synsets(word)
    return {
        'length': len(word),
        'synset_count': len(synsets),
        # you can add more ...
    }

These features help us measure “just because the words are close in meaning” and also “how lexically connected” they might be.

Scoring a candidate group

def score_group(words: list[str], embeddings: np.ndarray, idx_map: dict) -> float:
    """
    Score how well these four words form a coherent group.
    Higher score = more likely “correct group”.
    Using cosine similarity among embeddings + lexical heuristics.
    """
    idxs = [ idx_map[w] for w in words ]
    sub_emb = embeddings[idxs]
    # compute pairwise cosine similarities
    sim_mat = cosine_similarity(sub_emb)
    # we only care off-diagonal elements
    n = len(words)
    sims = []
    for i in range(n):
        for j in range(i+1, n):
            sims.append(sim_mat[i,j])
    avg_sim = np.mean(sims)
    # lexical heuristics: e.g., if lengths are similar, more likely
    lengths = [ len(w) for w in words ]
    length_std = np.std(lengths)
    lex_score = 1.0 / (1.0 + length_std)  # smaller std → higher score
    # final combined score (weights tuned empirically)
    return avg_sim * 0.7 + lex_score * 0.3

What the above does: groups whose words are semantically close (high embedding cosine similarity) score better; also groups of words with similar length (or similar lexical shape) get a small bonus.

Generating candidates

def generate_all_groups(words: list[str], embeddings: np.ndarray) -> list[tuple[list[str], float]]:
    idx_map = { w : i for i,w in enumerate(words) }
    candidates = []
    for combo in itertools.combinations(words, 4):
        s = score_group(list(combo), embeddings, idx_map)
        candidates.append((list(combo), s))
    # sort descending
    candidates.sort(key=lambda x: x[1], reverse=True)
    return candidates

Selecting cover sets of 4 groups

def pick_best_cover(words: list[str], embeddings: np.ndarray, top_k=50):
    """
    From all candidate groups, pick top_k best,
    then try to pick combinations of them that cover the 16 words without overlap.
    Return best covering (list of 4 groups).
    """
    candidates = generate_all_groups(words, embeddings)[:top_k]
    best_cover = None
    best_score = -1
    # Try all combinations of 4 groups from top_k
    for groups in itertools.combinations(candidates, 4):
        group_words = [ tuple(g[0]) for g in groups ]
        # flatten and check overlap
        all_words = sum(group_words, ())
        if len(set(all_words)) == 16:
            # compute combined score
            score = sum(g[1] for g in groups)
            if score > best_score:
                best_score = score
                best_cover = groups
    return best_cover, best_score

The above brute-forces combinations of top candidate groups (limited to top_k) to find a cover of the 16 words into 4 non-overlapping groups. In practice you might need to prune, add heuristics and cutoffs if top_k is large.

Putting it all together

def solve_puzzle(words: list[str]):
    embeddings = embed_words(words)
    cover, score = pick_best_cover(words, embeddings, top_k=100)
    if cover is None:
        print("No non-overlapping cover found in top candidates; try increasing top_k.")
        return None
    # Return groups in descending score order
    groups_sorted = sorted(cover, key=lambda x: x[1], reverse=True)
    return [ g[0] for g in groups_sorted ]

Web interface (Flask)

# app.py
from flask import Flask, request, render_template
from solver import solve_puzzle

app = Flask(__name__)

@app.route('/', methods=['GET','POST'])
def home():
    if request.method == 'POST':
        text = request.form['words']
        words = [ w.strip() for w in text.split(',') if w.strip() ]
        if len(words) != 16:
            return render_template('index.html', error="Please enter exactly 16 comma-separated words.")
        groups = solve_puzzle(words)
        return render_template('index.html', groups=groups, original=words)
    return render_template('index.html')

if __name__ == "__main__":
    app.run(debug=True)

And the HTML template (templates/index.html) might look like:

<!doctype html>
<html>
<head><title>NYT Connections Solver</title></head>
<body>
  <h1>NYT Connections Solver</h1>
  {% if error %}
    <p style="color:red">{{ error }}</p>
  {% endif %}
  <form method="post">
    <textarea name="words" rows="4" cols="80" placeholder="Enter your 16 words, comma separated"></textarea><br>
    <button type="submit">Solve</button>
  </form>
  {% if groups %}
    <h2>Suggested Groups</h2>
    <ol>
    {% for grp in groups %}
      <li>{{ grp | join(', ') }}</li>
    {% endfor %}
    </ol>
  {% endif %}
</body>
</html>

What this solver achieves & its limitations

Achievements

It automates the tedious enumeration of candidate 4-word sets and ranks them by a plausible score.
It supports a hint mode: if you only want to see the top1 group first, you can show just the highest-scoring group, and then reveal more if needed.
It helps you learn: by seeing which groups the solver thinks are strongest, you can compare your intuition and perhaps improve your strategy.

Limitations & caveats

Embedding similarity is not enough: Many of the hardest categories in Connections rely on subtle word-play (e.g., words that sound like letters, puns, multi-word expressions) or very specific cultural references that embeddings don’t necessarily capture. As one academic paper points out, this puzzle is “a deceptively simple text classification task that stumps system-1 thinkers”.
arXiv
Overfitting/False positives: The solver might pick 4 words that are “very similar” in meaning (e.g., synonyms) but that don’t match what the NYT theme intended. The theme might be less about “meaning” and more about “sound”, or “prefix/suffix”, or “it appears in a phrase”.
Brute-force covering is expensive: For 16 words you can brute all combinations of 4 groups from 1820 candidate groups fairly easily, but if you wanted to extend to larger grids (say 20 words or bigger) it would scale poorly.
No guarantee of uniqueness: The real puzzle has exactly one solution, but the solver might find multiple plausible covers with similar scores. The user still needs human judgment to decide which one “fits” best.
No direct integration: This solver does not (and cannot legally) fetch the official NYT puzzle data automatically (without permission). So you’ll likely rely on manual entry of the 16 words or a scraping workaround (which may run afoul of terms of service).

UX & user-experience considerations

When I built the web UI I kept the following user-experience aspects in mind:

Minimal friction: Paste 16 words → click Solve → get results. No login required, no complex setup.
Progressive disclosure: Some users just want one hint (e.g., “give me the easiest category”). Others want the full solution. So I added a “Hint only” mode.
Highlighting uncertainty: Since the solver is approximate, I indicate a “confidence score” (e.g., grouped words with score > 0.8 are likely) and perhaps highlight groups with lower confidence so the user knows “this one might be wrong”.
Color-coding: Even though I don’t know the exact NYT colour assignment, I choose to display groups in order of descending score and label them “Likely easiest”, “Likely moderate”, etc.
Mobile friendly: Many users play the puzzle on mobile; so the web UI is responsive and the textarea is thoughtfully sized.
Educational value: I put an option “Explain why this group might work” which shows a small explanation (based on the lexical/embedding heuristics) so the user can learn: e.g., “These words are very close in embedding space” or “These words share a common prefix/suffix pattern”.
Respect for puzzle integrity: If you embed a full “solve” mode, you are essentially spoiling the puzzle; so I also added a moral disclaimer to encourage users to try the puzzle on their own first before using full solve mode.

Strategy & heuristics inspired by human players

When I studied how human players play Connections, I noticed some common heuristics and thinking-patterns. I built some of these into the solver (or at least tried to mimic them):

Scan for the obvious – Some groups are very straightforward (the so-called “Yellow” easiest category). For instance, “Monday”, “Tuesday”, “Wednesday”, “Thursday” might appear together as days of the week. Word-game blogs call this out.
Think about multi-meaning words / word-play – Some words in the grid may belong to multiple plausible groups, but the correct theme might hinge on a pun, a prefix, or a sound-alike. One Reddit comment:

“Watch out for words that seem to belong to multiple categories!”
My solver tries to penalise overly ambiguous candidates (e.g., words with many synsets).

Eliminate red herrings – The NYT puzzle makers often plant distractor words that look like they go in one category but don’t. For example, a word may appear to be a “color” but in fact is part of a phrase that links to something else. Recognising this helps. I introduced a heuristic: if a word easily fits several high-score groups, then maybe it’s a distractor.
Solve 3 groups and the last one falls in place – Many players recognise that once 12 words are grouped, the remaining 4 must form the final category. This reduces search space. One comment remarks:

“I fall for the traps all the damn time lol”

Final Thoughts

Building a NYT Connections Solver is a perfect small NLP project:

It’s conceptually simple.
It touches on embeddings, clustering, and visualization.
It’s fun and rewarding to see AI recognize human-like patterns.

This project taught me a lot about how meaning can be quantified — and how sometimes, even machines can make surprising connections.

Build a Smart Minecraft Auto-Farm Bot

Tariq Mehmood — Tue, 09 Sep 2025 04:53:32 +0000

If you’re like me, you love the grind in Minecraft… until you don’t.

Planting, harvesting, replanting—it’s satisfying at first, but once you’ve done it 40 times, it gets old. That’s when I thought:

“Wait a second… I write bots for the web. Why not for Minecraft?”

So I did. With a bit of Node.js, a fantastic library called mineflayer
, and some trial and error, I built a smart auto-farming bot that logs into my server, walks over to my farm, harvests crops, replants them, and chills until the next cycle.

What You’ll Need:

Before diving in, here's what you'll need:
A Minecraft Java Edition account
A local or hosted Minecraft server (supporting bots)
The mineflayer library
A basic understanding of JavaScript and game loops

Step 1: Set Up Your Project

Start fresh:

mkdir mc-auto-farmer
cd mc-auto-farmer
npm init -y
npm install mineflayer vec3

Then create your entry file:

touch farmer.js

Step 2: Connect to the Minecraft Server

Let’s start simple — login to Minecraft APK and spawn into the world.

// farmer.js
const mineflayer = require('mineflayer');

const bot = mineflayer.createBot({
  host: 'localhost', // your server IP
  port: 25565,        // default Minecraft port
  username: 'FarmBot3000' // no auth needed for offline servers
});

bot.on('spawn', () => {
  console.log('🧑‍🌾 Bot has spawned and is ready to farm!');
});

Run with:

node farmer.js

Boom. You're in.

Step 3: Walk to the Farm

Now we need to guide the bot to the crop area. We’ll manually define the coordinates.

const { Vec3 } = require('vec3');

const farmLocation = new Vec3(100, 64, 100); // change to your farm's coords

bot.on('spawn', () => {
  bot.chat('Heading to the farm!');
  bot.pathfinder.setGoal(new GoalBlock(farmLocation.x, farmLocation.y, farmLocation.z));
});

But wait — we forgot something. pathfinder!

Install and load it:

npm install mineflayer-pathfinder

And require it properly:

const { pathfinder, Movements, goals } = require('mineflayer-pathfinder');
const { GoalBlock } = goals;

bot.loadPlugin(pathfinder);

bot.on('spawn', () => {
  const defaultMove = new Movements(bot);
  bot.pathfinder.setMovements(defaultMove);
  bot.pathfinder.setGoal(new GoalBlock(farmLocation.x, farmLocation.y, farmLocation.z));
});

Now your bot will navigate to the farm like a good little NPC.

Step 4: Harvest + Replant Crops

This is the fun part.

We'll detect when the bot arrives, then scan for crops (like wheat) that are fully grown.

bot.on('goal_reached', async () => {
  bot.chat('🌾 Arrived at the farm. Looking for ripe crops...');

  const crops = bot.findBlocks({
    matching: block => block.name === 'wheat' && block.metadata === 7,
    maxDistance: 6,
    count: 20,
  });

  for (const pos of crops) {
    const block = bot.blockAt(pos);

    if (block) {
      await bot.dig(block); // harvest
      await bot.placeBlock(bot.blockAt(pos.offset(0, -1, 0)), new Vec3(0, 1, 0)); // replant
    }
  }

  bot.chat('✅ Farming complete. Waiting for next cycle...');
});

We’re using metadata === 7 because that means the wheat is fully grown.

Step 5: Loop It with a Timer

Let’s run this farming cycle every 5 minutes.

setInterval(() => {
  bot.chat('⏳ Checking crops again...');
  bot.pathfinder.setGoal(new GoalBlock(farmLocation.x, farmLocation.y, farmLocation.z));
}, 5 * 60 * 1000);

Optional: Add random intervals to make it less bot-like.

Final Thoughts

This project was a blast to build. Not only did I automate one of Minecraft’s most repetitive tasks, but I also learned how accessible Minecraft automation is with JavaScript.

Where to Take This Next

Add chest storage logic (deposit harvested wheat)
Support multiple crop types (carrots, potatoes, etc.)
Build a Discord bot to report farming stats
Use mineflayer’s inventory API to manage seeds/tools
Detect hostile mobs and run away

Bonus Ideas

Create a farming network of multiple bots
Connect your farm bot with a weather plugin (don’t farm in the rain)
Auto-craft bread from harvested wheat
Visualize farm productivity with a dashboard

Track Null’s Brawl Battle Logs Using Node.js

Tariq Mehmood — Wed, 27 Aug 2025 13:42:19 +0000

So, you’re deep into Null’s Brawl — enjoying unlimited gems, maxed-out brawlers, and all the skins you never had in the real game. But wouldn’t it be cool if you could track your battle logs, see how often you win, or even spot your most used brawlers in real-time?

Let’s build something useful: a Battle Log Tracker Bot that monitors your match history in Null’s Brawl, stores it, and gives you insights about your playstyle. We’ll use Node.js, Express, a fake battle log API simulation (since Null’s Brawl is a private server), and lowdb for local JSON-based data storage.

This is purely educational — for offline fun with Null's Brawl, not real Brawl Stars or for any competitive edge.

What You’ll Need

Node.js installed
Some knowledge of Express and async/await
curl or Postman to simulate API calls
A fake or emulated battle log API (we’ll mock this)
A text editor (VS Code preferred)
Coffee (because this is a long one!)

Step 1: Project Setup

mkdir nulls-brawl-log-bot
cd nulls-brawl-log-bot
npm init -y
npm install express axios lowdb dotenv node-cron

Then create the following files:

touch server.js api.js db.js .env

In .env, store your player tag:

PLAYER_TAG=#Y0URFAKETAG

Step 2: Mocking a Battle Log API

Since Null’s Brawl doesn’t have a real public API, we’ll mock it for the sake of this bot.

Create api.js:

// api.js
const mockLog = [
  {
    battleTime: new Date().toISOString(),
    result: 'victory',
    brawler: 'Shelly',
    mode: 'Gem Grab'
  },
  {
    battleTime: new Date(Date.now() - 60000).toISOString(),
    result: 'defeat',
    brawler: 'Colt',
    mode: 'Showdown'
  }
];

async function getBattleLog(tag) {
  // Simulate an API call delay
  await new Promise((r) => setTimeout(r, 500));
  return mockLog;
}

module.exports = { getBattleLog };

Step 3: Store Battle Logs with LowDB

In db.js:

const { Low, JSONFile } = require('lowdb');
const path = require('path');

const file = path.join(__dirname, 'db.json');
const adapter = new JSONFile(file);
const db = new Low(adapter);

async function initDB() {
  await db.read();
  db.data ||= { logs: [] };
  await db.write();
}

async function saveBattleLog(entries) {
  await initDB();
  const existing = db.data.logs.map((e) => e.battleTime);
  const newEntries = entries.filter((e) => !existing.includes(e.battleTime));
  db.data.logs.push(...newEntries);
  await db.write();
}

async function getAllLogs() {
  await initDB();
  return db.data.logs;
}

module.exports = { saveBattleLog, getAllLogs };

Step 4: Build the Express Server

Now let’s glue it together in server.js:

require('dotenv').config();
const express = require('express');
const cron = require('node-cron');
const { getBattleLog } = require('./api');
const { saveBattleLog, getAllLogs } = require('./db');

const app = express();
const port = 3000;

app.use(express.json());

// API route to fetch battle logs manually
app.get('/logs', async (req, res) => {
  const logs = await getAllLogs();
  res.json(logs);
});

// Get most used brawler
app.get('/top-brawler', async (req, res) => {
  const logs = await getAllLogs();
  const counts = {};

  logs.forEach(({ brawler }) => {
    counts[brawler] = (counts[brawler] || 0) + 1;
  });

  const sorted = Object.entries(counts).sort((a, b) => b[1] - a[1]);
  const [top, freq] = sorted[0] || ['None', 0];

  res.json({ topBrawler: top, timesUsed: freq });
});

Step 5: Automate Battle Log Fetching

Inside server.js, add a cron job that runs every 10 minutes:

cron.schedule('*/10 * * * *', async () => {
  const logs = await getBattleLog(process.env.PLAYER_TAG);
  await saveBattleLog(logs);
  console.log(`[BOT] Synced ${logs.length} battle logs at ${new Date().toISOString()}`);
});

app.listen(port, () => {
  console.log(`🎮 Null's Brawl Tracker Bot running at http://localhost:${port}`);
});

Bonus: Get Win Rate

Let’s add one more API to calculate win rate:

app.get('/winrate', async (req, res) => {
  const logs = await getAllLogs();
  const total = logs.length;
  const wins = logs.filter(l => l.result === 'victory').length;

  res.json({
    totalGames: total,
    wins,
    losses: total - wins,
    winRate: total ? ((wins / total) * 100).toFixed(2) + '%' : '0%'
  });
});

Test Everything

Start your bot:

node server.js

Then hit the endpoints:

/logs → See your synced battles
/top-brawler → Find your most used brawler
/winrate → Win/loss ratio

Next Steps: Go Bigger

Once your local tracker works, here’s what you could build next:

A dashboard with Chart.js or React
Store logs in a proper DB (like MongoDB)
Analyze mode-based performance (e.g., Gem Grab vs Showdown)
Add a CLI tool to run stats in terminal
Discord integration to post win rates

Final Thoughts

Null’s Brawl might not be official, but that doesn’t mean you can’t build real tools around it. With a little Node.js, some smart data tracking, and time, you can create your own analytics platform — even without an official API.

how to build a youtube clone with python

Tariq Mehmood — Sun, 24 Aug 2025 15:35:15 +0000

YouTube has transformed the way people consume video content, making it a giant in the digital entertainment industry. But what if you wanted to create your own mini-YouTube platform where users can upload, stream, and manage videos? Thanks to Python and its powerful frameworks like Flask and Django, this is entirely possible. In this article, we will walk through building a basic YouTube clone using Python with Flask. While it won’t match the scale and features of YouTube, this project will give you a strong understanding of how video streaming platforms work under the hood.

1) Quick setup

python -m venv .venv
# macOS/Linux
source .venv/bin/activate
# Windows
# .venv\Scripts\activate

pip install flask sqlalchemy flask-login werkzeug
mkdir uploads instance

Create app.py in an empty folder. We’ll add code progressively.

2) Minimal Flask app + database models

We’ll define Users, Videos, Comments, and Likes. SQLite keeps things simple.

app.py
import os
from datetime import datetime
from typing import Optional

from flask import Flask, request, redirect, url_for, render_template_string, abort, send_file, Response, flash, jsonify
from flask_login import LoginManager, UserMixin, login_user, logout_user, current_user, login_required
from werkzeug.security import generate_password_hash, check_password_hash
from werkzeug.utils import secure_filename

from sqlalchemy import create_engine, select, func, ForeignKey
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column, relationship, Session

BASE_DIR = os.path.abspath(os.path.dirname(__file__))
UPLOAD_DIR = os.path.join(BASE_DIR, "uploads")
os.makedirs(UPLOAD_DIR, exist_ok=True)

app = Flask(__name__, instance_relative_config=True)
app.config["SECRET_KEY"] = "dev-secret-change-me"
os.makedirs(app.instance_path, exist_ok=True)

# DB
engine = create_engine(f"sqlite:///{os.path.join(app.instance_path, 'app.db')}", echo=False)

class Base(DeclarativeBase): pass

class User(UserMixin, Base):
    __tablename__ = "users"
    id: Mapped[int] = mapped_column(primary_key=True)
    username: Mapped[str] = mapped_column(unique=True, index=True)
    password_hash: Mapped[str]
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
    videos: Mapped[list["Video"]] = relationship(back_populates="owner")
    def set_password(self, pw): self.password_hash = generate_password_hash(pw)
    def check_password(self, pw): return check_password_hash(self.password_hash, pw)

class Video(Base):
    __tablename__ = "videos"
    id: Mapped[int] = mapped_column(primary_key=True)
    title: Mapped[str] = mapped_column(index=True)
    description: Mapped[str] = mapped_column(default="")
    filename: Mapped[str]
    mimetype: Mapped[str]
    views: Mapped[int] = mapped_column(default=0)
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
    owner_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    owner: Mapped[User] = relationship(back_populates="videos")
    comments: Mapped[list["Comment"]] = relationship(back_populates="video", cascade="all, delete-orphan")
    likes: Mapped[list["Like"]] = relationship(back_populates="video", cascade="all, delete-orphan")

class Comment(Base):
    __tablename__ = "comments"
    id: Mapped[int] = mapped_column(primary_key=True)
    body: Mapped[str]
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    video_id: Mapped[int] = mapped_column(ForeignKey("videos.id"))
    video: Mapped[Video] = relationship(back_populates="comments")

class Like(Base):
    __tablename__ = "likes"
    id: Mapped[int] = mapped_column(primary_key=True)
    user_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    video_id: Mapped[int] = mapped_column(ForeignKey("videos.id"))
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)
    video: Mapped[Video] = relationship(back_populates="likes")

Base.metadata.create_all(engine)

login_manager = LoginManager(app)
login_manager.login_view = "login"

@login_manager.user_loader
def load_user(uid: str) -> Optional[User]:
    with Session(engine) as s:
        return s.get(User, int(uid))

3) Tiniest UI (embedded templates) and homepage

We’ll embed a minimal template for speed. Later you can split to real files.

TPL_BASE = """
<!doctype html><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1">
<title>{{ title or 'PyTube' }}</title>
<style>
body{margin:0;font-family:system-ui,Segoe UI,Roboto,Arial;background:#0b0e12;color:#e6edf3}
.container{max-width:1000px;margin:0 auto;padding:20px}
.nav{display:flex;gap:12px;align-items:center;justify-content:space-between}
.search{flex:1;margin:0 12px}
.search input{width:100%;padding:10px;border-radius:10px;border:1px solid #253041;background:#0f141b;color:#e6edf3}
.btn{background:#22c55e;border:none;padding:10px 14px;border-radius:10px;color:#052e12;font-weight:700;cursor:pointer}
.btn.outline{background:transparent;border:1px solid #2b3543;color:#e6edf3}
.card{background:#11161d;border:1px solid #1b2430;border-radius:16px;padding:12px;margin:12px 0}
.grid{display:grid;grid-template-columns:repeat(auto-fill,minmax(240px,1fr));gap:16px}
.thumb{aspect-ratio:16/9;background:#0f141b;border-radius:10px;display:flex;align-items:center;justify-content:center;border:1px dashed #2b3543}
.meta{font-size:12px;color:#a7b1c0}
.video{width:100%;background:#000;border-radius:12px;border:1px solid #1b2430}
.flash{padding:10px;border:1px solid #273141;border-radius:10px;background:#0f141b;margin:8px 0}
</style>
<div class="container">
  <div class="nav">
    <div style="display:flex;gap:12px;align-items:center">
      <a href="/" style="font-weight:800;text-decoration:none;color:#e6edf3">PyTube</a>
      <form class="search" method="get" action="{{ url_for('index') }}">
        <input name="q" placeholder="Search videos..." value="{{ q or '' }}">
      </form>
    </div>
    <div style="display:flex;gap:8px">
      {% if current_user.is_authenticated %}
        <a class="btn outline" href="{{ url_for('upload') }}">Upload</a>
        <a class="btn outline" href="{{ url_for('logout') }}">Logout</a>
      {% else %}
        <a class="btn outline" href="{{ url_for('login') }}">Log in</a>
        <a class="btn" href="{{ url_for('register') }}">Sign up</a>
      {% endif %}
    </div>
  </div>
  {% for c, m in get_flashed_messages(with_categories=true) %}<div class="flash">{{ m }}</div>{% endfor %}
  {% block content %}{% endblock %}
</div>
"""

TPL_INDEX = """
{% extends TPL_BASE %}
{% block content %}
<h2>Latest uploads{% if q %} matching “{{ q }}”{% endif %}</h2>
{% if videos %}
<div class="grid">
{% for v in videos %}
  <a class="card" href="{{ url_for('watch', video_id=v.id) }}" style="text-decoration:none;color:#e6edf3">
    <div class="thumb">▶</div>
    <div style="font-weight:700">{{ v.title }}</div>
    <div class="meta">{{ v.views }} views • {{ v.created_at.strftime('%b %d, %Y') }}</div>
  </a>
{% endfor %}
</div>
{% else %}
  <div class="card"><div class="meta">No videos yet. Be the first to upload!</div></div>
{% endif %}
{% endblock %}
"""

app.jinja_env.globals["TPL_BASE"] = TPL_BASE

@app.route("/")
def index():
    q = request.args.get("q", "").strip()
    with Session(engine) as s:
        stmt = select(Video).order_by(Video.created_at.desc())
        if q:
            stmt = select(Video).where(Video.title.ilike(f"%{q}%")).order_by(Video.created_at.desc())
        videos = s.scalars(stmt).all()
    return render_template_string(TPL_INDEX, videos=videos, q=q)

4) Authentication (register, login, logout)

A clean, minimal form flow using flask-login.

TPL_AUTH = """
{% extends TPL_BASE %}
{% block content %}
<h2>{{ 'Create an account' if mode=='register' else 'Log in' }}</h2>
<form method="post" class="card">
  <label>Username</label><input name="username">
  <label>Password</label><input type="password" name="password">
  <button class="btn" type="submit">{{ 'Sign up' if mode=='register' else 'Log in' }}</button>
</form>
{% endblock %}
"""

@app.route("/register", methods=["GET","POST"])
def register():
    if request.method == "POST":
        u = request.form.get("username","").strip()
        p = request.form.get("password","")
        if len(u) < 3 or len(p) < 6:
            flash("Username or password too short.", "error")
        else:
            with Session(engine) as s:
                exists = s.scalar(select(func.count(User.id)).where(User.username==u)) > 0
                if exists:
                    flash("Username already taken.", "error")
                else:
                    user = User(username=u); user.set_password(p)
                    s.add(user); s.commit()
                    flash("Account created. Please log in.", "success")
                    return redirect(url_for("login"))
    return render_template_string(TPL_AUTH, mode="register")

@app.route("/login", methods=["GET","POST"])
def login():
    if request.method == "POST":
        u = request.form.get("username","").strip()
        p = request.form.get("password","")
        with Session(engine) as s:
            user = s.scalar(select(User).where(User.username==u))
            if user and user.check_password(p):
                login_user(user); flash("Welcome back!", "success")
                return redirect(url_for("index"))
        flash("Invalid credentials.", "error")
    return render_template_string(TPL_AUTH, mode="login")

@app.route("/logout")
@login_required
def logout():
    logout_user(); flash("Logged out.", "success")
    return redirect(url_for("index"))

5) Upload videos

We’ll accept .mp4, .webm, .ogg, .m4v. Filenames are sanitized and de-duplicated.

ALLOWED_EXTS = {".mp4", ".webm", ".ogg", ".m4v"}
def allowed(name): return os.path.splitext(name.lower())[1] in ALLOWED_EXTS

TPL_UPLOAD = """
{% extends TPL_BASE %}
{% block content %}
<h2>Upload a video</h2>
<form method="post" enctype="multipart/form-data" class="card">
  <label>Title</label><input name="title">
  <label>Description</label><textarea name="description" rows="3"></textarea>
  <label>File</label><input type="file" name="file" accept="video/*,.mp4,.webm,.ogg,.m4v">
  <button class="btn" type="submit">Upload</button>
</form>
{% endblock %}
"""

@app.route("/upload", methods=["GET","POST"])
@login_required
def upload():
    if request.method == "POST":
        title = request.form.get("title","").strip()
        desc = request.form.get("description","").strip()
        f = request.files.get("file")
        if not title or not f or not f.filename:
            flash("Title and file are required.", "error")
        elif not allowed(f.filename):
            flash("Unsupported file type.", "error")
        else:
            name = secure_filename(f.filename)
            base, ext = os.path.splitext(name)
            dest = os.path.join(UPLOAD_DIR, name)
            i = 1
            while os.path.exists(dest):
                name = f"{base}_{i}{ext}"; dest = os.path.join(UPLOAD_DIR, name); i += 1
            f.save(dest)
            with Session(engine) as s:
                v = Video(title=title, description=desc, filename=name, mimetype=f.mimetype or "video/mp4",
                          owner_id=current_user.id)
                s.add(v); s.commit()
                flash("Uploaded!", "success")
                return redirect(url_for("watch", video_id=v.id))
    return render_template_string(TPL_UPLOAD)

6) Range-aware streaming endpoint

This is the secret sauce. It supports scrubbing and fast starts.

def partial_response(path, mimetype):
    size = os.path.getsize(path)
    rng = request.headers.get("Range")
    if rng:
        # e.g. "bytes=1000-2000"
        units, _, spec = rng.partition("=")
        if units != "bytes": abort(416)
        start_s, _, end_s = spec.partition("-")
        try:
            start = int(start_s) if start_s else 0
            end = int(end_s) if end_s else size - 1
        except ValueError:
            abort(416)
        start = max(0, start); end = min(size - 1, end)
        length = end - start + 1
        with open(path, "rb") as fp:
            fp.seek(start)
            data = fp.read(length)
        resp = Response(data, 206, mimetype=mimetype, direct_passthrough=True)
        resp.headers.add("Content-Range", f"bytes {start}-{end}/{size}")
        resp.headers.add("Accept-Ranges", "bytes")
        resp.headers.add("Content-Length", str(length))
        return resp
    return send_file(path, mimetype=mimetype, as_attachment=False)

@app.route("/stream/<int:video_id>")
def stream(video_id: int):
    with Session(engine) as s:
        v = s.get(Video, video_id) or abort(404)
    path = os.path.join(UPLOAD_DIR, v.filename)
    if not os.path.exists(path): abort(404)
    return partial_response(path, v.mimetype)

7) Watch page (player + views counter)

We render a <video> player that points to our Range endpoint.

TPL_WATCH = """
{% extends TPL_BASE %}
{% block content %}
<div class="card">
  <video class="video" controls preload="metadata">
    <source src="{{ url_for('stream', video_id=v.id) }}" type="{{ v.mimetype }}">
    Your browser does not support the video tag.
  </video>
  <h2 style="margin:6px 0 0">{{ v.title }}</h2>
  <div class="meta">{{ v.views }} views • {{ v.created_at.strftime('%b %d, %Y') }}</div>
  {% if v.description %}<p style="margin-top:8px">{{ v.description }}</p>{% endif %}
</div>
{% endblock %}
"""

@app.route("/v/<int:video_id>")
def watch(video_id: int):
    with Session(engine) as s:
        v = s.get(Video, video_id) or abort(404)
        v.views += 1; s.commit()
    return render_template_string(TPL_WATCH, v=v)

Also if you want to download youtube videos then must download snaptube apk.

8) Likes (AJAX) and comments (form)

Small, friendly community features.

# Like toggle: returns JSON {count: <int>}
@app.route("/like/<int:video_id>", methods=["POST"])
@login_required
def like(video_id: int):
    with Session(engine) as s:
        v = s.get(Video, video_id) or abort(404)
        existing = s.scalar(select(Like).where(Like.video_id==video_id, Like.user_id==current_user.id))
        if existing:
            s.delete(existing); s.commit()
        else:
            s.add(Like(video_id=video_id, user_id=current_user.id)); s.commit()
        count = s.scalar(select(func.count(Like.id)).where(Like.video_id==video_id)) or 0
    return jsonify({"count": count})

Update the watch template to show a like button and a comment box:

TPL_WATCH = """
{% extends TPL_BASE %}
{% block content %}
<div class="card">
  <video class="video" controls preload="metadata">
    <source src="{{ url_for('stream', video_id=v.id) }}" type="{{ v.mimetype }}">
  </video>
  <h2 style="margin:6px 0 0">{{ v.title }}</h2>
  <div class="meta">{{ v.views }} views • {{ v.created_at.strftime('%b %d, %Y') }}</div>
  <div style="display:flex;gap:10px;align-items:center;margin-top:8px">
    <button class="btn" onclick="likeVideo({{ v.id }})">♥ Like</button>
    <div class="meta">Likes: <span id="likeCount">{{ like_count }}</span></div>
  </div>
  {% if v.description %}<p style="margin-top:8px">{{ v.description }}</p>{% endif %}
</div>

<div class="card">
  <h3>Comments</h3>
  {% if current_user.is_authenticated %}
    <form method="post" action="{{ url_for('comment', video_id=v.id) }}">
      <input name="body" placeholder="Say something nice…" style="width:100%;margin-bottom:8px">
      <button class="btn" type="submit">Post</button>
    </form>
  {% else %}
    <div class="meta">Log in to comment.</div>
  {% endif %}
  {% for c in comments %}
    <div style="padding:10px;border:1px solid #273141;border-radius:10px;background:#0f141b;margin-top:8px">
      <div class="meta">{{ c.created_at.strftime('%b %d, %Y') }}</div>
      <div style="margin-top:4px">{{ c.body }}</div>
    </div>
  {% else %}
    <div class="meta">No comments yet.</div>
  {% endfor %}
</div>

<script>
async function likeVideo(id){
  const res = await fetch(`/like/${id}`, {method:'POST'});
  const data = await res.json();
  const el = document.querySelector('#likeCount');
  if(el){ el.textContent = data.count; }
}
</script>
{% endblock %}
"""

@app.route("/v/<int:video_id>")
def watch(video_id: int):
    with Session(engine) as s:
        v = s.get(Video, video_id) or abort(404)
        v.views += 1; s.commit()
        comments = s.scalars(select(Comment).where(Comment.video_id==v.id).order_by(Comment.created_at.desc())).all()
        like_count = s.scalar(select(func.count(Like.id)).where(Like.video_id==v.id)) or 0
    return render_template_string(TPL_WATCH, v=v, comments=comments, like_count=like_count)

@app.route("/comment/<int:video_id>", methods=["POST"])
@login_required
def comment(video_id: int):
    body = request.form.get("body","").strip()
    if not body: flash("Comment cannot be empty.", "error")
    else:
        with Session(engine) as s:
            v = s.get(Video, video_id) or abort(404)
            s.add(Comment(body=body, user_id=current_user.id, video_id=video_id)); s.commit()
            flash("Comment posted!", "success")
    return redirect(url_for("watch", video_id=video_id))

9) Search on the homepage

We already wired a query param q in Step 2. Try it: type a word and hit Enter. It filters by title using case-insensitive ilike.

10) Run the app

python app.py

# Open http://127.0.0.1:5000
# 1) Register  2) Log in  3) Upload a small .mp4  4) Click the video
# Drag the scrubber — Range streaming should work smoothly.

Final notes

A “YouTube clone” is just well-known web primitives—uploads, byte ranges, a few tables—combined thoughtfully. Start with this skeleton, confirm streaming works, then iterate toward thumbnails, HLS, and scale.

Automate Your Spotify Playlists Using Node.js

Tariq Mehmood — Sat, 23 Aug 2025 16:54:24 +0000

If you're tired of hitting "Repeat" on the same songs or spending hours tweaking playlists, this project is for you.

Imagine a Spotify bot that listens with you — detecting your preferences, learning your moods, and generating personalized playlists that evolve as your music taste shifts. Thanks to the power of Node.js and the Spotify Web API, this isn't just possible — it's easier than you might think.

In this article, we’ll build a Smart Spotify Bot that uses real audio features and behavior analysis to automatically generate custom playlists. Whether you want upbeat tracks for workouts or mellow vibes for coding, this bot has you covered.

Tools You’ll Need

A Spotify Developer Account
A registered Spotify app (Client ID, Client Secret)
Node.js & npm
REST & OAuth 2.0 basics
A code editor like VS Code
Your favorite music taste

Project Overview

Here’s what our bot will do:

Authenticate the user (OAuth 2.0)
Pull top tracks from Spotify
Analyze them using Spotify’s audio features (like danceability, tempo, etc.)
Apply smart filters to find tracks that match your desired mood
Create a playlist and fill it with those tracks
Optionally, automate it on a schedule or extend it with genre/mood filters

Step 1: Set Up Spotify App & Environment

1. Create a Spotify App

Go to the Spotify Developer Dashboard
, create an app, and set your Redirect URI (e.g., http://localhost:8888/callback).

2. Initialize Node Project

mkdir smart-spotify-bot && cd smart-spotify-bot
npm init -y
npm install express axios dotenv querystring open

3. Create .env

SPOTIFY_CLIENT_ID=your_client_id
SPOTIFY_CLIENT_SECRET=your_client_secret
SPOTIFY_REDIRECT_URI=http://localhost:8888/callback

Step 2: Build the OAuth Flow with Express

// auth.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const querystring = require('querystring');
const open = require('open');

const app = express();
const PORT = 8888;

const SCOPES = [
  'user-read-private',
  'playlist-modify-public',
  'user-top-read'
].join(' ');

app.get('/login', (req, res) => {
  const params = querystring.stringify({
    response_type: 'code',
    client_id: process.env.SPOTIFY_CLIENT_ID,
    scope: SCOPES,
    redirect_uri: process.env.SPOTIFY_REDIRECT_URI,
  });
  res.redirect(`https://accounts.spotify.com/authorize?${params}`);
});

app.get('/callback', async (req, res) => {
  const code = req.query.code;

  try {
    const tokenRes = await axios.post('https://accounts.spotify.com/api/token',
      querystring.stringify({
        code,
        redirect_uri: process.env.SPOTIFY_REDIRECT_URI,
        grant_type: 'authorization_code',
      }),
      {
        headers: {
          Authorization: 'Basic ' + Buffer.from(
            `${process.env.SPOTIFY_CLIENT_ID}:${process.env.SPOTIFY_CLIENT_SECRET}`
          ).toString('base64'),
          'Content-Type': 'application/x-www-form-urlencoded',
        },
      }
    );

    const { access_token, refresh_token } = tokenRes.data;
    console.log('Access Token:', access_token);
    console.log('Refresh Token:', refresh_token);

    res.send('✅ Auth complete. Check your console.');
  } catch (err) {
    console.error('Error:', err.response.data);
    res.send('❌ Failed to authenticate.');
  }
});

app.listen(PORT, () => {
  console.log(`🔐 Go to http://localhost:${PORT}/login`);
  open(`http://localhost:${PORT}/login`);
});

Run it:

node auth.js

Step 3: Fetch and Filter Top Tracks

Get Top Tracks

async function getTopTracks(token) {
  const res = await axios.get('https://api.spotify.com/v1/me/top/tracks?limit=20', {
    headers: { Authorization: `Bearer ${token}` },
  });
  return res.data.items;
}

Get Audio Features

async function getAudioFeatures(token, trackIds) {
  const res = await axios.get(`https://api.spotify.com/v1/audio-features?ids=${trackIds.join(',')}`, {
    headers: { Authorization: `Bearer ${token}` },
  });
  return res.data.audio_features;
}

Step 4: Filter by Mood and Create Playlist

function filterTracksByMood(tracks, features) {
  return tracks.filter((_, i) => {
    const f = features[i];
    return f.energy > 0.65 && f.valence > 0.5 && f.danceability > 0.6;
  });
}

async function createPlaylist(token, userId, name) {
  const res = await axios.post(`https://api.spotify.com/v1/users/${userId}/playlists`, {
    name,
    description: 'Auto-generated by Smart Spotify Bot',
    public: false
  }, {
    headers: {
      Authorization: `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });
  return res.data.id;
}

async function addTracksToPlaylist(token, playlistId, uris) {
  await axios.post(`https://api.spotify.com/v1/playlists/${playlistId}/tracks`, {
    uris
  }, {
    headers: {
      Authorization: `Bearer ${token}`,
      'Content-Type': 'application/json'
    }
  });
}

Step 5: Run the Bot

async function runSmartBot(token) {
  const topTracks = await getTopTracks(token);
  const trackIds = topTracks.map(t => t.id);
  const features = await getAudioFeatures(token, trackIds);

  const filtered = filterTracksByMood(topTracks, features);
  const uris = filtered.map(t => t.uri);

  const me = await axios.get('https://api.spotify.com/v1/me', {
    headers: { Authorization: `Bearer ${token}` }
  });
  const userId = me.data.id;

  const playlistId = await createPlaylist(token, userId, '🎶 Auto Vibes');
  await addTracksToPlaylist(token, playlistId, uris);

  console.log(`✅ Created playlist with ${uris.length} tracks`);
}

Expand the Bot

You’ve got a working APK Spotify Premium playlist generator — but this is just the beginning. Here are some ideas to take it further:

Schedule It

Use node-cron to run the bot weekly or daily.

Genre-Based Filters

Filter by genres like chill, rock, or EDM using track metadata.

Mood Detection by Time/Weather

Use APIs (like OpenWeather) to change playlist themes based on real-time data.

Save Listening Data

Store user track data in a database to analyze trends and evolve the playlist algorithm over time.

Final Thoughts

Spotify’s API is an amazing playground for creative automation. With a few lines of JavaScript and a bit of logic, you can build a personal music assistant that adapts to you — not the other way around.

Start small, build something fun, and before you know it, you’ll have a smart music ecosystem that plays what you love, when you love it.

Ready to build your own music butler? 🎶
Go fork this into your next project and let your code curate your vibe.

Create a Smart Spotify Bot with Node.js & Web API

Tariq Mehmood — Fri, 15 Aug 2025 04:23:03 +0000

If you’re like me, your playlists are your digital mixtapes – carefully curated soundtracks for workouts, chill sessions, work grinds, or late-night drives. But building and maintaining them manually? That can be a drag.

That’s when I had this idea:

What if I could write a bot that builds playlists based on my listening habits, audio features, and moods – automatically?

With the power of the Spotify Web API, a little bit of Node.js, and some creative logic, I built a small utility bot that does just that. In this post, I’ll walk you through how you can build your own Spotify Playlist Curator Bot that creates smart playlists based on your taste.

What You’ll Need

Before we dive into code, let’s list the requirements:

A Spotify Developer Account
A Spotify App with its Client ID and Client Secret
A Node.js project setup
Some basic familiarity with JavaScript, OAuth2, and REST APIs
A text editor (I used VS Code)
And of course, your music taste

Step 1: Authenticate with Spotify (OAuth 2.0 Authorization Code Flow)

Spotify requires OAuth2 to access user data, so the first thing we need is to authenticate the user and obtain an access token.

Here’s a quick setup using the express framework and axios to handle HTTP requests:

1. Setup your environment:

npm init -y
npm install express axios dotenv querystring open

Create a .env file:

SPOTIFY_CLIENT_ID=your_client_id_here
SPOTIFY_CLIENT_SECRET=your_client_secret_here
SPOTIFY_REDIRECT_URI=http://localhost:8888/callback

2. Create a basic Express server

// server.js
require('dotenv').config();
const express = require('express');
const axios = require('axios');
const querystring = require('querystring');
const open = require('open');

const app = express();
const port = 8888;

const SCOPES = [
  'user-read-private',
  'user-read-email',
  'playlist-modify-public',
  'playlist-modify-private',
  'user-top-read',
].join(' ');

app.get('/login', (req, res) => {
  const queryParams = querystring.stringify({
    response_type: 'code',
    client_id: process.env.SPOTIFY_CLIENT_ID,
    scope: SCOPES,
    redirect_uri: process.env.SPOTIFY_REDIRECT_URI,
  });

  res.redirect(`https://accounts.spotify.com/authorize?${queryParams}`);
});

app.get('/callback', async (req, res) => {
  const code = req.query.code;

  try {
    const response = await axios.post(
      'https://accounts.spotify.com/api/token',
      querystring.stringify({
        grant_type: 'authorization_code',
        code,
        redirect_uri: process.env.SPOTIFY_REDIRECT_URI,
      }),
      {
        headers: {
          Authorization:
            'Basic ' +
            Buffer.from(
              `${process.env.SPOTIFY_CLIENT_ID}:${process.env.SPOTIFY_CLIENT_SECRET}`
            ).toString('base64'),
          'Content-Type': 'application/x-www-form-urlencoded',
        },
      }
    );

    const { access_token, refresh_token } = response.data;

    res.send('✅ Authenticated. Now you can close this tab and run your bot.');
    console.log('Access Token:', access_token);
    console.log('Refresh Token:', refresh_token);

    // Store these tokens securely or pass to your bot logic
  } catch (err) {
    console.error('Error fetching access token:', err.response.data);
    res.send('Authentication failed.');
  }
});

app.listen(port, () => {
  console.log(`> Visit http://localhost:${port}/login to authenticate`);
  open(`http://localhost:${port}/login`);
});

Run this with:

node server.js

Once authenticated, you'll get your tokens in the console.

Step 2: Get User's Top Tracks

Spotify allows access to the user's most played tracks over different time ranges. Let's use that to seed our playlist.

async function getTopTracks(token, time_range = 'short_term') {
  const response = await axios.get(
    `https://api.spotify.com/v1/me/top/tracks?limit=20&time_range=${time_range}`,
    {
      headers: {
        Authorization: `Bearer ${token}`,
      },
    }
  );

  return response.data.items;
}

You can choose time ranges like:

short_term (last 4 weeks)
medium_term (last 6 months)
long_term (all time)

Step 3: Analyze Tracks & Create Playlist

Spotify Premium APK offers audio features for every track — things like danceability, energy, tempo, and valence (positivity).

async function getAudioFeatures(token, trackIds) {
  const ids = trackIds.join(',');
  const response = await axios.get(
    `https://api.spotify.com/v1/audio-features?ids=${ids}`,
    {
      headers: {
        Authorization: `Bearer ${token}`,
      },
    }
  );

  return response.data.audio_features;
}

Based on this, let’s filter tracks with:

danceability > 0.7
energy > 0.6
valence > 0.5

You can adjust this for your mood.

Now Create the Playlist:

async function createPlaylist(token, userId, name, description) {
  const response = await axios.post(
    `https://api.spotify.com/v1/users/${userId}/playlists`,
    {
      name,
      description,
      public: false,
    },
    {
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    }
  );

  return response.data.id;
}

And finally, add songs:

async function addTracksToPlaylist(token, playlistId, uris) {
  await axios.post(
    `https://api.spotify.com/v1/playlists/${playlistId}/tracks`,
    {
      uris,
    },
    {
      headers: {
        Authorization: `Bearer ${token}`,
        'Content-Type': 'application/json',
      },
    }
  );
}

Putting It All Together

Here’s the logic of the final bot:

async function runBot(accessToken) {
  const topTracks = await getTopTracks(accessToken, 'short_term');
  const trackIds = topTracks.map(track => track.id);

  const features = await getAudioFeatures(accessToken, trackIds);

  const filteredTracks = topTracks.filter((track, i) => {
    const f = features[i];
    return f && f.danceability > 0.7 && f.energy > 0.6 && f.valence > 0.5;
  });

  const uris = filteredTracks.map(track => track.uri);

  const me = await axios.get('https://api.spotify.com/v1/me', {
    headers: { Authorization: `Bearer ${accessToken}` },
  });

  const userId = me.data.id;

  const playlistId = await createPlaylist(
    accessToken,
    userId,
    '💃 Curated Mood Booster',
    'Auto-curated feel-good tracks based on your recent listening habits.'
  );

  await addTracksToPlaylist(accessToken, playlistId, uris);

  console.log(`✅ Playlist created with ${uris.length} tracks!`);
}

Final Thoughts

This project was a blast.

What I love about this is how easy it is to build something meaningful with tools like Node.js and the Spotify Web API. With a few API calls and some logic, you’ve got a personal DJ assistant that creates vibe-based playlists for you.

You can take this further:

Schedule the bot to run weekly with a cron job
Email yourself a summary of your top tracks
Analyze genres or artists
Build mood-based playlists for different times of day

🧪 Bonus: Ideas to Expand

Add a web dashboard using React or Vue
Store history of generated playlists
Use AI/ML to predict mood from listening patterns
Integrate with Discord to share playlists

How to Connect Spotify to Discord

Tariq Mehmood — Mon, 04 Aug 2025 10:34:15 +0000

If you’re someone who loves music and spends a lot of time chatting with friends on Discord, connecting your Spotify account can take your experience to the next level. Whether you're streaming your favorite playlist during a gaming session or just want to show off what you're listening to, integrating Spotify with Discord is a simple but powerful feature.

In this guide, we’ll walk you through everything you need to know about how to connect Spotify to Discord—step by step. We’ll also cover a few extra tips, like how to display your music status, what to do if Spotify isn’t showing up, and how to unlink your account if needed.

Why Connect Spotify to Discord?

Before we jump into the how-to, let’s look at why you might want to link Spotify with Discord in the first place.

Here are a few benefits:

Share your music status: Others can see what you’re listening to in real-time.
Listen along with friends: If you have Spotify Premium APK iOS, you can listen to music in sync with friends who are also Premium users.
Perfect for gaming sessions: Background music while voice chatting adds to the fun.
Makes your profile more interesting: It’s a great conversation starter when someone sees you vibing to the same band or artist.

Prerequisites: What You’ll Need

Before getting started, make sure you have:

A Spotify account (Free or Premium)
A Discord account
The Discord app (desktop or mobile) or access to Discord via web

While both free and premium Spotify accounts can be connected, the “Listen Along” feature is limited to Spotify Premium users.

How to Connect Spotify to Discord (Desktop)

Step 1: Open Discord and Go to User Settings

Launch the Discord desktop app or log in via browser.
Click the gear icon ⚙️ next to your username in the lower-left corner. This opens the User Settings menu.

Step 2: Go to "Connections"

In the left-hand menu, scroll down and select Connections.
Here, you'll see a list of services you can connect to Discord, such as Twitch, YouTube, Reddit, and Spotify.

Step 3: Click the Spotify Icon

Click on the Spotify icon.
A new browser window will open asking you to log in to Spotify.
Enter your Spotify credentials and allow the necessary permissions.

Step 4: Customize Your Settings

Once connected, you’ll see a green Spotify box under your Connections tab. You can toggle the following:

Display on profile – Shows the Spotify icon and currently playing track on your Discord profile.
Display Spotify as your status – Shows the song you’re currently listening to underneath your username.

And that’s it! You’re connected.

How to Connect Spotify to Discord (Mobile)

The process is similar on mobile, though the layout is slightly different.

Step 1: Open Discord App

Launch the Discord app on your iOS or Android device.

Step 2: Access User Settings

Tap your profile icon at the bottom right to access User Settings.

Step 3: Tap “Connections”

Scroll and tap on Connections. If you’re not already logged in on Spotify through your phone’s browser, you’ll be prompted to sign in.

Step 4: Select Spotify

Tap the Spotify logo and log in with your Spotify credentials when prompted.

Once the connection is successful, your settings will sync across both mobile and desktop platforms.

Listen Along Feature

One of the coolest integrations is the “Listen Along” feature. It allows you and your friends to listen to the same song at the same time inside a voice channel or DMs.

To use Listen Along:

Make sure you and your friends have Spotify Premium.
Play a song on Spotify.
Your friends will see a “Listen Along” button next to your profile in Discord.
They can click it to sync playback with you.
This feature is perfect for hosting mini listening

What is Astrological Profile on Snapchat?

Tariq Mehmood — Thu, 17 Jul 2025 06:06:23 +0000

Snapchat is known for its fun and creative features — from playful filters to interactive stories. But beyond the surface-level fun, it also offers something a bit more personal: the Astrological Profile. This feature, available to users who add their birthday and birth time, gives you insights into your zodiac sign, rising sign, and deeper elements of your natal chart — all within the Snapchat app.

In this post, we’ll explore what Snapchat’s Astrological Profile is, how it works, what it reveals about you, and why many users enjoy sharing and comparing their astrological insights with friends.

What Is the Astrological Profile on Snapchat?

The Astrological Profile on Snapchat is a personalized birth chart, also known as a natal chart, which shows the positions of the planets at the exact time and place of your birth. Snapchat uses your birthday, birth time, and birth location to generate this chart and then presents it in an easy-to-understand, friendly layout.

This profile reveals more than just your Sun sign (like Leo or Scorpio); it also includes your Moon sign, Rising sign (Ascendant), and the planetary placements for Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune, and Pluto.

Snapchat simplifies astrology by providing a breakdown of these signs and what they say about your personality, emotions, communication style, and more.

How to Set Up Your Astrological Profile on Snapchat

Creating your Astrological Profile on Snapchat is easy and takes just a minute or two:

Open Snapchat and tap on your Bitmoji (top-left corner).
Tap the purple zodiac symbol (if you've already entered your birthdate).
You’ll be asked to input your birth time and birthplace.
Once you submit, Snapchat will generate your full astrological profile.

If you don’t see the zodiac icon, make sure your birthday is added to your profile first. You can do this from the settings menu.

Note: Your information is kept private unless you choose to share it.

What Information Does Snapchat’s Astrological Profile Show?

Once your profile is ready, Snapchat gives you:

Sun Sign
Your Sun sign reflects your core identity and personality — what most people associate with zodiac signs. It's based on your birthday.
Moon Sign
This sign governs your emotions and inner self. It shows how you deal with feelings and emotional responses.
Rising Sign (Ascendant)
The rising sign indicates how others perceive you — your outward style and first impression.
Planetary Placements
Each Snapchat Best Friend planet is tied to a specific part of your personality:

Mercury – Communication
Venus – Love and beauty
Earth - Beauty
Mars – Drive and energy
Jupiter – Luck and growth
Saturn – Discipline and responsibility
Uranus – Innovation and change
Neptune – Dreams and intuition

Snapchat gives short, clear explanations of what each placement means, making astrology more approachable even for beginners.

Can You See Astrological Compatibility on Snapchat?

Yes! Snapchat also offers Astrological Compatibility with your friends — but only if both of you have completed your profiles. When you tap on a friend’s profile who has also entered their astrological details, you can view a compatibility summary.

This includes comparisons like:

Emotional connection (Moon signs)
Communication style (Mercury)
Love and romance (Venus)

You’ll see emojis, short explanations, and how the stars align between you and your friend. It’s a fun way to explore your friendships (or something more).

Is It Safe to Share Your Astrological Profile?

Snapchat is clear about user privacy. Your Astrological Profile is not visible to others unless you choose to share it. You can also manage who sees your birthday and zodiac info from your privacy settings.

If you’re not comfortable sharing your exact birth time or location, you can skip the deeper parts — though that will limit the accuracy of your chart.

Why Do People Love the Astrological Profile Feature?

Snapchat has taken something often seen as complicated and made it feel light, friendly, and easy to connect with. Here’s why users enjoy it:

Self-discovery: It helps users learn more about themselves.
Friendship fun: Comparing charts and compatibility is a great icebreaker.
Aesthetic appeal: The visuals and emojis make astrology fun and digestible.
Privacy control: You’re always in control of what you share.

Whether you're a true believer in astrology or just curious, the Astrological Profile adds a personal touch to your Snapchat experience.

Final Thoughts

Snapchat’s Astrological Profile is more than just a novelty. It blends ancient zodiac wisdom with a modern, visual twist — helping users reflect on their traits and connect with others on a deeper level. You don’t need to be an astrology expert to enjoy it, and Snapchat does a great job of guiding you through the process.

If you haven’t tried it yet, go ahead and explore your birth chart inside the app. You might learn something new about yourself — or find out why you click so well with your best friend!

Playback and Offline Download Issues with Spotify Premium

Tariq Mehmood — Mon, 06 Jan 2025 07:16:59 +0000

I’ve been experiencing issues with Spotify Premium App that are affecting my overall listening experience. Despite having a stable internet connection, playback often lags or buffers for extended periods, which disrupts the flow of music. Additionally, offline downloads frequently fail or disappear, even though the songs were marked for offline listening. These problems persist across devices, making it difficult to enjoy the premium features I’ve subscribed to.