DEV Community: Raman Butta

My initial settings on Mac

Raman Butta — Sat, 20 Dec 2025 04:11:34 +0000

XCode Command Line Tools

xcode-select --install

Homebrew

Then go to homebrew's website and download the .pkg installer and install it. After that add it to your system path using this terminal command :

eval "$(/opt/homebrew/bin/brew shellenv)"

Then check the installation by :

brew doctor

It should say “Your system is ready to brew”
Homebrew lets you easily install the core development tools we'll need subsequently.

Use Homebrew to install the major tools needed:

Git

Git: Install version control (if you haven’t already):

brew install git

(Homebrew’s Git will be in your PATH)

Node.js

Node.js and npm: Install the LTS Node (includes npm). You’ll need Node 18+ for modern Next.js:

brew update
brew install node

This provides node and npm (npm v9+). You can check with node -v command. The version should be ≥ v20.9 for nextjs to work later.

Python

Note that Mac comes with a pre-installed system python (say 3.9.x) which you can check using:

which python3
python3 --version

Never mess with the system python or try to upgrade it using say brew. Instead install an environment manager like conda to create separate python envs with your desired version (e.g. py3.10) for different categories of your projects.

Conda

For that go to the Miniconda website and download the GUI .pkg installer for your system. Install it. Check it using conda --version

VSCode

You can download the installer from the VSCode website. This is a .app file and not a .pkg file. So double-clicking it from your Downloads folder will directly open the application. But this behaves like a "temporary instance" and doesn't install permanently. So you must drag the Visual Studio Code.app → Finder sidebar → Applications.
This makes it a proper, permanent installation.
Then you need to generate an ssh key in your Mac and connect that to your Github account to access github repos from the vscode terminal. Refer to my tutorial here.

Installing & Working with Python - in Ubuntu 24.04

Raman Butta — Thu, 20 Nov 2025 12:59:47 +0000

This approach is based on my personal experience, and is one of many approaches you'll find online.

Step 1 : Downloading

Go to the Anaconda website and download the shell script (.sh file) of Miniconda.

Step 2 : Create a folder

Create a folder say myfolder at your suitable location.

mkdir myfolder
cd myfolder

Paste the miniconda.sh file inside this folder (optional, but I did for convenience)

Step 3 : Install conda through the miniconda script

bash ~/miniconda.sh
# follow interactive prompts:
#  - accept license (yes)
#  - choose install location (default: ~/miniconda3) OK
#  - at the end it asks to initialize shell; say "yes" (or you can init manually later)

After install, either restart terminal or source the shell rc:

# restart terminal or
source ~/.bashrc

Stop auto-activation of base (recommended) :

conda config --set auto_activate_base false

Now base will not activate automatically on opening a new terminal.

To confirm proper installation of conda, you can run the following commands :

conda --version
which conda

Step 4 : Create and set up a python environment with conda

I do not prefer to store my custom env inside the installation folder ~/miniconda3/envs/myenv. I want it inside my project myfolder folder, isolated from the system. So instead of conda create -n and conda install -n commands, I will use --prefix :

conda create --prefix ./myenv python=3.10

Then activate the env :

conda activate ./myenv

You will notice that the entire path to myenv gets prefixed before the terminal prompt in parenthesis, which looks bulky. To just keep the name myenv, run the following commands :

conda config --set env_prompt '({name}) '
# Then deactivate and activate myenv again
conda deactivate
conda activate ./myenv

Then check the python version inside that env :

python --version          # should show Python 3.10
which python              # should show ~/YOUR-LOCATION/myenv/bin/python

So you see that the system/OS has an inbuilt python installed, which I did not disturb. I wanted Python3.10 since that is the most supported version for ML applications. But I did not separately install it from the Python website. Instead it got auto-installed while creating the myenv with this python version.

Next, I installed some basic python packages within this activated env as per my needs. You can do what suits your needs.

conda install numpy pandas scipy scikit-learn matplotlib jupyterlab biopython -y

Step 5 : Install and register an IPython kernel from `myenv`

I planned to use an IDE like VSCode or Jupyter Notebook. Since these IDEs detect kernels and not environments, this step is needed.

# Install ipykernel
conda install ipykernel -y
# Register the kernel with a readable name
python -m ipykernel install --user --name myenv --display-name "Python 3.10 (myenv)"

Now myenv can act as a kernel for these IDEs.

Step 6 : Use python in your favourite IDE

Select the kernel in your IDE and start coding !!

N.B. Jupyter IDEs need to be launched from within myenv

jupyter notebook # if you want to use notebook
jupyter lab # if you want to use lab

N.B. Regardless, I prefer Google Colab for most of my applications :)

Marimo : an alternative to Jupyter notebook

Marimo is a Jupyter notebook with each cell being somewhat logically connected to each other. That's way if you update the value of a variable in a cell and re-run it, related values in other cells will be auto-updated and auto-run. This is called reactive execution. Thus the notebook can act as a single python script or app and has an extension of .py instead of .ipynb.

After you've created your myenv environment, you can easily install and use marimo from within it.

conda activate ./myenv
conda install -c conda-forge marimo -y

That's it. Then the installation comes with many inbuilt sample notebooks openable using the marimo tutorial command. Open this one and go through it :

marimo tutorial for-jupyter-users

Creating and editing marimo notebooks

# create notebook
marimo new analysis.py

# open it
marimo edit analysis.py

You can open multiple notebooks within different browser tabs as well.

Installing R in Ubuntu 24.04 LTS & Mac

Raman Butta — Fri, 01 Aug 2025 14:18:29 +0000

Ubuntu

Step 1 : Install R-Base

Go to the terminal and run:

sudo apt update
sudo apt install r-base

This is equivalent to installing R or R-GUI on Windows. With this you can run R in the terminal and get an interactive console to run R commands even without an IDE. But we'll install an IDE called R-Studio in the next step anyway.

Step 2 : Install R-Studio

Go to the site posit.co and download the latest .deb file for Ubuntu 22. Then run sudo dpkg -i filename.deb in the terminal to install it. While installing you may get certain dependency errors. Install those dependencies and run commands as prompted in the error log. And then run the sudo dpkg -i command again. And just like that, you will have installed R Studio.

Now simply run rstudio & in the terminal and the IDE will open. You may get some GPU errors in the terminal which you can ignore as R Studio auto-detects the hardware GPU in your system and in absence of
that, runs on a software GPU, so your IDE will work without issues.

Now you can run R scripts in the editor, interact in the console, look at variables and plots just like the Spyder IDE for python, and install packages from within the IDE.

Mac

Step 1 : Install R

Go to CRAN to install the .pkg installer file for R. Double-click it to install it.

Step 2 : Install R-Studio

Download the .dmg installer file from https://posit.co/download/rstudio-desktop/ and double-click to install it.

Writing the 4 basic SQL Queries

Raman Butta — Wed, 30 Jul 2025 11:29:27 +0000

1. SELECT

Say we have a simple table where we need to select certain cells (*** in the figure) in a chosen column, based on some condition.

+---------+---------+
| Column1 | Column2 |
+---------+---------+
|  Cell1  |  Cell2  |
|  Cell3  |  Cell4  |
|  ***    |  Cell6  |
|  ***    |  Cell8  |
|  ***    | Cell10  |
+---------+---------+

We would SELECT a column FROM the table WHERE certain conditions are met. Additionally, we may JOIN a foreign_table based ON a foreign_key=primary_key relation, and have a WHERE condition accordingly.

The general syntax (parameterized) would be:

`SELECT h.name
FROM humans h
JOIN animals a ON h.animal_id = a.id
WHERE a.name = $1`,[Human],

You'd add the above sql query in the dots below:

const result = await pool.query<{name:string}>(.....);

where pool is your connector object from a PostgreSQL client like pg.

Array-of-objects to Array-of-dataType :

The returned result object is a json object with many entries in which the useful entry is rows : [..array of objects]. Each object in this array is of type say {name: string}. If we map through this entry using result.rows.map and extract the string, we'll get an array of strings which is what we want. So :

const humans:string[] = result.rows.map(row:{name:string})=>{row.name};

Then you can res.json(humans);

2. 📥 INSERT

In SQL, INSERT is used when you want to add new rows to a table — like creating a new human, animal, product, etc.

Let's say we want to add new rows (marked with ***) into this table:

+---------+---------+
| Column1 | Column2 |
+---------+---------+
|  Cell1  |  Cell2  |
|  Cell3  |  Cell4  |
|  ***    |  ***    |
+---------+---------+

You use:

INSERT INTO table_name (column1, column2)
VALUES (value1, value2);

If you want to insert a row in which one of the values is referenced from a foreign table, then,

INSERT INTO humans(name, animal_id)
VALUES(
  'Ram`,
  (SELECT id FROM animals WHERE name='Human')
)
ON CONFLICT (name, animal_id) DO NOTHING

If there's another table say species above animals, then multi-level nesting is also possible:

(SELECT id FROM animals WHERE name = 'X' AND species_id = (SELECT id FROM species WHERE ...))

3. ♻️ UPDATE

The UPDATE statement is used in SQL when you want to change existing data in a table — like correcting a spelling mistake, changing an animal assigned to a human, updating a price, etc.

The general format is :

UPDATE humans
SET fav_color = 'Blue'
WHERE name = 'Ram'

Again if there's a primary key in a foreign table containing 'Blue', you can reference that using SELECT instead of hardcoding 'Blue'.

💡 Note: It’s good practice to always include a WHERE clause in UPDATE. Leaving it out will update every row in the table!

4. 🗑️ DELETE

The DELETE statement is used to remove rows from a table — for example, removing a record that is no longer needed.

📌 General Syntax (basic)

DELETE FROM table_name
WHERE condition;

💡 Warning: If you leave out the WHERE clause, all rows in your table will be deleted!

Summary Table

Action	SQL Command	Example
SELECT	`SELECT ... FROM ... WHERE ...`	Get/retrieve data
INSERT	`INSERT INTO ... VALUES ...`	Add new data
UPDATE	`UPDATE ... SET ... WHERE ...`	Modify existing data
DELETE	`DELETE FROM ... WHERE ...`	Remove data

Basics of EDA

Raman Butta — Sun, 27 Jul 2025 09:41:06 +0000

Exploratory Data Analysis (EDA) is often the first step in grasping a fair idea of a dataset. It not only lays the foundation for subsequent steps like feature engineering and building models to fit the given data, but is invaluable in providing condensed tabular and visual analyses of large datasets.

Whenever you first get a dataset df, you should do light EDA on it. These are the must-dos in quick succession :

I. Textual Analyses

df.shape : gives the dimension of the dataframe
df : shows the first few rows and first few columns. If you want it to show all columns, run: pd.set_option('display.max_columns', None)
df.head() : the first impression
df.describe() : central tendencies of numeric columns (ref: https://youtube.com/watch?v=g2OpfqWi2tM)
df.info() : to visually detect null values in a column, which can be imputed or dropped using .fillna() or .drop() respectively. You can also get the null values from df.isnull().sum()
separate num & cat columns into diff dataframes
generate pivot_table of num col "values" against the target vector "index". This is similar to groupby. For eg.
tips.pivot_table(values='tip', index='sex') and tips.groupby('sex')['tip'].mean() would give exactly the same output, but pivot_table is visually nicer.
see value_counts of cat columns
divide above value_counts between target vector's values by generating pivot_table of cat col "columns" against the target vector "index" with aggfunc='count'

II. Graphical Analyses

Categorical variables

If you want to plot the frequencies (y) of different alleles (x) of a categorical variable, use countplot, eg:

sns.countplot(x="day", data=tips)
plt.show()

As you can see, that you give x, and y is automatically generated. It is the graphical version of value_counts()

or you can make a pieplot:

counts = tips['day'].value_counts()
plt.pie(counts, labels=count.index)
plt.axis('equal')
plt.show()

Numerical variables

0. Histogram

If you want to graph the frequencies (y) of different bins (x) of a numeric variable in a column i, use a histogram, eg:

 plt.hist(df_num[i])
 plt.title(i)
 plt.show()

As you can see, you give i, and x, y are automatically generated.

If you use sns.distplot instead on that column, it creates a histogram with KDE curve overlay

1. General Catplot Syntax for num vars grouped across cat var

If you want to graph the aggregated value of one numerical variable (y) grouped by a categorical variable (x), the general syntax is :

sns.catplot(x='day', y='total_bill', data=tips, kind='...', hue='...')

Within kind you can put the kind of plot. Allowed values for kind are: 'strip', 'swarm', 'box', 'boxen', 'violin', 'bar', 'count', and 'point'.

Within hue you can put another categorical variable for sub-grouping the num var in each curve.

Although you have this general syntax, its helpful to know specific formats as below.

2. Barplot

If you want to graph the aggregated value of one numerical variable (y) grouped by a categorical variable (x), use a barplot. Eg

sns.barplot(x="day", y="total_bill", data=tips, estimator=sum, ci=None)
plt.show()

If you drop the estimator argument, it will default to the "mean" estimator/aggfunc. For central tendencies like mean or median, you may drop the ci argument so that it defaults to True and shows confidence intervals.

3. Boxplot

Note that sns.barplot(x='day', y='total_bill', data=tips) will only give the mean of total_bill in each day (bin). If you instead want to focus on quartiles, spread, and outliers, use a boxplot. Eg:

sns.boxplot(x="day", y="total_bill", data=tips)
plt.show()

This creates a boxplot showing the median, interquartile range (IQR), and potential outliers for total_bill across each day. The box represents the IQR (25th to 75th percentile), the line inside the box is the median, and the "whiskers" extend to the minimum and maximum values within 1.5 * IQR. Points outside this range are plotted as outliers. You can add hue to further split the boxes by another categorical variable, e.g., hue="sex", to compare distributions across subgroups.

4. KDE Plot

If instead of the boxplot, you want a visual KDE curve of total_bill across each day, use

sns.kdeplot(data=tips, x='total_bill', hue='day', multiple='layer')  # or multiple='dodge', 'stack'
plt.show()

5. Scatterplots

Eg:

sns.scatterplot(x="total_bill", y="tip", data=tips, hue="sex")
plt.title("Scatterplot of Total Bill vs Tip")
plt.show()

This creates a scatterplot where each point represents a pair of total_bill (x-axis) and tip (y-axis) values from the tips dataset. The hue="sex" argument colors points by the categorical variable sex.

6. Pairplot

If you find that the KDE curve of total_bill across various days has such overlap that it's not a sharp classifier, you may want to see pairs of numerical variables which may form distinct clusters in the xy plane across different days (hues) and serve as sharp classifiers. Thus you may need a pairplot like this :

sns.pairplot(tips, vars=['total_bill', 'tip', 'size'], hue='day')
plt.show()

You keep numerical variables in vars. If you omit vars, it plots for all numerical variables in the dataframe.

The pairplot grid gives you KDE curves along the diagonal and scatterplots off-diagonally.

7. Violinplot

They are like boxplot inside a KDE curve.

sns.violinplot(x="day", y="total_bill", data=tips)
plt.show()

This creates a violinplot that combines a boxplot with a kernel density estimate (KDE) for total_bill across each day. The width of each "violin" represents the density of the data at different values, providing a clearer view of the distribution's shape compared to a boxplot. The inner boxplot shows the median and IQR, while the KDE extends to show the full distribution. You can add hue to split the violins by another categorical variable, e.g., hue="sex", and use split=True to display the distributions side-by-side within each category for easier comparison.

8. Correlation heatmaps

If you want to visualize the correlation between numerical variables in a dataset, use a heatmap of the correlation matrix. Eg:

sns.heatmap(tips.corr(), annot=True, cmap='coolwarm', vmin=-1, vmax=1)
plt.show()

This creates a heatmap where each cell represents the correlation coefficient between pairs of numerical variables in the tips dataset. The corr() method computes the Pearson correlation by default, ranging from -1 (perfect negative correlation) to 1 (perfect positive correlation). The annot=True argument displays the correlation values in each cell, and cmap='coolwarm' uses a diverging color scheme to highlight positive (red) and negative (blue) correlations. The vmin and vmax parameters set the range for the color scale.

III. Applying Filters on a categorical column

First find all the alleles of the chosen cat variable. Eg.

print(df1['day'].unique())

Then say Sunday is a unique allele wrt which you want to filter :

days_df = df[df[days] == Sunday]

or if you want to filter out days which have the word "sun" (case-insensitive), run

days_df = df[df[days].str.contains('sun', case=False, na=False)]

And then

days_df

Getting started with Kaggle

Raman Butta — Fri, 18 Jul 2025 09:56:30 +0000

Basic libraries like Numpy, Pandas, Seaborn, Matplotlib are pre-installed in Kaggle. You just need to import them in your notebook.

Loading datasets in your notebook

Kaggle is organised in directories.
/kaggle/working/ is your present working directory.
/kaggle/input/ is where public datasets are kept.

So you can go to the sidebar in your Kaggle notebook and "Add Input" (for public Kaggle databases) or "Upload" (if you have own/non-Kaggle database). For example, you can add the "Titanic" dataset and then it appears in your /kaggle/input directory.

To print all the datasets added to your notebook, you can use Python's built-in os module, which can walk through a directory tree (like /kaggle/input).
So os.walk('/kaggle/input') is a generator that walks through the directory /kaggle/input and returns 3 things for each folder it visits:

dirname: current folder path
subdirs: a list of subdirectories (which we can ignore with _)
filenames: a list of all the files in that folder

So you can run the following code :

import os
for dirname, _, filenames in os.walk('/kaggle/input'):
    for filename in filenames:
        print(os.path.join(dirname, filename))

and it will output something like

/kaggle/input/titanic/train.csv
/kaggle/input/titanic/test.csv
/kaggle/input/titanic/gender_submission.csv

Note that you only see what your notebook has mounted — not all Kaggle datasets.

To master data science projects (like the Titanic one), it's important to follow a structured pipeline :

Data Loading
Data Preprocessing:
- Data Cleaning (you can merge all dataframes before cleaning it)
- Feature Engineering
- Encoding
EDA
Preprocessing
Model Building
Model Tuning

What is Kaggle?

Raman Butta — Sun, 22 Jun 2025 16:04:55 +0000

While Kaggle started with supervised learning competitions (like predicting house prices or Titanic survival), it now supports the entire range of data science, machine learning, and AI workflows. Here's the full scope of what Kaggle is used for:

✅ 1. Supervised Learning

Most common, yes — but just one part.

🏠 Regression (e.g., house prices)
🧍 Classification (e.g., Titanic survival, spam detection)

❓ 2. Unsupervised Learning

You’ll find notebooks and datasets for:

📦 Clustering (e.g., customer segmentation)
🌐 Dimensionality reduction (e.g., PCA for image compression)

🤖 3. Deep Learning Tasks

With TensorFlow, PyTorch, Keras — you’ll see:

🖼️ Image classification (e.g., cats vs. dogs)
🗣️ NLP (sentiment analysis, summarization, text generation)
🎵 Audio/speech recognition
🧠 LLMs and transformers (fine-tuning BERT, GPT, etc.)

🕹️ 4. Reinforcement Learning

While rarer than other categories, there are:

🐍 Notebooks using OpenAI Gym environments
🏁 Path-planning, game AI, and Q-learning projects

📈 5. Time Series & Forecasting

You’ll find:

📅 Stock price prediction
🦠 COVID-19 case forecasting
⛅ Weather prediction

Often includes tools like:

statsmodels
prophet
LSTM/RNN models

🔬 6. Exploratory Data Analysis (EDA) Projects

No modeling — just visual exploration:

Seaborn/Matplotlib visual storytelling
Finding insights in sports, economy, or demographic data

🏗️ 7. Data Engineering + Preprocessing

Examples:

Data cleaning pipelines
Missing value treatment
Feature engineering recipes
Efficient I/O (e.g., feather, parquet formats)

🧪 8. Real-World Applications

Kaggle now has "Code Competitions" and "Notebooks" on:

🔍 Document search (IR, vector DBs)
🧬 Biology (protein folding, cancer detection)
🛒 Recommender systems
🧾 PDF parsing, OCR, and web scraping

📚 9. Learning + Community

Not just competitions:

Kaggle Learn: mini-courses (Python, ML, SQL, etc.)
Public notebooks: like StackOverflow, but for data workflows
Discussions: Q&A, guides, updates

Domain	Examples
Supervised ML	Titanic, Housing, Spam
Unsupervised ML	Clustering, PCA
Deep Learning	CNNs, NLP, LLMs
Reinforcement Learning	Q-Learning, OpenAI Gym
Time Series Forecasting	Prophet, ARIMA, LSTM
EDA & Data Cleaning	Visual stories, missing data hacks
Data Engineering	Joins, transforms, pipelines
Real-world AI Apps	Recommenders, OCR, Chatbots

So, Kaggle is a full-stack playground: from EDA → modeling → deployment experiments — all runnable in the browser, free GPU/TPU included.

So try out beginner projects in a specific domains like vision, text, time series, or audio. And keep learning.

How I Fixed My Seagate External Hard Drive Mounting Issue on Ubuntu 24.04

Raman Butta — Mon, 16 Jun 2025 16:04:28 +0000

Problem:

Clicking my Seagate hard drive icon in Ubuntu's GUI suddenly gave an error like :

“error mounting seagate bad errorblock on /dev/sdb" or "wrong fs type, bad option, bad superblock”

Manual Mounting

I tried manually mounting the drive through terminal :

  sudo mkdir /mnt/mydrive
  sudo mount /dev/sdb1 /mnt/mydrive
  ...access your files...
  sudo umount /dev/sdb1

But this showed an error : "$MFTMirr does not match $MFT"

So I ran:

sudo add-apt-repository universe
sudo apt update
sudo apt install ntfs-3g exfat-fuse exfatprogs

My HDD was NTFS-based (you can check it by running lsblk -f command). So I ran :

sudo ntfsfix /dev/sdb1

Now the sudo mount command worked, confirming the drive and data were accessible, but the GUI still failed.

Adjusting Mount Options in Disks App

(I learnt this from https://askubuntu.com/a/1517406/519832)

I opened the Disks app, selected my drive, and clicked the cog wheel (settings).
Chose Edit Mount Options…
Turned off User Session Defaults.
Adjusted other mount parameters as needed (e.g., mount point, mount at startup).
Saved the changes.

Now, the drive mounts from the GUI as before. But remember to properly unmount before removing your HDD.

Step-by-Step Guide to Submitting a Pull Request on GitHub

Raman Butta — Wed, 04 Jun 2025 12:54:28 +0000

This guide will take you from complete beginner to confident contributor by walking you through the entire pull request (PR) process.

Prerequisites

A GitHub account
Git installed on your computer
Basic command line knowledge

Step 1: Fork the Repository

Navigate to the repository you want to contribute to on GitHub
Click the "Fork" button in the top-right corner
- This creates your own copy of the repository under your GitHub account

Step 2: Clone Your Fork Locally

Copy the URL of your forked repository (click the "Code" button)
Open your terminal/command prompt and run:

   git clone https://github.com/YOUR-USERNAME/REPOSITORY-NAME.git
   cd REPOSITORY-NAME

Step 3: Set Up Upstream Remote

Add the original repository as a remote called "upstream":

   git remote add upstream https://github.com/ORIGINAL-OWNER/REPOSITORY-NAME.git

Verify the remotes:

   git remote -v

Should show both your fork (origin) and the original (upstream)

Step 4: Create a New Branch

Never work directly on the main branch. Create a new branch for your changes:

git checkout -b your-branch-name

Good branch names describe the work: fix-typo-docs, add-feature-x, etc.

Step 5: Make Your Changes

Make the necessary changes to the code/files
Save your changes
Stage the changes:

   git add .

Or add specific files:

   git add filename.ext

Commit your changes with a meaningful message:

   git commit -m "Brief description of changes"

Step 6: Push Changes to Your Fork

Push your branch to your GitHub fork:

git push origin your-branch-name

Step 7: Create the Pull Request

Go to your fork on GitHub
You should see a banner suggesting to create a PR - click "Compare & pull request"
- Or go to the "Pull requests" tab and click "New pull request"
Select the correct branches:
- Base repository: original repo's main (or default branch)
- Head repository: your fork's your-branch-name
Fill in the PR details:
- Meaningful title
- Detailed description of changes
- Reference any related issues (using #issue-number)
Click "Create pull request"

Step 8: Respond to Feedback

Project maintainers might request changes:

Make additional commits if needed
Push them to the same branch
The PR will automatically update

Step 9: Sync with Upstream (if needed)

If the original repository changes while your PR is open:

git checkout main
git fetch upstream
git merge upstream/main
git checkout your-branch-name
git merge main
# Resolve any conflicts, then push
git push origin your-branch-name

Step 10: After Merge

Once your PR is merged:

Delete your branch (both locally and on GitHub)
Sync your fork's main branch:

   git checkout main
   git pull upstream main
   git push origin main

Expert Tips

Keep PRs small and focused - address one issue per PR
Follow project conventions - coding style, commit messages, etc.
Write good commit messages:

   Summarize changes in 50 chars or less

   More detailed explanation if needed. Wrap at 72 chars.
   - Bullet points are okay
   - Explain why, not just what

Reference issues in your PR description (e.g., "Fixes #123")
Use GitHub's features:
- Markdown formatting
- Code reviews
- Suggested changes
Consider signing commits for extra verification

Common Workflows

Forking Workflow (described above)

Best for open source contributions where you don't have write access

Branching Workflow

If you have write access to the repository, you can create branches directly in the main repo instead of forking

GitHub CLI Alternative

Advanced users can use GitHub CLI to create PRs from the command line:

gh pr create --title "Your PR title" --body "Description"

Now you're ready to contribute to projects with confidence! Start with small contributions to build your reputation in open source communities.

Adding WakaTime stats to your Github README

Raman Butta — Sun, 11 May 2025 11:30:10 +0000

First I referred to this tutorial.

Of particular note is the integration of my local IDE to my Wakatime account. For example I use the Zed editor. So I typed Zed in my "Supported IDEs" in Wakatime website, which led me to this project page. It says to ensure that the .wakatime.cfg is created in the very Home (~) directory of your machine and the wakatime api_key is added to this file. Upon restarting your IDE, you'll see your stats in your Wakatime dashboard.

I added wakatime to Google Colab by running in a code cell like this (not sure if it works):

%%writefile /root/.wakatime.cfg
[settings]
api_key = YOUR_WAKATIME_API_KEY

Now I went to Github.

In the /.github/workflows/waka.yml file I created, I added the following code:

name: Update WakaTime Stats

on:
  schedule:
    - cron: '0 0 * * *' # Runs daily at midnight UTC
  workflow_dispatch: # Allows you to manually trigger the workflow

jobs:
  update-readme:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout Repository
        uses: actions/checkout@v3

      - name: Update WakaTime Stats in README
        uses: athul/waka-readme@master
        with:
          WAKATIME_API_KEY: ${{ secrets.WAKATIME_API_KEY }}

Note that I added a "Checkout Repository" step as well so that it captures my activity on Github also, not just on my IDE.

Also note that I used the popular Github action of Athul here. Anmol's Github action can also be used here.

Once you run this Github action, your README starts getting populated with stats.

By default, all Wakatime APIs provide your past 7 days' activity.

Follow me on my X Profile

Migrating from Windows to Linux

Raman Butta — Thu, 01 May 2025 13:14:50 +0000

Firstly, congratulations on your decision to migrate to Linux. Windows is great for beginners and also certain proprietary software and games. But in my opinion, it is unnecessarily compute-heavy. Linux is sleek, light, modern and open-source. The most popular, versatile and powerful Linux distro for beginners is Ubuntu. So if you're on a PC, you better make the move.

Here's how you migrate:

INSTALLATION

1. Backup your Windows data

2. Download Ubuntu ISO

i.e. the ISO image of Ubuntu LTS version from their website.
At the time of this article, Ubuntu 24.04 is the LTS version.

3. Create a Bootable USB Drive

Download Rufus software from https://rufus.ie/ and use it to burn the ISO image onto your USB drive to make it bootable.

Insert your USB.
Open Rufus.
Select the USB drive under "Device".
Select the Ubuntu ISO under "Boot selection".
Partition scheme: GPT
File system: FAT32
Click Start and confirm.

4. Boot from the USB Drive

Plug in the USB drive into your PC.
Restart your PC.
Press the boot menu key (often F12, Esc, F10, or Del) while booting to access the boot menu.
Select your USB drive from the list.
Ubuntu will boot into a live session.

5. Start Ubuntu Installation

Click “Install Ubuntu”.
Choose your language and keyboard layout.
Select updates and third-party software (optional but recommended).
On the "Installation Type" screen:
- Choose “Erase disk and install Ubuntu”
- This will:
  - Delete Windows and old Ubuntu
  - Format the entire hard disk
  - Create a new partition table
Click Continue.

6. Disk Partitioning (Auto)

Ubuntu will automatically create:
- A root (/) partition
- A swap partition (since you have 8 GB RAM, a 2–4 GB swap is typical)
You can customize partitions if you're experienced, but auto-mode is fine.

POST-INSTALLATION

7. System Update and Upgrade

Open the Terminal (Ctrl + Alt + T) and run:
sudo apt update && sudo apt upgrade -y

8. Install Common Utilities

sudo apt install -y curl wget git build-essential software-properties-common

8. Enable Restricted Drivers (NVIDIA/Wi-Fi, etc.)

Go to “Software & Updates” > “Additional Drivers”
Choose the recommended proprietary driver (e.g., NVIDIA) and apply changes.

9. Set Up Git (if you plan to code)

git config --global user.name "Your Name"
git config --global user.email "you@example.com"

10. Check your live system parameters

Press Super (Windows key) and search “System Monitor”
To check disk usage you can run df -h on your terminal

PACKAGE INSTALLATIONS

To check if a package is already installed in Ubuntu before using sudo apt install, you can use the dpkg command like this:
dpkg -s software-properties-common

On Windows, installers bundle everything you need — usually the latest stable version — into a single .msi or .exe file (.pkg/.app/.dmg for Mac). But on Ubuntu (and Linux in general), things work differently.

Ubuntu maintains its official package repositories. These repos wrap software apps. You can install them using apt. Eg. : sudo apt install nodejs. But these APT Repos are sometimes not updated frequently. So for the nodejs example, if you run node -v you may see an old version.

The solution is to use official 3rd-party APT Repos (like Nodesource for nodejs). You can add it to your system and pipe it to your bash, before installing, like this:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo bash -
sudo apt-get install -y nodejs

Similarly, Docker, VS Code, MongoDB, etc. all maintain external apt repos.

An alternative to 3rd-party repos often used for community or developer-maintained packages like Git is PPAs (Personal Package Archives). You can add apt repos from a designated PPA eg.: sudo add-apt-repository ppa:git-core/ppa.
Then Ubuntu’s APT will then fetch packages from the PPA’s servers when running sudo apt install git.

I will add more tips in future posts. See ya. You can connect with me on X and LinkedIn.

DEV Community: Raman Butta

My initial settings on Mac

XCode Command Line Tools

Homebrew

Git

Node.js

Python

Conda

VSCode

Installing & Working with Python - in Ubuntu 24.04

Step 1 : Downloading

Step 2 : Create a folder

Step 3 : Install conda through the miniconda script

Step 4 : Create and set up a python environment with conda

Step 5 : Install and register an IPython kernel from myenv

Step 6 : Use python in your favourite IDE

Marimo : an alternative to Jupyter notebook

Creating and editing marimo notebooks

Installing R in Ubuntu 24.04 LTS & Mac

Ubuntu

Step 1 : Install R-Base

Step 2 : Install R-Studio

Mac

Step 1 : Install R

Step 2 : Install R-Studio

Writing the 4 basic SQL Queries

1. SELECT

2. 📥 INSERT

3. ♻️ UPDATE

4. 🗑️ DELETE

📌 General Syntax (basic)

Summary Table

Basics of EDA

I. Textual Analyses

II. Graphical Analyses

Categorical variables

Numerical variables

0. Histogram

1. General Catplot Syntax for num vars grouped across cat var

2. Barplot

3. Boxplot

4. KDE Plot

5. Scatterplots

6. Pairplot

7. Violinplot

8. Correlation heatmaps

III. Applying Filters on a categorical column

Getting started with Kaggle

Loading datasets in your notebook

What is Kaggle?

✅ 1. Supervised Learning

❓ 2. Unsupervised Learning

🤖 3. Deep Learning Tasks

🕹️ 4. Reinforcement Learning

📈 5. Time Series & Forecasting

🔬 6. Exploratory Data Analysis (EDA) Projects

🏗️ 7. Data Engineering + Preprocessing

🧪 8. Real-World Applications

📚 9. Learning + Community

How I Fixed My Seagate External Hard Drive Mounting Issue on Ubuntu 24.04

Manual Mounting

Adjusting Mount Options in Disks App

Step-by-Step Guide to Submitting a Pull Request on GitHub

Prerequisites

Step 1: Fork the Repository

Step 2: Clone Your Fork Locally

Step 3: Set Up Upstream Remote

Step 4: Create a New Branch

Step 5: Make Your Changes

Step 6: Push Changes to Your Fork

Step 7: Create the Pull Request

Step 8: Respond to Feedback

Step 9: Sync with Upstream (if needed)

Step 10: After Merge

Expert Tips

Common Workflows

Forking Workflow (described above)

Branching Workflow

GitHub CLI Alternative

Adding WakaTime stats to your Github README

Step 5 : Install and register an IPython kernel from `myenv`