DEV Community: JohnKagunda

The Beauty of Git: Writing Code Stories

JohnKagunda — Sun, 03 Aug 2025 18:17:07 +0000

Most people understand the basics of what git is. add, commit -m "please work", push. Well, having this for a git workflow makes it feel like a burden more than a tool.

Lemme expand your mind a little bit.

Imagine your code like a story one you're telling to your future self or another developer joining you. Every commit is a chapter, every branch is a plot thread, and every merge is where storylines converge. When viewed this way, Git transforms from a mundane version control system into a powerful narrative tool that makes your development journey coherent, traceable, and beautiful.

The Art of Storytelling Through Commits

Writing Commits That Matter

A well-crafted commit message is like a good book title it tells you exactly what to expect inside. Instead of cryptic messages like "fix stuff" or "updates," consider commits as documentation of your thought process:

# Instead of this:
git commit -m "fix bug"

# Write this:
git commit -m "Fix user authentication timeout in mobile Safari

- Increase session timeout from 15 to 30 minutes
- Add heartbeat mechanism to maintain active sessions
- Update error handling for expired tokens

Resolves issue where users were logged out mid-transaction
on slower mobile connections."

This commit tells a complete story: what was broken, how it was fixed, why it matters, and what the impact is. Your future self will thank you when debugging at 2 AM.

The Power of Atomic Commits

Think of atomic commits as perfectly focused short stories each one should do exactly one thing, and do it completely. This approach transforms your development workflow:

Benefits of atomic commits:

Easier debugging: When something breaks, you can pinpoint exactly which change caused it
Cleaner history: Your project timeline becomes a clear narrative of evolution
Safer reverts: You can undo specific changes without collateral damage
Better code reviews: Reviewers can understand and evaluate each change independently

# Instead of one massive commit:
git commit -m "Add user dashboard with profile, settings, and notifications"

# Break it down:
git commit -m "Add user profile component with avatar and basic info"
git commit -m "Implement user settings page with privacy controls"
git commit -m "Create notification system with real-time updates"

Each commit now tells a focused story that's easy to understand, review, and maintain.

Rebase: The Editor's Revision Process

Interactive rebase is like having a time machine for your story. It lets you go back and polish your narrative before sharing it with the world:

git rebase -i HEAD~3

This opens your last three commits in an editor where you can:

Reword commit messages for clarity
Squash related commits together
Reorder commits to create logical flow
Edit commits to fix small issues
Drop commits that shouldn't exist

Think of it as the difference between showing someone your rough draft versus your polished manuscript. The story is the same, but the presentation makes all the difference.

# Before rebase - messy story:
feat: add login form
fix: typo in login form
feat: add validation to login
fix: validation bug
feat: add password reset

# After rebase - clean narrative:
feat: implement user authentication system
feat: add password reset functionality

When Stories Take Unexpected Turns: Cherry-Pick to the Rescue

We've all been there you're deep in the flow, making brilliant commits, only to realize you're on the wrong branch. It's like writing a perfect chapter for the wrong book. But Git has a solution: cherry-picking.

The Cherry-Pick Rescue Mission

Cherry-pick lets you take specific commits from one branch and apply them to another, like moving a scene from one story to another:

# You made commits on 'main' but meant to be on 'feature-branch'
git log --oneline
a1b2c3d Fix authentication bug
e4f5g6h Add user validation
i7j8k9l Update API endpoints

# Switch to the correct branch
git checkout feature-branch

# Cherry-pick the commits you need
git cherry-pick e4f5g6h  # Just the validation commit
git cherry-pick a1b2c3d  # And the auth fix

Common Cherry-Pick Scenarios

Hotfix Emergency: You've pushed a critical fix to the wrong branch, but production needs it now:

git checkout production
git cherry-pick hotfix-commit-hash
git push origin production

Feature Extraction: You realize part of your feature should be its own separate story:

git checkout -b new-feature-branch
git cherry-pick specific-commit-hash

Cross-Branch Pollination: You developed something on one feature that another feature needs:

git checkout other-feature-branch
git cherry-pick useful-commit-hash

The Beautiful Git Workflow

When you combine all these concepts, your Git workflow becomes elegant and purposeful:

Start with intention: Create descriptive branch names that tell the story's purpose

   git checkout -b feature/user-notification-system

Commit atomically: Each commit is a complete thought, a finished paragraph

   git add notification-model.js
   git commit -m "Add notification data model with user preferences"

Polish before sharing: Use interactive rebase to craft your narrative

   git rebase -i origin/main

Handle mistakes gracefully: Cherry-pick when life happens

   git cherry-pick commit-hash

Merge with purpose: Your pull request tells a complete, coherent story

   git checkout main
   git merge --no-ff feature/user-notification-system

The Transformation

Once you start thinking of Git as a storytelling tool, everything changes. Your commits become documentation. Your branches become organized thoughts. Your merges become chapter conclusions. Your repository becomes a living history of your project's evolution.

The developer who inherits your code won't curse your name they'll appreciate the clear narrative you've left behind. Your future self won't struggle to understand past decisions the story will be right there in the commit history.

Git stops being a burden and becomes what it was always meant to be: a powerful tool for collaborative storytelling in code. Every repository becomes a well-crafted novel, every commit a meaningful sentence, every branch a thoughtful subplot.

So the next time you sit at your terminal, remember: you're not just managing code you're writing the story of your software. Make it a story worth reading.

Leetcode: Two Ptrs: Easy

JohnKagunda — Tue, 25 Feb 2025 03:11:10 +0000

Technical interviews haven’t changed much, so it’s up to us to upskill and master data structures and algorithms (DSA). Although the LeetCode 75 Study Plan is a great resource, covering just 75 questions to grasp all DSA concepts might not be enough—they tend to favor breadth over depth.

Being a jack of all trades might save us for now, but as time goes by, we might struggle to solve various medium-level problems within a specific topic.

Problem Statement

Given two strings, needle and haystack, return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.

Example 1

Input: haystack = "sadbutsad", needle = "sad"

Output: 0

Explanation: The substring "sad" occurs at indices 0 and 6, but the first occurrence is at index 0.

Example 2

Input: haystack = "leetcode", needle = "leeto"

Output: -1

Explanation: The substring "leeto" does not occur in "leetcode", so the output is -1.

Two-Pointer Technique Solution

Although this problem can be solved with a few lines of code, our goal is to implement it using the two-pointer technique. Below is one such solution:

class Solution:
    def strStr(self, haystack: str, needle: str) -> int:
        # If needle is an empty string, return 0 as per convention.
        if not needle:
            return 0

        for i in range(len(haystack)):
            j = i
            for k in range(len(needle)):
                # Check if we are within the bounds of haystack and characters match.
                if j < len(haystack) and haystack[j] == needle[k]:
                    j += 1
                else:
                    break

                # If we've successfully matched all characters in needle.
                if k == len(needle) - 1:
                    return i

        return -1

Explanation

Outer Loop:

Iterates through each index in haystack, considering it as a potential starting position for needle.
Inner Loop:

For each starting index, it iterates through the characters in needle to verify if the substring in haystack starting at that index matches needle. The loop breaks early if a mismatch is found.
Early Termination:

If the inner loop completes (i.e., all characters in needle have been successfully matched), the function immediately returns the starting index.

Performance Analysis

Time Complexity:

In the worst-case scenario, the outer loop runs n times (where n is the length of haystack) and the inner loop runs up to m times (where m is the length of needle) for each iteration. This results in a worst-case time complexity of O(n * m). However, in most cases, the inner loop terminates early due to mismatches, leading to better average performance.
Space Complexity:

The solution uses only a few extra pointer variables and does not require additional data structures, resulting in a constant space complexity of O(1).

Conclusion

This two-pointer approach provides a clear and intuitive solution for the string matching problem. While it is efficient for many cases, more advanced algorithms—such as the Knuth-Morris-Pratt (KMP) algorithm—can offer better performance in worst-case scenarios when dealing with very large strings.

Docker Woes: When Containers Refuse to Listen and Databases Play Hard to Get

JohnKagunda — Tue, 12 Nov 2024 04:58:59 +0000

We can all agree at this point that Docker is a unique tool. The magic of having a consistent environment for both development and production is truly one of a kind.

Despite its many benefits, setting it up can sometimes be a bit of a headache, whether it's for a single container or a network of containers.

In this article, we will look at:

Why you can't stop/kill your container and why it happens
Access Denied issues on database containers, even when using the correct username and password

Why can't I stop/kill my Docker container, and why does this happen?

Docker containers can become extremely frustrating when you try Ctrl + C or Cmd + C, and the container does not stop. You might start questioning your life choices, and eventually, you open another terminal to kill it using docker kill, only to receive a Permission denied error, even when running with sudo.

Instead of rebooting your system each time or trying to reset your Docker service, using kill -9 can help. First, find all running services using pgrep docker, then pick the process numbers and use kill -9 <process number> to terminate the process.

Why does this happen?

This issue often occurs because the process running inside the Docker container has a restart policy or operand.

For example, consider the following process:

uvicorn main:app --reload

If you run this app inside a Docker container and let it start by default when the container is launched, you won't be able to kill it because the --reload option continuously restarts the app, even when the SIGINT signal is sent.

`Access Denied` on database containers, even with the correct username and password

This problem can be puzzling. You might think, "Did I miss a comma, or perhaps there's an extra space?" Maybe you suspect there's an "Egyptian semicolon" in the password. But no, I’m sure of it — I copy-pasted the credentials, so even the Egyptian semicolon should have worked.

The issue occurred while using a docker-compose.yml file. The strange part was that the image ran fine on a single Docker container but failed when used with a docker-compose file. I began removing extra parameters I wasn’t using when running the container individually, and it all came down to one culprit: MYSQL_HOST.

Specifying this parameter caused a myriad of problems, as outlined in the issue here.

Avoiding it is a better way to resolve the problem.

Dockerfile Best Practices: Building Efficient and Secure Containers

JohnKagunda — Fri, 16 Aug 2024 16:32:19 +0000

Docker has revolutionized the way we develop, ship, and run applications. However, writing an efficient and secure Dockerfile is crucial to ensure your containers perform well and are safe from vulnerabilities. In this article, we’ll explore some best practices that can help you create robust Docker images.

1. Use Official Base Images

Always start your Dockerfile with an official base image from Docker Hub, such as alpine, ubuntu, or node. Official images are maintained by Docker and are regularly updated for security patches.

FROM python:3.9-slim

Why?

Security: Official images are vetted for security vulnerabilities.
Stability: They are tested and maintained by the community or the official project maintainers.

2. Leverage Multi-Stage Builds

Multi-stage builds allow you to separate the build environment from the final runtime environment, reducing the size of your Docker image.

# Stage 1: Build
FROM golang:1.19 AS builder
WORKDIR /app
COPY . .
RUN go build -o myapp

# Stage 2: Runtime
FROM alpine:latest
WORKDIR /app
COPY --from=builder /app/myapp .
CMD ["./myapp"]

Why?

Reduced Image Size: Only the necessary files are included in the final image.
Security: Keeps build tools and other unnecessary components out of your runtime environment.

3. Minimize Layers

Each RUN, COPY, or ADD instruction creates a new layer in your image. Combining commands in a single RUN instruction can help minimize the number of layers.

RUN apt-get update && apt-get install -y \
    curl \
    vim \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

Why?

Efficiency: Reduces the size of the Docker image and improves build performance.
Maintainability: Fewer layers make the image easier to understand and manage.

4. Use `.dockerignore` File

Include a .dockerignore file to prevent unnecessary files from being copied into the Docker image.

node_modules
*.log
Dockerfile
README.md

Why?

Smaller Images: Excluding unnecessary files reduces the final image size.
Faster Builds: Fewer files to copy means faster build times.

5. Avoid Installing Unnecessary Packages

Only install the packages and dependencies that are absolutely necessary for your application to run.

RUN apt-get update && apt-get install -y \
    curl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

Why?

Security: Fewer packages mean fewer potential vulnerabilities.
Performance: Reducing the number of packages improves image build times and runtime performance.

6. Use Non-Root User

Running your application as a non-root user inside the container enhances security.

# Create a non-root user
RUN useradd -m appuser
USER appuser

CMD ["./myapp"]

Why?

Security: Limits the impact of a security breach by reducing the permissions available to the running process.

7. Optimize Caching

Take advantage of Docker’s layer caching to speed up your builds. Place commands that change less frequently towards the top of your Dockerfile.

# Dependencies
COPY requirements.txt .
RUN pip install -r requirements.txt

# Application code
COPY . .

Why?

Efficiency: Docker reuses layers from the cache, leading to faster builds, especially during development.

8. Clean Up After Yourself

Remove temporary files, package managers’ cache, and other unnecessary files after installation.

RUN apt-get update && apt-get install -y \
    curl \
    && apt-get clean \
    && rm -rf /var/lib/apt/lists/*

Why?

Smaller Images: Removing unnecessary files helps keep your Docker image lean.
Better Performance: Smaller images download faster and use less disk space.

9. Set Metadata Labels

Use labels to add metadata to your images, such as version information or maintainer contact details.

LABEL maintainer="rafaeljohn@example.com"
LABEL version="1.0"
LABEL description="My application Docker image"

Why?

Organizational: Helps track image versions, authorship, and purpose.
Automation: Labels can be used in automation tools to filter or organize images.

10. Scan Images for Vulnerabilities

Regularly scan your Docker images for vulnerabilities using tools like Trivy or Clair.

Why?

Security: Regular scans help identify and fix vulnerabilities before they can be exploited.

By following these best practices, you’ll be well on your way to building efficient, secure, and maintainable Docker images. Remember, a well-crafted Dockerfile not only ensures the smooth operation of your applications but also contributes to the overall security and performance of your environment.

Happy Dockerizing!

Docker Advanced Techniques: Beyond the Basics

JohnKagunda — Wed, 14 Aug 2024 18:16:55 +0000

Docker is an incredible tool that makes managing applications easier. Most people are familiar with the basics: creating containers, managing images, and using Docker Compose. But there's so much more you can do with Docker! In this article, I'll walk you through some advanced techniques that will level up your Docker game.

1. Multi-Stage Builds

Ever wondered how to keep your Docker images small and efficient? Multi-stage builds are the answer! They allow you to use multiple FROM statements in your Dockerfile, each with a different purpose.

Here's a simple example:

# Stage 1: Build the application
FROM node:14 AS build
WORKDIR /app
COPY . .
RUN npm install && npm run build

# Stage 2: Run the application
FROM nginx:alpine
COPY --from=build /app/build /usr/share/nginx/html

In this Dockerfile, we first build our Node.js app in a full Node.js environment, and then in the second stage, we copy only the necessary files into a lightweight Nginx container. This keeps the final image small and fast.

2. Using Docker Volumes for Persistence

Docker containers are ephemeral by nature, meaning they don't keep data once stopped or removed. But what if you need to store data that persists even after the container stops? This is where Docker volumes come in.

Volumes allow you to persist data outside the container's filesystem. Here’s how you can use them:

docker run -d \
  --name my_app \
  -v my_data:/data \
  my_image

In this command, -v my_data:/data creates a volume named my_data and mounts it to the /data directory inside the container. Your data will be safe even if the container is removed!

3. Docker Networking for Communication

When working with multiple containers, you'll often need them to communicate. Docker provides networking options to make this seamless. The most common approach is to use a bridge network.

First, create a network:

docker network create my_network

Then, run your containers on this network:

docker run -d --name app1 --network my_network my_image1
docker run -d --name app2 --network my_network my_image2

Now, app1 and app2 can communicate with each other using their container names as hostnames. Simple, right?

4. Docker Compose for Multi-Container Applications

Docker Compose is a powerful tool for managing multi-container applications. With a single YAML file, you can define and run all your services together.

Here’s a basic example:

version: '3'
services:
  web:
    image: nginx
    ports:
      - "80:80"
  db:
    image: postgres
    environment:
      POSTGRES_PASSWORD: example

Running docker-compose up in the directory containing this file will start both the Nginx and Postgres containers, ready to work together.

5. Automating Docker with CI/CD Pipelines

For those who want to take their Docker usage to the next level, integrating Docker with CI/CD (Continuous Integration/Continuous Deployment) pipelines is the way to go. Tools like Jenkins, GitLab CI, or GitHub Actions can automate your Docker workflows.

Here’s an example of a GitHub Actions workflow for building and pushing a Docker image:

name: Docker CI

on:
  push:
    branches:
      - main

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - name: Build Docker image
        run: docker build -t my_app:latest .
      - name: Log in to Docker Hub
        run: echo ${{ secrets.DOCKER_PASSWORD }} | docker login -u ${{ secrets.DOCKER_USERNAME }} --password-stdin
      - name: Push Docker image
        run: docker push my_app:latest

This workflow builds your Docker image every time you push to the main branch and then pushes it to Docker Hub.

Wrapping Up

Docker is more than just a tool for containerizing applications; it's a whole ecosystem that can transform how you develop, deploy, and manage your apps. By mastering these advanced techniques, you'll be well on your way to becoming a Docker pro. Happy tinkering!

It's Working on My Machine; "Deploy Your Machine Then"

JohnKagunda — Mon, 12 Aug 2024 08:28:54 +0000

We’ve all heard the joke: “It’s working on my machine; deploy your machine then.” This joke highlights a common problem in software development: software that runs perfectly on a developer’s local machine might not work the same way when deployed to a different environment.

To tackle this issue, developers needed a way to ensure that software runs consistently across different machines. That’s where Docker containers come in.

What Are Docker Containers?

Docker containers are a technology that allows you to package your application and all its dependencies into a single, portable unit. Think of a Docker container as a lightweight, self-contained box that holds everything your application needs to run.

Why Use Docker Containers?

Consistency: Since the container includes the application and all its dependencies, you can be sure that it will work the same way on any machine. Whether it’s your local development machine or a production server, the container will behave the same.
Isolation: Containers run in isolation from each other and from the host system. This means that one container’s processes won’t interfere with another’s, and your application won’t affect the underlying system.
Portability: Containers can be moved easily from one environment to another. You can build a container on your local machine and deploy it to a cloud server without worrying about compatibility issues.

Example: Running a Simple Web App in Docker

Let’s go through a basic example of using Docker containers. Suppose you have a simple web application that requires Python and some libraries to run.

Create a Dockerfile: This file describes how to build your Docker image. It includes instructions for setting up the environment and installing dependencies.

# Use the official Python image from Docker Hub
FROM python:3.8

# Set the working directory in the container
WORKDIR /app

# Copy the application code into the container
COPY . /app

# Install the dependencies
RUN pip install -r requirements.txt

# Define the command to run the application
CMD ["python", "app.py"]

Build the Docker Image: Run the following command in your terminal to create an image from the Dockerfile.
```
docker build -t my-web-app .
```
This command builds an image named my-web-app using the current directory (denoted by .) as the build context.
Run the Docker Container: Start a container from the image you just built.
```
docker run -p 5000:5000 my-web-app
```
This command runs the my-web-app container and maps port 5000 of the container to port 5000 on your local machine.
Access the Application: Open your web browser and go to http://localhost:5000. You should see your web application running.

By using Docker containers, you’ve packaged your application in a way that makes it easy to deploy and run consistently, no matter where you are. This eliminates the “it works on my machine” problem and simplifies the deployment process.

Conclusion

Docker containers are a powerful tool for ensuring your applications run smoothly across different environments. They provide consistency, isolation, and portability, making them a popular choice for modern software development. By using containers, you can avoid common deployment issues and focus on building great software.

Check out this video about Docker in 100 seconds

Building a Monty Bytecode Interpreter: A Hands-On Approach to Learning Stacks and Queues

JohnKagunda — Wed, 07 Aug 2024 11:19:47 +0000

Understanding the Monty Bytecode Interpreter: A Comprehensive Guide

Introduction

In the realm of programming languages and interpreters, the Monty Bytecode Interpreter stands out as a valuable tool for learning and mastering core computer science concepts such as stacks, queues, and data manipulation. This article delves into what the Monty Bytecode Interpreter is, why it is significant, and how recreating it can significantly enhance your technical skills.

What is the Monty Bytecode Interpreter?

The Monty Bytecode Interpreter is a simple interpreter designed to execute a custom bytecode language. It is a part of a learning exercise, often associated with educational programming courses or challenges. The Monty Bytecode Interpreter operates on a stack-based virtual machine, which interprets a series of bytecode instructions to perform various operations.

Key Features

Stack-Based Architecture: The interpreter relies on a stack for executing bytecode instructions. This stack-based model is fundamental in understanding how low-level operations are performed in various computing environments.
Bytecode Language: Monty Bytecode is a minimalistic language consisting of a set of predefined instructions. These instructions are designed to demonstrate basic control flow and data manipulation.
Virtual Machine: The interpreter simulates a virtual machine environment where bytecode instructions are executed sequentially.

Components of the Monty Bytecode Interpreter

Bytecode Instructions: The interpreter processes a set of bytecode instructions such as push, pop, pall, pint, etc. Each instruction performs a specific operation on the stack or prints output.
Stack Operations: The Monty Bytecode Interpreter primarily uses a stack to manage data. Common stack operations include push (to add an item to the stack) and pop (to remove the top item from the stack).
Execution Loop: The interpreter reads bytecode instructions and executes them in a loop. It maintains a program counter to keep track of the current instruction being executed.
Error Handling: Proper error handling mechanisms are essential for interpreting invalid instructions or handling stack underflow/overflow situations.

Why Recreate the Monty Bytecode Interpreter?

Recreating the Monty Bytecode Interpreter is a valuable exercise for several reasons:

1. Deepens Understanding of Stacks

The stack is a fundamental data structure used extensively in computer science. By implementing a stack-based interpreter, you gain hands-on experience with stack operations such as push, pop, and peek. Understanding how the stack manages data in real-time helps solidify your knowledge of this crucial data structure.

2. Enhances Knowledge of Queues

While the Monty Bytecode Interpreter is primarily stack-based, you might integrate queues to handle certain operations or manage instructions. Learning how to implement and use queues in conjunction with stacks provides a broader perspective on data management and manipulation.

3. Improves Bytecode Interpretation Skills

Writing an interpreter requires you to understand how to parse and execute low-level instructions. This exercise enhances your skills in interpreting and executing bytecode, which is relevant for understanding how modern programming languages work at a fundamental level.

4. Boosts Debugging and Error-Handling Abilities

Implementing a bytecode interpreter involves addressing various edge cases, such as invalid instructions or stack underflows. Developing robust error-handling mechanisms sharpens your debugging skills and prepares you for real-world programming challenges.

5. Strengthens Algorithmic and System Design Skills

Designing and implementing an interpreter involves algorithmic thinking and system design. You need to create efficient algorithms for instruction execution and design a system that manages data effectively. This exercise improves your overall problem-solving and system design abilities.

Conclusion

The Monty Bytecode Interpreter is more than just a simple interpreter; it is a powerful tool for learning and mastering fundamental computer science concepts. By recreating it, you not only enhance your understanding of stacks and queues but also improve your debugging, algorithmic, and system design skills. Whether you're a beginner or an experienced developer, this exercise offers valuable insights into the inner workings of interpreters and virtual machines.

Exploring Lesser-Known but Essential Git Commands

JohnKagunda — Mon, 05 Aug 2024 12:30:28 +0000

While many are familiar with basic commands like git add, git commit, and git push, there are several lesser-known commands that can be equally important. Understanding these commands can help you become more efficient and effective in your version control practices.

1. `git stash`

Imagine you're working on a feature, and suddenly you need to switch branches to fix a critical bug. You don't want to commit incomplete work, but you also don't want to lose your changes. This is where git stash comes in handy.

Command:

git stash

This command temporarily shelves (or stashes) your changes, allowing you to switch branches without committing. Later, you can reapply your stashed changes with:

git stash apply

2. `git cherry-pick`

Have you ever committed a bug fix on one branch and then realized that the same fix is needed on another branch? Instead of copying and pasting the changes, you can use git cherry-pick.

Command:

git cherry-pick <commit-hash>

This command applies the changes from a specific commit to your current branch. It’s like plucking a cherry from one tree and placing it on another!

3. `git bisect`

When trying to find the commit that introduced a bug, git bisect can be a lifesaver. It uses a binary search algorithm to efficiently pinpoint the problematic commit.

Command:

git bisect start
git bisect bad
git bisect good <commit-hash>

Git will then check out different commits, asking you to mark them as good or bad, until it identifies the offending commit.

4. `git reflog`

Ever made a mistake and wished you could turn back time? git reflog is your time machine. It logs every change made to the tip of branches and allows you to recover lost commits.

Command:

git reflog

You can then use git checkout <commit-hash> or git reset --hard <commit-hash> to revert to a previous state.

5. `git blame`

Want to know who made a specific change in a file? git blame can tell you. It shows the commit hash, author, and timestamp for each line in a file.

Command:

git blame <file>

This can be useful for tracking down when a change was introduced and who made it.

6. `git clean`

When your working directory gets cluttered with untracked files, git clean can help you tidy up.

Command:

git clean -f

The -f flag stands for force, as Git wants to ensure you really want to remove those files. For added caution, use the -n flag to perform a dry run and see what would be removed:

git clean -n

7. `git log --graph --oneline`

If you want a visual representation of your commit history, git log --graph --oneline is perfect. It provides a concise, graphical view of your branch history.

Command:

git log --graph --oneline

This is particularly useful for understanding complex branching and merging histories.

8. `git shortlog`

For a summary of contributions by author, git shortlog is very helpful. It groups commit messages by author and can give you an overview of who has contributed what.

Command:

git shortlog

Add the -s flag to see a summary:

git shortlog -s

9. `git diff`

While git diff is commonly known, many don't use it to its full potential. It shows changes between commits, commit and working tree, etc.

Command:

git diff

To compare changes between two branches:

git diff branch1..branch2

10. `git show`

git show is a versatile command that shows various types of objects, including commits, trees, and tags.

Command:

git show <object>

For instance, to see the details of a specific commit:

git show <commit-hash>

Conclusion

By incorporating these lesser-known but powerful Git commands into your workflow, you can enhance your productivity and make your version control more effective.

Feel free to explore these commands in your projects, and don't hesitate to refer back to this guide whenever you need a quick refresher. Git is an indispensable tool, and mastering it can significantly improve your development experience.

Avoid Common Pitfalls: Octocat's Tips for Better Git Commits🐙 🐱🐈

JohnKagunda — Sat, 03 Aug 2024 11:52:38 +0000

Well, if you are reading this article we can agree that our git commits are not what we are most proud of. Mostly, it's because of the idea that we are just putting up our code in GitHub or a remote repo.

Quick Fact: Do you know you can make git commits without the use of GitHub, GitLab, or any remote repository?

Try it:

mkdir my_project
cd my_project
git init
touch README.md
git add README.md
git commit -m "Added a README file"

Now you have a git repository on your local machine, you can write code and commit some more with no worries. If you want to keep track just use git log to see the commit history.

Then why do we need git commits?

Well, commits just help you keep track of different versions of your code. It is like a time machine for your code. You can always go back to a previous version of your code if you want to.

Well, now with this ideology we can now all agree commits are important.

Commit messages are like the ID of different versions of you. You wouldn't want to go to the past and when you try to check the different versions you, all you have as the ID is Small changes or WIP. That would be a nightmare.

So what makes a good commit message?

Short and sweet: A commit message should be short and sweet.
Meaningful: A commit message should be meaningful.
Consistent: A commit message should be consistent.
Use the imperative mood: A commit message should use the imperative mood.

Let's see comparisons between good commit messages and bad commit messages:

Aspect	Bad Commit Message	Good Commit Message
Clarity	"Fix"	"Fix null pointer exception in user login"
Specificity	"Bug fix"	"Fix bug causing crash when username is empty"
Context	"Updated"	"Update dependencies to latest versions"
Feature Addition	"Added new feature"	"Add search functionality to the product catalog"
Initial Commit	"Initial commit"	"Initial commit: setup project structure and dependencies"

Well, now when it comes to maintaining your codebase with good commit history, you can always go back to a previous version of your code and see what you did in that commit.
You can also see the commit message and understand what you did in that commit.

Conclusion

So, in conclusion, commit messages are important.

They help you keep track of different versions of your code.
They help you understand what you did in that commit.
They help you maintain your codebase.

So, next time you make a commit, make sure you commit to its message first.

If it quacks like a duck 🦆🐥

JohnKagunda — Thu, 01 Aug 2024 08:37:54 +0000

Duck typing is an interesting concept to learn and also very valuable when you understand it.

So what is duck typing?

A famous concept was made to make understanding this simpler:

if it quacks like a duck, then it is a duck

Well, let's look at this using a simple example:

class Duck:
    def quack(self):
        print("Quack!")

class Goose:
    def quack(self):
        print("Quack!")

class Dog:
    def bark(self):
        print("Woof!")

In the example above, a duck quacks as well as a goose, while a dog only barks. According to duck typing, we can agree that a duck and a goose may as well both be ducks.

So the next question is:

Why is this important?

Let's use already existing components min and max inbuilt functions in Python.
Duck typing is one of the reasons why they are so efficient in getting the minimum and the maximum values.

Comparability

min checks for the method __lt__ inside the object called, regardless of the class, while max checks for the method __gt__.

Iterability

The collection passed to min or max must be iterable. This means it should implement the __iter__ method, which allows the function to traverse through the elements of the collection.

Here is a simple example:

class ComparableObject:
    def __init__(self, value):
        self.value = value

    def __lt__(self, other):
        return self.value < other.value

    def __gt__(self, other):
        return self.value > other.value

    def __repr__(self):
        return f'ComparableObject({self.value})'

a = ComparableObject(10)
b = ComparableObject(20)
c = ComparableObject(5)

objects = [a, b, c]

print(min(objects))  # Outputs: ComparableObject(5)
print(max(objects))  # Outputs: ComparableObject(20)

In this example, ComparableObject implements the __lt__ and __gt__ methods, allowing instances of this class to be compared using the < and > operators. This makes them suitable for use with min and max.

Duck Typing in Action:

When min(objects) is called, Python checks if each element in objects can be compared using the < operator. It doesn't care about the type of the elements as long as they can be compared.
Similarly, when max(objects) is called, Python checks if each element can be compared using the > operator.

Because ComparableObject implements the necessary comparison methods, min and max work with instances of this class, demonstrating duck typing. The focus is on the presence of the required methods (__lt__ and __gt__), not on the specific type of the objects.

In conclusion, duck typing is a powerful and flexible programming paradigm that emphasizes an object's behavior over its explicit type.

This approach allows for more reusable and adaptable code, as seen in the seamless operation of Python's min and max functions.

By focusing on the presence of necessary methods and attributes, duck typing promotes a more intuitive and efficient coding style, ultimately leading to cleaner and more maintainable codebases.

Embracing duck typing can enhance your programming skills, making you a more versatile and effective developer in dynamically typed languages like Python.

Tackling Complex Backend Challenges: My Journey with HNG Internship

JohnKagunda — Mon, 01 Jul 2024 05:03:34 +0000

Introduction

Hello, tech enthusiasts! My name is Rafael John, and I am a full-stack developer with a passion for backend development. Recently, I faced a particularly challenging backend problem that tested my skills and determination. In this blog post, I’ll walk you through the problem, how I approached it, and the solution I implemented. Additionally, I'll share my excitement about starting my journey with the HNG Internship and why this opportunity is so important to me.

The Challenge

The problem I encountered involved optimizing a complex data processing pipeline for a client project. The system was built using Python and Flask, with a MySQL database for storing processed data. The challenge was to reduce the processing time and improve the overall efficiency of the system. The existing solution was slow, and the client needed a faster, more reliable system.
Breaking Down the Solution

Analyzing the Bottlenecks
The first step was to identify the main bottlenecks in the existing system. I used profiling tools to monitor the performance of each component in the pipeline. This helped me pinpoint areas where the system was slowing down.
Database Optimization
I noticed that the database queries were a major bottleneck. To address this, I optimized the queries by adding appropriate indexes and restructuring the database schema. This significantly improved the query performance.
- Efficient Data Processing The data processing logic was another area that needed improvement. I refactored the code to use more efficient algorithms and data structures. Additionally, I implemented batch processing to handle large datasets more effectively.
- Asynchronous Processing To further enhance performance, I integrated asynchronous processing using Celery and Redis. This allowed the system to handle multiple tasks concurrently, reducing the overall processing time.
- Caching Frequently Accessed Data I implemented caching using Redis to store frequently accessed data. This reduced the load on the database and improved the system's response time.
- Testing and Deployment After implementing the optimizations, I thoroughly tested the system to ensure it met the client's requirements. Finally, I deployed the updated system using Docker and Nginx, ensuring it was scalable and easy to maintain.

Results

The optimizations resulted in a significant reduction in processing time, from several hours to just under 30 minutes. The client was thrilled with the improved performance and reliability of the system.
My Journey with HNG Internship

I am incredibly excited to start my journey with the HNG Internship. This program is a fantastic opportunity to learn from industry experts and collaborate with other talented developers. The hands-on experience and mentorship provided by the HNG Internship will help me grow as a backend developer and tackle even more complex challenges in the future.

The HNG Internship is not just about coding; it's about building a network, gaining real-world experience, and becoming a part of a vibrant community. If you're interested in learning more about the program, check out the HNG Internship website and HNG Premium.

Conclusion

Solving complex backend challenges requires a combination of analytical thinking, technical skills, and perseverance. I am proud of the solution I developed for my client and excited about the journey ahead with the HNG Internship. This experience has reinforced my passion for backend development and my commitment to continuous learning and improvement.

Thank you for reading, and I hope my story inspires you to tackle your own challenges with determination and creativity. Let's continue to learn and grow together!

Make your own music downloader website

JohnKagunda — Tue, 11 Jun 2024 01:49:13 +0000

How I Built My Music Downloader Site

Disclaimer: Services described in this post are in courtesies of
the Service providers, codes described in this post may be used only for educational purposes

Creating my music downloader site was an exciting and educational journey. I leveraged the Spotify API and Pytube to build a seamless experience for users who want to discover and download music. Here’s a detailed walkthrough of how I achieved this.
Backend Development

Integrating Spotify API

The first step was to integrate the Spotify API to fetch tracks and preview music. Setting up the Spotify component was straightforward:

Register your application: Sign up on the Spotify Developer Dashboard and create a new application to get your API credentials.
Get an access token: Use the credentials to request an access token. This token will authenticate your API requests.
Fetch tracks: Use the access token to query the Spotify API and fetch tracks based on user search inputs. Spotify's rich API provides detailed information including track previews, album art, and links to Spotify.

Here's a quick code snippet on how you can achieve this:

python

import requests

# Define the API endpoint and access token
SPOTIFY_API_URL = 'https://api.spotify.com/v1/search'
access_token = 'YOUR_ACCESS_TOKEN'

def search_spotify(query):
    headers = {
        'Authorization': f'Bearer {access_token}'
    }
    params = {
        'q': query,
        'type': 'track'
    }
    response = requests.get(SPOTIFY_API_URL, headers=headers, params=params)
    return response.json()

Creating the API Endpoint

Once I had the data from Spotify, I created an endpoint using Flask to serve this data to my frontend:

python

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/search', methods=['GET'])
def search():
    query = request.args.get('query')
    results = search_spotify(query)
    return jsonify(results)

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

Implementing the Download Option with Pytube

The next challenge was to enable downloading the music. I used Pytube to fetch music from YouTube based on the track title and artist:

python

from pytube import YouTube
from io import BytesIO

def download_youtube_audio(query):
    # Find the YouTube video using the query
    yt = YouTube(f'https://www.youtube.com/results?search_query={query}')
    video = yt.streams.filter(only_audio=True).first()

    # Download the audio to a BytesIO buffer
    buffer = BytesIO()
    video.stream_to_buffer(buffer)
    buffer.seek(0)

    return buffer

By saving the audio in a buffer (using BytesIO), I was able to transport this buffer through the API endpoint, thus overcoming the challenge of file directory dependency.

Here’s how the Flask endpoint looked for handling the download:

python

@app.route('/download', methods=['GET'])
def download():
    track_title = request.args.get('track_title')
    artist = request.args.get('artist')
    query = f"{track_title} {artist}"
    audio_buffer = download_youtube_audio(query)

    return send_file(audio_buffer, as_attachment=True, download_name=f"{track_title}.mp3", mimetype='audio/mpeg')

Frontend Integration

On the Frontend, when a user searches for a music track, an API request is sent to my backend API which queries the Spotify API. The results, including music images, previews, and direct Spotify links, are displayed to the user.

When the user wants to download a track, they specify the track title and artist for accuracy. An API request is then sent to the backend, which uses Pytube to fetch and deliver the audio file.
Conclusion

Building this site was a rewarding experience, combining several technologies to provide a useful service. For a more detailed post-mortem, check out

You can also explore the site .

DEV Community: JohnKagunda

The Beauty of Git: Writing Code Stories

The Art of Storytelling Through Commits

Writing Commits That Matter

The Power of Atomic Commits

Rebase: The Editor's Revision Process

When Stories Take Unexpected Turns: Cherry-Pick to the Rescue

The Cherry-Pick Rescue Mission

Common Cherry-Pick Scenarios

The Beautiful Git Workflow

The Transformation

Leetcode: Two Ptrs: Easy

Problem Statement

Example 1

Example 2

Two-Pointer Technique Solution

Explanation

Performance Analysis

Conclusion

Docker Woes: When Containers Refuse to Listen and Databases Play Hard to Get

Why can't I stop/kill my Docker container, and why does this happen?

Why does this happen?

Access Denied on database containers, even with the correct username and password

Dockerfile Best Practices: Building Efficient and Secure Containers

1. Use Official Base Images

Why?

2. Leverage Multi-Stage Builds

Why?

3. Minimize Layers

Why?

4. Use .dockerignore File

Why?

5. Avoid Installing Unnecessary Packages

Why?

6. Use Non-Root User

Why?

7. Optimize Caching

Why?

8. Clean Up After Yourself

Why?

9. Set Metadata Labels

Why?

10. Scan Images for Vulnerabilities

Why?

Docker Advanced Techniques: Beyond the Basics

1. Multi-Stage Builds

2. Using Docker Volumes for Persistence

3. Docker Networking for Communication

4. Docker Compose for Multi-Container Applications

5. Automating Docker with CI/CD Pipelines

Wrapping Up

It's Working on My Machine; "Deploy Your Machine Then"

What Are Docker Containers?

Why Use Docker Containers?

Example: Running a Simple Web App in Docker

Conclusion

Building a Monty Bytecode Interpreter: A Hands-On Approach to Learning Stacks and Queues

Understanding the Monty Bytecode Interpreter: A Comprehensive Guide

Introduction

What is the Monty Bytecode Interpreter?

Key Features

Components of the Monty Bytecode Interpreter

Why Recreate the Monty Bytecode Interpreter?

1. Deepens Understanding of Stacks

2. Enhances Knowledge of Queues

3. Improves Bytecode Interpretation Skills

4. Boosts Debugging and Error-Handling Abilities

5. Strengthens Algorithmic and System Design Skills

Conclusion

Exploring Lesser-Known but Essential Git Commands

1. git stash

2. git cherry-pick

3. git bisect

4. git reflog

5. git blame

6. git clean

7. git log --graph --oneline

8. git shortlog

9. git diff

10. git show

`Access Denied` on database containers, even with the correct username and password

4. Use `.dockerignore` File

1. `git stash`

2. `git cherry-pick`

3. `git bisect`

4. `git reflog`

5. `git blame`

6. `git clean`

7. `git log --graph --oneline`

8. `git shortlog`

9. `git diff`

10. `git show`