DEV Community: Harini Madura

How to Dockerize an Apriori Algorithm in Python

Harini Madura — Mon, 28 Apr 2025 15:39:03 +0000

If you're curious how to build a Docker image that runs an Apriori algorithm (Market Basket Analysis) in Python — this post is for you!

We'll go from Python code ➡️ to a fully working Docker container.

🛠️ Step 1: Create the Apriori Python Script
First, let’s write a basic Python app that runs the Apriori algorithm.

Create a file called apriori_app.py:

🐳 Step 2: Create a Dockerfile
Next, let’s create a Dockerfile to containerize the app.

🛳️ Step 3: Build and Run the Docker Image
Now let's build and run everything!

Build the Docker Image

✅ This creates a Docker image named apriori-docker-app.

✅ The Apriori results (frequent itemsets and association rules) will be printed in your terminal.

And that's it! 🎯
You’ve successfully created a Dockerized Python application that runs Market Basket Analysis using the Apriori algorithm.
This pattern is super useful for scaling machine learning and data analysis apps across different environments.

If you liked this post or have any questions, feel free to drop a comment! 🚀
Happy Coding!

🚀 Getting Started with Docker: A Beginner's Guide

Harini Madura — Mon, 28 Apr 2025 15:22:43 +0000

Docker is a powerful tool that simplifies application deployment by using containers. This guide will walk you through the basics of Docker, from installation to pushing your first image to Docker Hub.

🐳 What is Docker?

Docker is an open-source platform that automates the deployment of applications inside lightweight, portable containers. Containers package an application with all its dependencies, ensuring consistency across multiple environments.

🔧 Prerequisites:

Before we begin, ensure you have the following installed:

Docker Desktop: Download and install from Docker's official website.
Git: Install Git from here.

Switch to the Main Branch

If you're working in a different branch and want to return to the main branch:

--git branch
--git checkout main

This moves you back to the main branch where your production code usually lives.

Check the Status of Your Repository

To see what's happening in your Git project (like new files, modified files, etc.):

--git status

It’s a good habit to run git status often, so you know exactly what’s staged, what’s modified, and what’s untracked!

Creating a New Branch Directly from GitHub

Sometimes, you don't even need Git commands.

You can create a new branch directly in the GitHub website:

Here's how:

Go to your repository on GitHub.
Click the branch selector dropdown (usually says main).
In the text box, type the name of your new branch.
Press Enter — GitHub will automatically create the branch for you!

Now, let's get into some basic Docker commands.

Docker helps you containerize your application, making it easier to run anywhere.

1. Check the Docker Version

First, check if Docker is installed and running:

--docker --version

This will show you the installed Docker version.

2. Create a Dockerfile

A Dockerfile is a simple text file with instructions on how to build a Docker image.

Steps:

Create a file named Dockerfile (no extension) in your project folder.

Add simple content inside it, like:

Use an official base image:
FROM node:20

Set working directory:
WORKDIR /app

Copy all files:
COPY . .

Install dependencies:
RUN npm install

Start the application:
CMD ["npm", "start"]

The Dockerfile tells Docker how to set up your application inside a container.

3. Build a Docker Image

After you create your Dockerfile, you can build your Docker image:

--docker build -t your-image-name .
--docker build -t my-first-app .

4. List Available Docker Images

To see all the Docker images on your machine:

--docker images

This shows the repository name, tag, image ID, creation time, and size.

5. Push a Docker Image to a Registry (like Docker Hub)

After building your image, you might want to share it by pushing it to a remote repository like Docker Hub.

First, login:

--docker login

Then tag your image (if needed):

--docker tag your-image-name your-dockerhub-username/your-image-name

Finally, push the image:

--docker push your-dockerhub-username/your-image-name

Git and Docker are essential tools for developers today.
By learning simple commands like checking out branches, checking status, building Dockerfiles, and pushing images, you're setting yourself up for success! 💪

Start small, practice often, and soon you’ll be managing full development workflows like a pro!

Mastering Advanced Git Commands

Harini Madura — Fri, 25 Apr 2025 16:33:24 +0000

Git is a powerful tool, and knowing some advanced commands can really level up your version control game. In this post, we'll go through some commonly used Git commands along with their purpose, how to use them.

Let’s get started!

1. git diff

Purpose: Show differences between two commits or working directory and index.

Command: git diff

2. git log

Purpose: Show commit history.

Command: git log

3. git clone

Purpose: Clone a remote repository to your system.

Command: git clone https://github.com/harinimadura06/24MCR030

4. git pull

Purpose: Pull changes from remote to local repo.

Command: git pull origin main

5. git push

Purpose: Push local commits to remote.

Command: git push origin main

6. git blame

Purpose: Show who last modified each line of a file.

Command: git blame ML.txt

7. git merge conflict (not a command)

Note: Conflict occurs during a git merge.

Here’s how to simulate:

git checkout -b new-branch

git checkout main

git merge new-branch

8. git branch

Purpose: List, create, or delete branches.

Command: git branch

9. git checkout -b

Purpose: Create and switch to a new branch.

Command: git checkout –b advanced-git-commands

10 .gitignore

Purpose: File to specify untracked files to ignore.

Steps:

Create .gitignore file in root directory.
Add file patterns to ignore.

e.g.:

*.log
node_modules/

No command needed, Git automatically ignores the specified files.

Git and GitHub: Understanding Version Control

Harini Madura — Wed, 23 Apr 2025 17:59:48 +0000

What is Version Control?
Version Control, also known as Source Control, is a system that helps you manage code efficiently.

version control allows you to:
> Track your files
> Revert your files to previous versions

CVCS vs DVCS:
There are two main types of version control systems:

 > CVCS – Centralized Version Control System
 > DVCS – Distributed Version Control System

Git is based on DVCS, meaning every developer has a local copy.

Git Advantage:
> Works with a local copy of the repository and commit changes locally.

Git Lifecycle: The Three States
A file in Git can be in one of three states:

  1. Modified – The file has been changed but not yet tracked.
  2. Staged – The changes are marked for the next commit (like a temporary area before committing).
  3. Committed – The changes are saved in your local Git database.

Steps to Commit:

Step 1: Add the files
git add

Step 2: Commit the changes with a message
git commit -m "your commit message"

Step 3: Push changes to the repository
git push origin

Create a Local Git Repository:

git init
git add ML.txt
git commit -m "Added Personal Details"

git status
git log

Creating a Personal Repository on GitHub:

Step 1: Go to GitHub
Step 2: Click on New Repository
Step 3: Name your repository
Step 4: Add Description
Step 5: Choose visibility (public/private)
Step 6: Click Create repository

git config --global user.username "harinimadura06"
git config --global user.email "harinimadura06@gmail.com"

git remote add origin https://github.com/harinimadura06/24MCR030.git
git branch -M main
git push -u origin main

git branch

git add ML.txt
git commit -m "updated the personal details"
git push -u origin main

To Conclude:

Understanding Git and GitHub helps you manage your codebase efficiently but also makes collaboration smooth and structured.

Happy version controlling!