Ghulam Mujtaba

Cleaning Up the LinkedIn Feed with a Tampermonkey Userscript

2026-10-06T00:00:00+00:00

I got tired of scrolling past unrelated content on LinkedIn. Between promoted posts, “Recommended for you” blocks, and posts from people I have never met that showed up only because a stranger reacted to them, most of my home feed had nothing to do with my network. So I wrote a small userscript that cleans it up and keeps what I care about.

It is free to use, tweak, or fork: LinkedIn Cleanup on GitHub Gist.

What It Hides

The script only runs on the home feed (linkedin.com/ and linkedin.com/feed/). Profiles, messaging, and search are left alone, and when you navigate away from the feed it restores everything it changed.

On the feed, it hides:

The right sidebar, including LinkedIn News and the puzzles widget.
Promoted and sponsored posts.
Recommendation blocks such as “Recommended for you”, “Add to your feed”, and “People you may know”.
Posts whose author is a 2nd or 3rd+ degree connection.
Activity posts that appear only because someone “finds this funny”, “finds this curious”, or “follows” someone.
Upsell links in the left column, such as “Try Premium Page” and “Advertise on LinkedIn”.
The messaging drawer at the bottom of the feed. The “Message” button on profiles still works.

What It Keeps

Hiding everything from outside your network would also remove posts your connections are actively engaging with, which are often the useful ones. So the script keeps a post visible when one of your connections commented on it, replied to it, or reposted it. With the default KEEP_LIKES = true, a post also stays visible when a connection likes, celebrates, supports, loves, or finds it insightful.

Installation

Install the Tampermonkey extension. I tested the script in Chrome.
Open the gist and click Raw on linkedin-cleanup.user.js. Tampermonkey will offer to install it.
Reload LinkedIn.

If nothing changes in Chrome, open Tampermonkey’s details page in chrome://extensions and turn on Allow User Scripts (on older Chrome versions, turn on Developer mode instead). Chrome requires this before any extension can run userscripts.

Configuration

Every behavior is a flag at the top of the script, so you can switch off anything you want to keep:

const HIDE_RIGHT_SIDEBAR   = true;
const HIDE_ACTIVITY_POSTS  = true;  // "X finds this funny", "X follows ..."
const KEEP_LIKES           = true;  // keep posts a connection liked/celebrated/supported
const HIDE_DEGREE_POSTS    = true;  // posts whose author is 2nd / 3rd+
const HIDE_PROMOTED        = true;
const HIDE_RECOMMENDED     = true;  // "Recommended for you", "Add to your feed"
const HIDE_LEFT_LINKS      = true;  // Try Premium Page, Advertise on LinkedIn
const HIDE_MESSAGING       = true;  // feed only
const DRY_RUN              = false; // true = hide nothing, only record what WOULD be hidden

DRY_RUN is useful when you change a rule and want to see what it would hide before it hides anything.

How It Works

A few details took more iterations than I expected.

Collapsing instead of removing. The obvious approach is display: none. That breaks infinite scroll. LinkedIn loads more posts when its lazy-load observers see the end of the list, and an element with display: none has no box for them to see. Hide enough posts that way and the feed simply stops loading. The script instead collapses hidden posts to zero height with visibility: hidden, so they still exist in the layout and scrolling keeps working. It also collapses the outermost wrapper of each post, so no empty divider or spacer is left behind.

Matching on text, not class names. LinkedIn’s class names change often. The script looks for stable visible text instead: the “2nd” or “3rd+” badge next to an author’s name, the word “Promoted”, or a header like “finds this funny”. A cheap regular expression filters out almost every text node first, so the more expensive checks only run on the few that could matter.

Staying fast while you scroll. A MutationObserver queues every node LinkedIn adds as the feed loads. The queue is processed in requestIdleCallback slices of about 6 ms, and all measuring happens before any hiding, so the page does not have to recalculate its layout over and over. Posts that are not laid out yet are retried a moment later.

Private by default. The script includes an optional debug report for when LinkedIn changes its markup and something stops matching. It is off by default, it is stored only in your browser, and it records page structure and counts, never names or post text.

Limitations

LinkedIn changes its markup regularly, so a rule that works today may stop matching later. If something stops being hidden, or something you want is hidden, leave a comment on the gist and I will take a look.

Get the script: gist.github.com/iamgmujtaba. Connect with me on LinkedIn if you build on it.

RegisPortfolio: A Serverless Portfolio Platform for Data Science Students

2026-02-08T00:00:00+00:00

As a faculty member in Regis University’s Master of Science in Data Science program, I kept seeing the same frustrating pattern. Smart students with impressive projects would graduate, then struggle for months to find jobs that matched their skills. The problem wasn’t their abilities. It was how they presented themselves. Most had scattered GitHub repositories, basic LinkedIn profiles, and maybe a personal website thrown together at the last minute. Recruiters couldn’t easily see how their skills had grown or how their coursework connected to real jobs. So I built RegisPortfolio.com.

Great projects, hard to find

Some examples from our MSDS students:

Matthew Scardino built a “Wildlife Image Processing & Semantic Search System V2” that won a Faculty Choice Award. It identifies species using multiple models and integrates MCP and LangGraph.
Chandon Hamel won a Faculty Choice Award in Summer 2025 for “3D Denoising Diffusion Video Frame Interpolation,” which uses 3D diffusion models to generate in-between video frames.
Etana Disasa won a Student Choice Award for “Multimodal Sentiment Analysis for Instagram Posts,” which combines text and images to judge sentiment.

Before RegisPortfolio, work like this was easy to miss. The pattern was the same every semester:

Students are strong at the technical work but have never had to present it professionally.
Good projects get buried in messy GitHub repositories.
Every student builds a portfolio differently, and many don’t build one at all.
Recruiters can’t see how a student progressed through the program, or how a class project relates to the job they’re hiring for.

Demo

Your browser doesn't support HTML5 video. Here is a link to the video instead.

How it works for students

The idea behind RegisPortfolio.com is simple: the best portfolios tell a story, not just list projects.

Students use the portfolio editor to add projects straight from their coursework. They don’t need to know HTML, CSS, or web development. For each project they write a short reflection connecting it to their career goals, preview exactly what a recruiter will see, and build up a record of their progress semester by semester.

Under the hood

Why serverless

Student usage is spiky: heavy at the end of each term, quiet in between. Paying for a server that sits idle most of the year doesn’t make sense. With a serverless setup:

there’s no server to maintain, and nothing to go down during job search season,
it scales automatically when everyone submits at the end of the term,
costs follow usage, which keeps it affordable for a university,
a content delivery network (CDN) serves portfolios quickly to recruiters anywhere.

Students own their accounts

Students sign in with GitHub (OAuth), so each portfolio belongs to the student, not to a university account. They can choose which projects are visible, edit from any device, and keep access after their university email expires.

Mobile first

Recruiters often look at portfolios on their phones, so every page is designed for small screens first and still works well on a desktop.

Version control and automatic deployment

All portfolio content lives in Git, which gives a full history and a backup of every change. When a student saves in the editor, GitHub Actions rebuilds and publishes their public page, usually in under 30 seconds.

Key features

Standard forms, professional pages: students fill in their project details, and the platform generates consistent, well-designed portfolio pages.
Responsive design: pages work on phones, tablets, and desktops.
Built-in SEO: every page has meta tags and structured data, so portfolios show up in search.
Fast everywhere: pages are served through a global CDN.

Example: my profile on RegisPortfolio.

What’s next

AI features

Automatically categorizing projects and extracting skills, so students type less.
Suggesting career paths and job openings based on a student’s projects.
Recommending classmates with complementary skills for team projects.

Alumni

Letting graduates keep updating their portfolios after they finish the program.
Tracking career outcomes over time, which helps the program and shows current students realistic paths.
Connecting current students with alumni working in the industries they’re targeting.

Want this for your program?

RegisPortfolio gives our students one professional place to show their work, and it helps employers see what our graduates can do. If you’d like to talk about the architecture, adapting it for your institution, or collaborating on an open-source version, email me at gmujtaba@ieee.org.

See it live: browse student portfolios at RegisPortfolio.com, try the editor at editor.regisportfolio.com, or connect with me on LinkedIn.

Regis Applied Practicum Coach: An AI Coach for Data Science Capstone Projects

2025-11-30T00:00:00+00:00

I developed the Regis Applied Practicum Coach to support students in Data Science Practicum/capstone projects at Regis University. It helps with the hardest part of the capstone for most students: coming up with an original, doable, and useful data science project from scratch.

In a typical practicum, students can only get feedback when their instructor is available. The coach fills the gaps: students can brainstorm and plan with it at any hour, then bring better-formed ideas to our meetings.

Applied Practicum Coach Preview

What the Coach Does

The Regis Applied Practicum Coach engages students through structured, conversational sessions:

Brainstorm Topics: Guides students through discovery questions about their interests, preferred domains, datasets, tools, and complexity levels. Generates 3-6 tailored project ideas with specific datasets, techniques, and expected outcomes.
Plan Sessions: Helps students structure their work with customized agendas, time blocks, and milestones aligned with course requirements and academic constraints.
Creative Exercises: Suggests data science-specific activities like dataset critiques, model-choice debates, bias-analysis exercises, and idea-pitch rounds.
Organize Ideas: Recommends prioritization frameworks such as feasibility-impact matrices, MoSCoW method, and practicum-aligned rubrics for unbiased decision-making.
Feedback and Improvement: Provides structured feedback on project proposals, session outcomes, and iterative refinement suggestions.
Skills Development: Assesses students’ brainstorming and planning capabilities through targeted questions, then creates personalized training plans with resources and improvement techniques.

How It Works

The coach asks one question at a time, so the conversation feels like working with a mentor rather than reading a wall of text. It adapts to each student’s academic goals, technical background, and project constraints, ensuring suggestions align with MSDS program requirements and evaluation criteria.

Students can access the coach through dedicated prompt templates that guide them to specific functionalities: topic brainstorming, session planning, exercise suggestions, idea organization, feedback requests, or skills assessment.

Privacy and Access

Currently, the Regis Applied Practicum Coach is available exclusively to Anderson College of Business and Computing students at Regis University. The system maintains student privacy while providing personalized guidance throughout the semester.

Interested in Implementing This for Your Program?

If you’re a faculty member or administrator interested in deploying a similar AI coaching system for your data science or practicum courses, I’m happy to share implementation details, prompt engineering strategies, and customization approaches.

Contact: Email me at gmujtaba@ieee.org to discuss:

Custom prompt templates for your course structure
Integration strategies with your LMS
Privacy and access control considerations
Pilot program opportunities

The goal is to add to human mentorship, not replace it: students become more independent while still having help whenever they need it.

Try It: Currently, Regis Applied Practicum Coach is available only to enrolled Regis University MSDS students. Use this URL to access it.

A Personal AI Assistant for My Students and Research

2025-11-22T00:00:00+00:00

Many of my courses don’t have a teaching assistant, and students’ questions don’t stop when office hours end. So I built an AI assistant that answers questions about my courses, research, and publications at any time of day. Try it at chat.gmujtaba.com.

What it does

Answers common questions about grading policies, due dates, and course logistics, so students don’t have to dig through long documents.
Points to the right material. Instead of a vague answer, it links to the specific reading, lecture, or section that covers the topic.
Covers my research too. Visitors can ask about my publications, patents, and projects.

How it works

It’s a retrieval-based assistant. I convert my course and research documents into text, split them into chunks, and compute embeddings (numeric representations of meaning) ahead of time. When someone asks a question, the site finds the most relevant chunks and sends them, with the question, to Google Gemini, which writes an answer that cites those sources.

A few privacy and security choices:

Precomputed embeddings: the documents are processed once, offline, and only the text excerpts the assistant needs are served.
No original files exposed: the site serves converted text excerpts, never the original PDFs.
No secrets in the code: API keys aren’t stored in the repository; they’re added at deploy time.

Want one for your program?

If you’d like to run a short pilot or talk about setting up access and privacy controls, email me at gmujtaba@ieee.org.

Vibe Coding My Academic Website into Jekyll: What AI Did and What I Still Had to Do

2025-08-21T00:00:00+00:00

“Vibe coding” means describing what you want and letting an AI assistant write most of the code. I used it to rebuild this website, and here is what worked and what didn’t.

The project

My old academic website was hard to update and wasn’t under version control. I wanted to move it to Jekyll, a static site generator, so that:

every page is a simple Markdown or data file,
all changes are tracked in Git,
the site is fast and secure, with no database or server code to maintain.

First I downloaded a copy of the existing site with HTTrack (a website copier I first used as an undergraduate), which gave me its HTML, CSS, JavaScript, and images. Then I used GitHub Copilot with Claude Sonnet 4 to convert it into a Jekyll site while keeping the content and the responsive design.

How much did the AI do?

About 90% of the code the AI generated was usable as is. It was very good at the repetitive work: turning pages into layouts and includes, writing Liquid templates, and moving content into data files. That saved a lot of time.

The other 10% needed me. Quality varied from task to task, so I had to review everything it wrote for correctness, security, performance, and maintainability.

Where AI fell short

Debugging. When something broke in a non-obvious way, asking the AI to fix it often went in circles. Finding the bug myself was faster.
Site-specific needs. Academic websites have their own requirements, such as publication lists and teaching pages, and the AI often didn’t understand them without a lot of explanation.
Polish. User experience testing, page speed, and accessibility checks still needed human judgment.

Use AI to get the structure and first draft in place quickly, then use your own skills to fix, customize, and optimize. AI speeds up a programmer; it doesn’t replace one, and you still need to understand the code to work with it well.

The result is the site you’re reading now, gmujtaba.com.

LaTeX Template for Data Science Practicum Proposals (IEEE Format)

2025-05-01T15:00:00+00:00

I made this LaTeX template for my Master of Science in Data Science practicum students. It gives every proposal the same IEEE-style layout and the same sections, with short instructions in each section explaining what to write. Students can focus on their project instead of formatting, and I can review proposals faster because they all follow the same structure.

What’s included

IEEE-style formatting
Writing guidance in every section
Works in Overleaf or a local LaTeX install
Ready-made examples of citations, figures, tables, algorithms, and code

Sections

Abstract: project summary (250 words max)
Introduction / Background: context and motivation
Problem Statement: the data science problem you’re solving
Related Work: what others have done
Methodology / Approach: your technical and analytical plan
Data Analysis: data source, preparation, and ethical considerations
Expected Outcomes: what you expect to find and why it matters
Timeline: milestones and phases
Conclusion: summary

Preview

Under the hood

The template uses the IEEEtran document class and includes:

Math equations
Pseudocode with the algorithm2e package
Figures and tables
A BibTeX bibliography
Code listings with syntax highlighting

How to use it

In Overleaf (easiest)

Download the GitHub repository as a ZIP file.
In Overleaf, choose New Project > Upload Project and select the ZIP.
Replace the placeholder text with your proposal.
Click Recompile to generate the PDF.

On your own computer

Clone the repository:

git clone https://github.com/iamgmujtaba/practicum_proposal_template.git

Open main.tex in your LaTeX editor.
Edit and compile with your LaTeX distribution.

Files

main.tex: the template
IEEEtran.cls: the IEEE document class
references.bib: sample bibliography

Customizing

Put your name and your advisor’s name in the preamble.
Add, remove, or rename sections to match your program’s requirements.
Adjust formatting if your department has its own guidelines.

The IEEEtran document class is provided by IEEE.

Run DeepSeek-R1 Locally with Ollama and Open WebUI (Even on a Jetson Orin Nano)

2025-01-28T15:00:00+00:00

What you’ll set up

This guide runs the DeepSeek-R1 reasoning model on your own computer using Ollama (which downloads and runs models) and Open WebUI (a ChatGPT-style interface in your browser). Nothing is sent to the cloud. At the end I show the small 1.5B model running on an NVIDIA Jetson Orin Nano.

Requirements

Python 3.11 or newer
Conda (see my conda cheat sheet)
Admin rights to install software
At least 8 GB of RAM (16 GB or more for the larger models)
Tested on Ubuntu Linux

Step 1: Create a conda environment

conda create -n webui python=3.11 -y && conda activate webui 

Step 2: Install Ollama

Linux

curl -fsSL https://ollama.com/install.sh | sh

# Check it installed
ollama --version

macOS

Download Ollama from ollama.com/download/mac.
Open the .dmg and drag Ollama into Applications.
Start Ollama from Applications.

Windows

Download the installer from ollama.com/download/windows.
Run it and follow the steps.
Start Ollama from the Start menu.

Step 3: Install Open WebUI

pip install open-webui

Step 4: Download a DeepSeek-R1 model

Start with the smallest model. It runs on almost any machine:

# DeepSeek-R1-Distill-Qwen-1.5B (smallest, good for edge devices)
ollama run deepseek-r1:1.5b

Larger models give better answers but need much more memory:

# DeepSeek-R1-Distill-Qwen-7B
ollama run deepseek-r1:7b

# DeepSeek-R1-Distill-Llama-8B
ollama run deepseek-r1:8b

# DeepSeek-R1-Distill-Qwen-14B
ollama run deepseek-r1:14b

# DeepSeek-R1-Distill-Qwen-32B
ollama run deepseek-r1:32b

# DeepSeek-R1-Distill-Llama-70B
ollama run deepseek-r1:70b

# Full DeepSeek-R1 (671B, needs server-class hardware)
ollama run deepseek-r1:671b

Step 5: Start Open WebUI

open-webui serve

Then open http://localhost:8080 in your browser, pick the DeepSeek model, and start chatting.

Demo

Running it on an NVIDIA Jetson Orin Nano

I also ran the 1.5B model on an NVIDIA Jetson Orin Nano with 8 GB of memory, and it ran smoothly. Small reasoning models like this are practical on edge devices when you need AI without an internet connection.

Run DeepSeek-R1 Locally in Your Browser with WebGPU

2025-01-21T15:00:00+00:00

What it is

This project runs DeepSeek-R1, a reasoning model, directly in your web browser. It uses the small 1.5-billion-parameter version and your computer’s GPU through WebGPU, a browser feature that lets web pages use the graphics card. Under the hood it uses Transformers.js and ONNX Runtime Web.

In my tests it generated about 60 tokens per second.

Why run a model in the browser

Privacy: your prompts never leave your computer. There’s no server and no API key.
Works offline: once the model has downloaded, you can disconnect from the internet.
No cloud costs: your own GPU does the work.

The catch is that only small models fit in a browser, so answers won’t match large hosted models. For experiments, teaching, and privacy-sensitive use, it works well.

Setup

git clone https://github.com/iamgmujtaba/deepseek-r1.git
cd deepseek-r1
bash run.sh

The app opens at http://localhost:8000. The first load downloads the model, which takes a few minutes; after that it loads from the browser cache.

Demo

Your browser doesn't support HTML5 video. Here is a link to the video instead.

DeepSeek-R1 running in the browser with WebGPU.

Requirements

A browser with WebGPU support (recent Chrome or Edge)
Tested on macOS and Linux (Ubuntu)
At least 4 GB of RAM

Acknowledgments

This project builds on the Hugging Face Transformers.js examples.

Conda Cheat Sheet: Create, Remove, and Export Environments

2025-01-14T15:00:00+00:00

A quick reference for the conda commands I use most, written for my data science students. It covers creating and removing environments, installing packages, channels, and sharing environments with environment.yml.

Install conda

Miniconda: just conda and Python. This is what I recommend (see the comparison at the end).
Anaconda Distribution: conda plus hundreds of preinstalled data science packages.
conda documentation

Why use conda

Separate environments per project. Each project gets its own Python version and packages, so upgrading one project never breaks another.
Works the same on Windows, macOS, and Linux. An environment.yml file recreates the same setup on a teammate’s machine.
More than Python packages. Conda can also install R, system libraries, and compiled tools that pip can’t.

Key terms

Environment: an isolated folder with its own Python and packages.
Channel: a source of packages, such as defaults or conda-forge.
environment.yml: a text file listing an environment’s packages, used to recreate it.

Commands

Check your setup

conda info                    # Show conda configuration and paths
conda --version               # Show the installed conda version
conda update conda            # Update Conda itself

Environments

conda create --name myenv         # Create a new environment (-n is short for --name)
conda create -n myenv python=3.10 # Create an environment with a specific Python version
conda activate myenv              # Activate an environment
conda deactivate                  # Deactivate current environment
conda env list                    # List all environments
conda remove --name myenv --all   # Delete an environment

Packages

conda list                    # List installed packages
conda install packagename     # Install a package
conda update packagename      # Update a specific package
conda update --all            # Update all packages
conda remove packagename      # Remove a package

Channels (package sources)

conda config --show channels                # Show configured channels
conda config --add channels channelname     # Add a channel
conda install -c channelname packagename    # Install from specific channel

conda env export > environment.yml                    # Export full environment
conda env export --from-history > environment.yml     # Export Minimal environment
conda env create -f environment.yml                   # Import environment from file

Specific versions and cleanup

conda install python=3.10             # Install specific Python version
conda install "package>2.5,<3.2"      # Version range installation
conda clean --all                     # Remove unused packages and caches

Common Workflows

Starting a New Project

conda create --name projectname python=3.10   # Create environment
conda activate projectname                    # Activate it
conda install required-packages               # Install needs
conda env export > environment.yml            # Save configuration

Sharing a Project

conda env export --from-history > environment.yml   # For cross-platform sharing
conda env export > environment.yml                  # For exact reproduction

Troubleshooting Tips

Use conda list to verify installed packages
Check channel priorities with conda config --show
Clear package caches with conda clean --all
Review environment history with conda list --revisions
Restore previous states with conda install --revision

Best Practices & Tips

PyTorch no longer publishes conda packages on its own channel. Maintaining conda builds cost too much compared to how few people downloaded them versus PyPI. As part of the deprecation timeline, PyTorch will stop providing nightly builds for its core and domain libraries starting November 18, 2024 PyTorch Issue #138506.

To accommodate users affected by this change, PyTorch recommends switching to its official wheel packages available on download.pytorch.org or PyPI, which are actively supported. For users who prefer conda, PyTorch suggests transitioning to the pytorch-cpu or pytorch-gpu packages available through conda-forge. If you currently depend on the deprecated binaries, it is advised to migrate to pip wheels, which offer equivalent functionality and are more sustainable to maintain PyTorch Discussion: Deprecation of Conda Nightly Builds.

Source: Twitter

Use Miniconda: it takes far less disk space. Miniconda gives you conda and Python, while Anaconda preinstalls hundreds of packages you may never use Miniconda vs Anaconda - Anaconda Documentation.

Feature	Anaconda Distribution	Miniconda
Created by	Anaconda	Anaconda
Has conda	Yes	Yes
Has Anaconda Navigator	Yes	No
Number of packages	300+	< 70
Install space required	~4.4 GB	~480 MB

Name Environments Meaningfully: Use descriptive names for easy identification
One Environment Per Project: Create separate environments for different projects
Export Regularly: Keep environment files in version control
Update Strategically: Test updates in a clone of your environment first (conda create --name myenv-test --clone myenv)
Use Environment Files: Store environment configurations in version control

My recommendation

Use Miniconda to create environments (it works well with VS Code), then install packages with pip inside the environment. Pick one installer per environment: mixing conda and pip installs of the same packages can cause conflicts.

Git & GitHub Cheat Sheet: Essential Commands (git add -A vs git commit -a)

2024-12-22T13:00:00+00:00

A one-page reference for the Git commands I use most, and the ones my students ask about. It starts with setup and goes through staging, branches, remotes, and fixing mistakes.

Install Git

GitHub Desktop for Windows and macOS, if you prefer a graphical app
Git for the command line for Windows, macOS, and Linux

Key terms

Source: GitHub Education

Git: the version control tool that runs on your computer.
GitHub: a website that hosts Git repositories and adds collaboration tools.
Commit: a saved snapshot of your project.
Branch: a separate line of work, so you can try changes without touching main.
Clone: a full local copy of a repository, including its history.
Remote: a copy of the repository on a server, usually called origin.
Fork: your own copy of someone else’s repository on GitHub.
Pull request: a request to merge your branch, with a place for review and discussion.
HEAD: the commit you currently have checked out.

First-time setup

git config --global user.name "[Your Name]"      # Name shown on your commits
git config --global user.email "[you@email.com]" # Email shown on your commits
git config --global color.ui auto                # Colored output

Start a repository

git init                   # Turn the current folder into a Git repository
git clone [repository-url] # Download a repository with its full history

Stage and commit changes

git status                 # What's modified, staged, and untracked
git add [file]             # Stage a file for the next commit
git reset [file]           # Unstage a file (keeps your edits)
git diff                   # Changes you haven't staged yet
git diff --staged          # Changes staged for the next commit
git commit -m "[message]"  # Commit what's staged

git add -A vs git add . vs git add -u vs git commit -a

These four look similar but stage different things. The key question is whether untracked (new) files and deletions are included.

Command	New (untracked) files	Modified files	Deleted files	Scope
`git add -A`	Yes	Yes	Yes	Whole repository
`git add .`	Yes	Yes	Yes	Current directory and below
`git add -u`	No	Yes	Yes	Whole repository
`git commit -a`	No	Yes	Yes	Whole repository (stages and commits in one step)

git add -A                 # Stage everything: new, modified, and deleted files
git add -u                 # Stage modified and deleted tracked files only (no new files)
git commit -a -m "msg"     # Auto-stage modified/deleted TRACKED files, then commit
git add new_file.py && git commit -a -m "msg"  # New files must be added first

Common gotcha: git commit -a does not commit untracked files. A file you just created is ignored until you run git add on it once. After that, Git tracks it and git commit -a picks up its future changes.

Branches

git branch                 # List local branches (* marks the current one)
git branch -a              # List local AND remote-tracking branches (e.g. remotes/origin/main)
git branch -r              # List remote-tracking branches only
git branch [name]          # Create a branch
git checkout [name]        # Switch to a branch (newer Git: git switch [name])
git merge [branch]         # Merge another branch into the current one
git log                    # Commit history

Inspect history

git log                     # Full commit history
git log branchB..branchA    # Commits in branchA that aren't in branchB
git log --follow [file]     # History of one file, including renames
git diff branchB...branchA  # Changes on branchA since it split from branchB
git show [commit-SHA]       # Details and changes of one commit

Work with remotes

git remote add [alias] [url]   # Add a remote (usually "origin")
git fetch [alias]              # Download new commits without merging
git merge [alias]/[branch]     # Merge a fetched remote branch
git push [alias] [branch]      # Upload your commits
git pull                       # Fetch and merge in one step

Move and delete files

git rm [file]               # Delete a file and stage the deletion
git mv [old-path] [new-path] # Move or rename a file and stage it
git log --stat -M           # History showing renamed and moved files

Rewrite history and save work for later

git rebase [branch]         # Replay your commits on top of another branch
git reset --hard [commit]   # Go back to a commit and DISCARD everything after it

git reset --hard deletes uncommitted work permanently. Use it carefully.

git stash                   # Put your uncommitted changes aside
git stash list              # See saved stashes
git stash pop               # Bring back the latest stash

Ignore files

List files and folders Git should ignore in a .gitignore file at the root of your repository:

logs/
*.notes
pattern*/

To ignore files in every repository on your computer:

git config --global core.excludesfile [path-to-ignore-file]

The six commands you’ll use every day

git clone: get a copy of a repository
git status: see what changed
git add: stage changes
git commit: save a snapshot
git push: upload your commits
git pull: download others’ commits

Good habits

Write clear commit messages that say what changed and why.
Do new work on a branch, not directly on main, and merge through a pull request.
Automate checks with GitHub Actions so tests run on every push.

A Simple Web UI for LLaMA 3.2 Multimodal (Text + Images) with Ollama

2024-09-28T13:00:00+00:00

What it is

Meta’s LLaMA 3.2 includes a multimodal version that understands both text and images. Ollama makes it easy to run locally, but its default interface is the command line. I built a small web interface so you can chat with the model in a browser, upload images, and read nicely formatted answers. Everything runs on your own machine.

I tested it on Ubuntu.

Features

Text and image input: ask a question, attach an image, or both.
Formatted answers: code comes back syntax-highlighted.
Copy button: copy any code snippet with one click.
Works on any screen: desktop, tablet, or phone.

Setup

Install Ollama from ollama.com.
Clone the repository and go into the folder:

git clone https://github.com/iamgmujtaba/llama3.2-webUI
cd llama3.2-webUI

Start the app:

bash run.sh

The script starts a local server. Open http://localhost:8000 in your browser. Check the repository README for the exact model to pull with Ollama.

Using it

Type a question in the input box and press send.
To ask about an image, upload it along with your question (for example, “What’s in this picture?” or “Explain this chart”).
Use the copy button on any code block to grab the code.

Screenshots

Contributing and license

Contributions are welcome through pull requests. The project uses the MIT License; see the LICENSE file.

The code is on GitHub.

Generate Thumbnail Containers (Seek Preview Sprites) from Videos with Python and FFmpeg

2024-04-15T13:00:00+00:00

What a thumbnail container is

When you hover over the progress bar on YouTube, a small preview of that moment appears. Those previews don’t come from the video itself. The player loads a thumbnail container: a single image holding a grid of small frames taken at regular intervals (for example, a 5×5 grid with one frame every few seconds). Showing the right tile of that grid is instant, so scrubbing feels smooth without downloading any video.

Thumbnail containers are also the core of my research on lightweight video summarization. Because they’re tiny compared to the video, a phone or edge device can analyze them to find the interesting parts of a long video.

A thumbnail container (left) and how YouTube uses one to show seek previews (right).

This post shows how to generate thumbnail containers, plus HLS video segments, from your own videos with my tool vid2tc.

Setup

Clone the repository:

git clone https://github.com/iamgmujtaba/vid2tc.git
cd vid2tc

Create a conda environment and install the requirements:

conda create -n vid2tc python=3.8 -y
conda activate vid2tc
pip install -r requirements.txt

You also need FFmpeg installed and on your PATH. My HLS server guide covers installing it on Windows.

Options

python .\main.py -h

  -h, --help                         Show help
  -i INP_PATH, --inp_path INP_PATH   Folder with your input videos
  -o OUT_PATH, --out_path OUT_PATH   Folder for the output
  -s SEG_LEN,  --seg_len SEG_LEN     Video segment length in seconds
  -a AUDIO,    --audio AUDIO         Extract audio (True/False)
  -f FRAMES,   --frames FRAMES       Extract video frames (True/False)
  --thumb_width THUMB_WIDTH          Width of each thumbnail in pixels
  --thumb_height THUMB_HEIGHT        Height of each thumbnail in pixels
  --thumb_interval THUMB_INTERVAL    Seconds between thumbnails
  --thumb_container THUMB_CONTAINER  Grid size of each container (default: 5x5)

Example

Put your videos in an input folder and run:

python .\main.py -i .\input\ -o .\output\

The output folder will contain the thumbnail containers and the video segments for each video. To stream the segments, follow my HLS server guide.

The code is on GitHub.

Acknowledgement

The base code comes from Video Thumbnail Generator.

How to Set Up an HLS Streaming Server on Windows (IIS + FFmpeg)

2024-02-15T13:00:00+00:00

What this guide sets up

HTTP Live Streaming (HLS) is the streaming format Apple introduced in 2009. It’s now supported by most players, browsers, and phones. HLS cuts a video into short segments (usually 6–10 seconds) and lists them in a playlist file ending in .m3u8. The player downloads the playlist, then fetches the segments one after another. Everything goes over plain HTTP, so any web server can host it, and it passes through firewalls and CDNs without special setup.

The trade-off is latency: live HLS streams typically run 15–30 seconds behind real time. For video on demand that doesn’t matter, which is why HLS is so widely used.

This guide sets up an HLS server on Windows 10/11 with IIS (the web server built into Windows) and FFmpeg, then plays a test video in VLC and on an iPhone. If you need MPEG-DASH instead, see my DASH server guide.

Step 1: Turn on IIS

Press Windows Key + S and search for Turn Windows features on or off.
Tick Internet Information Services and wait for it to install, then close the window.
Open a browser and go to 127.0.0.1.
You should see the IIS welcome page. If not, restart your computer.

Step 2: Change the web root (optional)

By default IIS serves files from C:\inetpub\wwwroot\. Skip this step if that’s fine.

Open IIS Manager (Windows Key + S, type IIS). Right-click Default Web Site and choose Manage Website > Advanced Settings. This window shows the site’s settings, including its folder (the “document root”), protocols, and bindings. Click Physical Path, then the button on the right, to pick a different folder.

Step 3: Enable CORS

Web players often load the stream from a different site, and browsers block that unless your server allows it. This permission is called cross-origin resource sharing (CORS).

Open IIS Manager.
Select Default Web Site and double-click HTTP Response Headers.
Click Add. Enter Access-Control-Allow-Origin as the name and * as the value.
Click Add again. Enter Access-Control-Allow-Headers as the name and Range as the value.

Step 4: Add the HLS MIME types

IIS won’t serve file types it doesn’t recognize, and it doesn’t know .m3u8 by default.

In IIS Manager, click your server and double-click MIME Types.

Type .m3u8 for File name extension; type application/vnd.apple.mpegurl for MIME-type. Press OK.
Add a second entry: .ts for File name extension; type video/mp2t for MIME-type. Press OK. (Skip this if .ts is already listed.)

HLS MIME types: playlists (.m3u8) use application/vnd.apple.mpegurl (some servers use the older application/x-mpegURL, which players also accept), and MPEG-TS segments (.ts) use video/mp2t. A wrong MIME type is the most common reason an HLS stream won’t play from IIS.

When you’re done, the MIME Types list in IIS should include:

File name extension	MIME type
`.m3u8`	`application/vnd.apple.mpegurl`
`.ts`	`video/mp2t`

Step 5: Install FFmpeg

Download a Windows build of FFmpeg from ffmpeg.org.
Extract it to C:\ffmpeg.
Copy the path of the bin folder (C:\ffmpeg\bin).
Open System Properties > Advanced System Settings > Environment Variables.
Under System variables, select Path and click Edit.
Click New, paste the path, and click OK.

To check, open a new Command Prompt and type ffmpeg. If it prints version information, it’s installed.

Step 6: Create the HLS segments

You can use my vid2tc tool to create video segments (and thumbnail containers) from your own videos, or follow these steps:

Download the Big Buck Bunny sample video.
Rename it to input.mp4.
In that folder, run:

ffmpeg -i input.mp4 -force_key_frames "expr:gte(t,n_forced*10)" -strict -2 -c:a aac -c:v libx264 -f segment -segment_list_type m3u8 -segment_list_size 0 -segment_time 10.0 -segment_time_delta 0.1 -segment_list out.m3u8 out%02d.ts

This cuts the video into 10-second .ts segments and writes the out.m3u8 playlist.

Create a folder named bbb in your web root (for example C:\inetpub\wwwroot\bbb). Copy every generated file into it, but not input.mp4.

To convert several videos at once, use my script:

git clone https://github.com/iamgmujtaba/hls-server.git

Then run:

python .\main.py -i .\input\ -o .\output\

Step 7: Test playback

Find your IP address

Open Command Prompt and run ipconfig. Note the IPv4 Address (something like 192.168.x.x).

Play in VLC

Install VLC.
Press Ctrl+N to open a network stream.
Enter http://192.XXX.XXX.XXX/bbb/out.m3u8, using your own IP address.
Press Play. If the video plays, your HLS server works.

Play on an iPhone or iPad

Safari plays HLS natively. Connect the device to the same Wi-Fi network and open http://192.XXX.XXX.XXX/bbb/out.m3u8 in Safari.

Play in a browser (Ubuntu, Jetson, or any device)

Most desktop browsers need a JavaScript player for HLS. Use hls.js and follow its getting started instructions.

The code is on GitHub. Open an issue there if you run into problems.

How to Set Up an MPEG-DASH Streaming Server on Windows (IIS + FFmpeg)

2024-02-09T13:00:00+00:00

What this guide sets up

MPEG-DASH (Dynamic Adaptive Streaming over HTTP) splits a video into short segments at several quality levels and lists them in a manifest file (.mpd). The player picks the quality that fits the viewer’s connection and switches as it changes. Because everything is plain HTTP, any web server can host it.

This guide sets up a DASH server on Windows 10/11 using IIS (the web server built into Windows) and FFmpeg. At the end you’ll stream a test video to VLC. If you need HLS instead, see my HLS server guide; the IIS steps are almost the same.

Step 1: Turn on IIS

Press Windows Key + S and search for Turn Windows features on or off.
Tick Internet Information Services and wait for it to install, then close the window.
Open a browser and go to 127.0.0.1.
You should see the IIS welcome page. If not, restart your computer.

Step 2: Change the web root (optional)

By default IIS serves files from C:\inetpub\wwwroot\. Skip this step if that’s fine.

Open IIS Manager (Windows Key + S, type IIS).
Right-click Default Web Site, then choose Manage Website > Advanced Settings.
Click Physical Path and pick a different folder.
Make sure IIS has permission to read that folder.

Step 3: Enable CORS

Browser-based players load the stream from another origin, so the server must allow cross-origin requests (CORS).

Open IIS Manager.
Select Default Web Site and double-click HTTP Response Headers.
Click Add. Enter Access-Control-Allow-Origin as the name and * as the value.
Click Add again. Enter Access-Control-Allow-Headers as the name and Range as the value.

Step 4: Add the DASH MIME types

IIS won’t serve file types it doesn’t recognize, and it doesn’t know the DASH extensions by default.

In IIS Manager, click your server and double-click MIME Types.
Add .mpd with MIME type application/dash+xml.
Add .m4s with MIME type video/mp4.

Step 5: Install FFmpeg

Download a Windows build of FFmpeg from ffmpeg.org.
Extract it to C:\ffmpeg.
Copy the path of the bin folder (C:\ffmpeg\bin).
Open System Properties > Advanced System Settings > Environment Variables.
Under System variables, select Path and click Edit.
Click New, paste the path, and click OK.

To check, open a new Command Prompt and type ffmpeg. If it prints version information, it’s installed.

Step 6: Create the DASH segments

Download the Big Buck Bunny sample video.
Rename it to input.mp4.
In that folder, run:

ffmpeg -re -i input.mp4 -map 0 -map 0 -c:a copy -c:v libx264 -b:v:0 800k -b:v:1 300k -s:v:1 320x170 -profile:v:1 baseline -profile:v:0 main -bf 1 -keyint_min 120 -g 120 -sc_threshold 0 -b_strategy 0 -ar:a:1 22050 -use_timeline 1 -use_template 1 -window_size 5 -adaptation_sets "id=0,streams=v id=1,streams=a" -f dash out.mpd

This creates two video qualities (800 kbps and 300 kbps), the audio, and the out.mpd manifest.

Create a folder named bbb_dash in your web root (for example C:\inetpub\wwwroot\bbb_dash). Copy every generated file into it, but not input.mp4.

To convert several videos at once, use my script:

git clone https://github.com/iamgmujtaba/dash-server.git

Then run:

python .\main.py -i .\input\ -o .\output\

Step 7: Test playback

Find your IP address

Open Command Prompt and run ipconfig. Note the IPv4 Address (something like 192.168.x.x).

Play in VLC

Install VLC.
Press Ctrl+N to open a network stream.
Enter http://192.XXX.XXX.XXX/bbb_dash/out.mpd, using your own IP address.
Press Play.

If the video plays, your DASH server works.

Play in a browser (Ubuntu, Jetson, or any device)

For a web player, use dash.js and follow its getting started instructions.

The code is on GitHub. Open an issue there if you run into problems.

Install FFmpeg on NVIDIA Jetson with Hardware Encoding (jetson-ffmpeg, h264_nvmpi)

2023-12-15T13:00:00+00:00

Why build FFmpeg yourself on a Jetson

NVIDIA doesn’t ship an FFmpeg build that uses the Jetson’s hardware video encoder and decoder. The stock FFmpeg from apt runs everything on the CPU, which is slow on a Jetson. The open-source jetson-ffmpeg project adds an nvmpi codec that talks to the Jetson’s hardware. Once it’s built in, you get h264_nvmpi for fast H.264 encoding and decoding.

I tested these steps on a Jetson TX2 with JetPack 4.3.

Step 1: Install the build dependencies

$ sudo apt build-dep ffmpeg

If you get the error “You must put some ‘source’ URIs in your sources.list”, source repositories are turned off. Open the sources list:

$ sudo vi /etc/apt/sources.list

Uncomment every line that starts with deb-src, save (:wq), then try again:

$ sudo apt update
$ sudo apt build-dep ffmpeg

Step 2: Build the jetson-ffmpeg library

This builds the nvmpi library that FFmpeg will use to reach the hardware encoder and decoder:

$ git clone https://github.com/jocover/jetson-ffmpeg.git
$ cd jetson-ffmpeg
$ mkdir build
$ cd build
$ cmake ..
$ make
$ sudo make install
$ sudo ldconfig

Step 3: Patch and build FFmpeg

Download FFmpeg 4.2, apply the nvmpi patch, and build it with --enable-nvmpi:

$ git clone git://source.ffmpeg.org/ffmpeg.git -b release/4.2 --depth=1
$ cd ffmpeg
$ wget https://github.com/jocover/jetson-ffmpeg/raw/master/ffmpeg_nvmpi.patch
$ git apply ffmpeg_nvmpi.patch
$ ./configure --enable-nvmpi
$ make -j4 2>&1 | tee make.log
$ sudo make install

The build takes a while on the TX2. make.log keeps the output in case something fails.

Step 4: Check that h264_nvmpi is available

$ which ffmpeg
/usr/local/bin/ffmpeg
$ ffmpeg -codecs | grep 264

You should see h264_nvmpi listed as both a decoder and an encoder:

ffmpeg version 3eedf15 Copyright (c) 2000-2019 the FFmpeg developers
  built with gcc 7 (Ubuntu/Linaro 7.5.0-3ubuntu1~18.04)
  configuration: --enable-nvmpi
  libavutil 56. 31.100 / 56. 31.100
  libavcodec     58. 54.100 / 58. 54.100
  libavformat    58. 29.100 / 58. 29.100
  libavdevice    58.  8.100 / 58.  8.100
  libavfilter     7. 57.100 /  7. 57.100
  libswscale      5.  5.100 /  5.  5.100
  libswresample   3.  5.100 /  3.  5.100
 DEV.LS h264                 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10 (decoders: h264 h264_v4l2m2m h264_nvmpi ) (encoders: h264_nvmpi h264_v4l2m2m h264_vaapi )

If which ffmpeg points somewhere other than /usr/local/bin/ffmpeg, you’re still running the old apt version. Remove it or call /usr/local/bin/ffmpeg directly.

Using the hardware encoder

To encode with the hardware, pass h264_nvmpi as the video codec:

$ ffmpeg -i input.mp4 -c:v h264_nvmpi output.mp4

I first published this guide on Medium.

Ghulam Mujtaba

Cleaning Up the LinkedIn Feed with a Tampermonkey Userscript

What It Hides

What It Keeps

Installation

Configuration

How It Works

Limitations

RegisPortfolio: A Serverless Portfolio Platform for Data Science Students

Great projects, hard to find

Demo

How it works for students

Under the hood

Why serverless

Students own their accounts

Mobile first

Version control and automatic deployment

Key features

What’s next

AI features

Alumni

Want this for your program?

Regis Applied Practicum Coach: An AI Coach for Data Science Capstone Projects

Applied Practicum Coach Preview

What the Coach Does

How It Works

Privacy and Access

Interested in Implementing This for Your Program?

A Personal AI Assistant for My Students and Research

What it does

How it works

Want one for your program?

Vibe Coding My Academic Website into Jekyll: What AI Did and What I Still Had to Do

The project

How much did the AI do?

Where AI fell short

What I’d recommend

LaTeX Template for Data Science Practicum Proposals (IEEE Format)

What’s included

Sections

Preview

Under the hood

How to use it

In Overleaf (easiest)

On your own computer

Files

Customizing

Run DeepSeek-R1 Locally with Ollama and Open WebUI (Even on a Jetson Orin Nano)

What you’ll set up

Requirements

Step 1: Create a conda environment

Step 2: Install Ollama

Linux

macOS

Windows

Step 3: Install Open WebUI

Step 4: Download a DeepSeek-R1 model

Step 5: Start Open WebUI

Demo

Running it on an NVIDIA Jetson Orin Nano

Run DeepSeek-R1 Locally in Your Browser with WebGPU

What it is

Why run a model in the browser

Setup

Demo

Requirements

Acknowledgments

Conda Cheat Sheet: Create, Remove, and Export Environments

Install conda

Why use conda

Key terms

Commands

Check your setup

Environments

Packages

Channels (package sources)

Share an environment

Specific versions and cleanup

Common Workflows

Troubleshooting Tips