DEV Community: Priya

Breaking Down the Cloud: A Simple Guide for Beginners

Priya — Sun, 14 Dec 2025 07:56:35 +0000

I recently started learning DevOps and cloud computing, and one thing I realized very quickly is that cloud basics sound complicated — until you explain them simply.

This post is part of a beginner-friendly series where I share what I’m learning as I go. No expert talk, no buzzwords — just practical understanding from someone who’s getting started.

What the Cloud Actually Means

At its core, cloud computing means:

On-demand delivery of IT resources over the internet with pay-as-you-go pricing.

Let’s break that down in simple terms.

🔹 On-demand delivery

You get resources when you need them.

You don’t have to plan months ahead or buy hardware upfront. If you need a server right now, you can create one in minutes. If you don’t need it anymore, you can delete it.

🔹 IT resources

These are the building blocks you usually need to run applications, such as:

Servers (virtual machines)
Databases
Storage
Networking components (load balancers, firewalls, etc.)

Instead of owning these physically, you rent them from a cloud provider.

🔹 Over the internet

Cloud resources are accessed over the internet.

As long as you have an internet connection, you can manage your infrastructure from anywhere in the world.

🔹 Pay-as-you-go pricing

You pay only for what you use.

If a server runs for one hour, you pay for one hour. If it’s stopped, you usually don’t pay for compute anymore. This flexibility is powerful — but it also means you need to be careful with unused resources.

What are virtual machines?

VMs provide flexibility, and are foundational to cloud computing, enabling multiple virtual servers on single hardware.

A virtual machine (VM) is a software-based computer that runs inside a physical computer (the "host"), allowing you to run an entire operating system (like Windows on a Mac, or Linux on Windows) and its applications in an isolated environment, using a portion of the host's hardware resources (CPU, RAM, storage).

If you have a powerful server, you wouldn’t want to dedicate it to just one OS. Virtualization allows you to split that server’s resources to run multiple VMs, each with its own operating system, efficiently using the hardware.

Types of Cloud Services

Cloud services are generally divided into three models, based on what the provider manages versus what the user controls:

🔹 IaaS (Infrastructure as a Service)

IaaS provides virtualized computing resources over the internet. You rent servers, storage, and networks, but you manage the operating system and applications yourself.

Examples: AWS, GCP, Azure

🔹 PaaS (Platform as a Service)

PaaS provides a platform for developing and running applications without managing the underlying servers, storage, or networking — the provider takes care of the infrastructure.

Examples: Heroku, Google App Engine

🔹 SaaS (Software as a Service)

SaaS delivers fully managed software applications over the cloud. You use the software without worrying about infrastructure or platform management.

Examples: Gmail, Dropbox, Slack

Why you can try it

Flexible, pay-as-you-go costs instead of fixed expenses.
Lower maintenance and running costs compared to owning hardware.
Scale capacity up or down without worrying about servers.
Elasticity — automatically scale resources up or down to meet changing demand.
Agility — quickly allocate resources, adapt to changing workloads, and rapidly test & deploy applications.

Wrap Up

Cloud computing might seem complex at first, but breaking it down into simple concepts like on-demand resources, virtualization, and benefits makes it much easier to understand.

Fixing ChatGPT’s Hidden Edit Button – A Reminder That Testing Matters!

Priya — Sat, 15 Feb 2025 11:01:57 +0000

Today, I ran into a strange issue—I couldn’t edit my messages in ChatGPT! 🤔 At first, I thought it was a bug, but after some searching, I found the solution in a forum thread.

The Issue?

The edit button wasn’t removed—it was just hidden using display: none; in CSS! Maybe this happened after they added a certain feature and forgot to re-enable it?

The Fix?

I followed the forum’s suggestion:

Open DevTools (Right-click → Inspect or press F12).
Find the edit button’s HTML.
Remove display: none; from its styles.

And boom—the edit button was back! 🎉

Before...

After...

Keep in mind, this fix only works until you refresh the page. A permanent fix would require changes from OpenAI’s side.

Turns out, the edit button was just playing hide and seek behind display: none; 😆

Why This Matters – The Importance of Testing

This small UI issue is a great example of why testing is crucial, even for well-established products. A simple CSS rule change can unintentionally break core functionality.

🔹 UI testing could have caught this before release.

🔹 Regression testing might have flagged the missing edit button.

🔹 User feedback helped surface the issue, but it’s always better to catch it earlier!

Even big companies can have small oversights, and this is why thorough testing matters—whether you're working on a personal project or a large-scale application.

Have you ever fixed a UI bug like this? Share your experience in the comments!

Wait... Should We Be Doing It This Way?

Priya — Fri, 07 Feb 2025 17:28:32 +0000

Every developer has that moment when they stumble upon something in their codebase that makes them pause and think: “Wait... should we really be doing it this way?” Recently, I had a few of those moments, and they sparked some learning opportunities.

From unconventional API endpoint names to sending plaintext passwords over HTTPS, and even battling XSS attacks, it’s been a series of challenges. Let me take you on this journey!

1. API Naming 🔍

Imagine you’re the new developer on the team, and you see API endpoints named get_accounts or remove_folders.

Functional? Yes. Elegant? Not so much.

It’s like calling a restaurant menu item “Fetch_Burger” instead of just “Burger🍔"

What’s the Problem?

It’s not RESTful. REST APIs are meant to be clean and resource-oriented, not action-packed.
Action vs. Resource: RESTful API design focuses on resources rather than actions. Think of an action like get or remove as something that should be implied by the HTTP verb, not included in the URL.

The Fix:

Let the HTTP methods do the heavy lifting!

GET /accounts instead of GET /get_accounts
DELETE /folders/{folder_id} instead of DELETE /remove_folders/{folder_id}

Now, it’s like having a clean, organized menu where you know exactly what to expect.

2. DOM Manipulation in Ember.js 🔧

I stumbled upon some .js files where the DOM was being accessed directly, like this:

document.querySelector('#my-element').textContent = 'Hello';

This felt like bypassing a chef in a fancy restaurant to cook your own food in their kitchen—messy, unnecessary, and against the rules😒.

Why This Matters:

Ember.js is built to handle the DOM for you. Manual manipulation can break reactivity and create inconsistencies.
It also has powerful tools like tracked properties and services that help manage state without directly manipulating the DOM. By embracing this, you make your components more maintainable and avoid potential issues with synchronization between the UI and underlying state.

The Fix:

Let Ember do the heavy lifting with its reactive template system:

<h1>{{this.greeting}}</h1>

Need to interact with the DOM? Use lifecycle hooks. This keeps your code elegant, predictable, and future-proof.

3. Passwords Over HTTPS 🔐

Is it ok to send plaintext passwords over HTTPS? Yes, HTTPS encrypts traffic, but it’s like locking your front door while leaving your house key under the mat—it’s still a bad idea🫤.

Why It’s Risky:

Logs or intermediaries might capture plaintext passwords.

The Fix:

Handle passwords securely on the server.
Instead of storing passwords as plaintext, hash them using algorithms like bcrypt, or scrypt with a unique salt for each password.
Consider token-based authentication systems (like JWTs) to replace raw password handling altogether.

Want to dive deeper into JWTs and why they're a game-changer for secure authentication? Check out this post.

4. XSS Attacks🛡️

This one felt like a mini-war. We recently discovered XSS vulnerabilities in the codebase—where attackers could inject malicious scripts into our web pages. It was like realizing you’ve left your windows open during a storm💨.

Get a clear understanding of XSS 🤏 here.

The Risks:

Attackers can steal data, hijack sessions, or run unauthorized scripts.

How We Fought Back:

Input Sanitization: We made sure all user inputs are cleaned up before rendering.
Content Security Policy (CSP): Strengthened our CSP to block unauthorized scripts.
Output Escaping: Leveraged Ember’s built-in escaping mechanisms to prevent scripts from running in templates.

Now, the codebase feels like a fortress—not impenetrable, but definitely harder to breach.

Not familiar with Content Security Policy (CSP)? Check out this guide on MDN to learn how it strengthens web security.

Wrap-Up

Codebases grow, evolve, and sometimes pick up bad habits along the way. The key is to keep learning and improving. If you’ve ever had similar “aha!” moments in your codebase, I’d love to hear your stories. After all, every bug fixed is a lesson learned!

Happy Coding 💻

Django + Redis: Simplifying Data Caching with a Real-World Example

Priya — Sun, 02 Feb 2025 08:01:27 +0000

In the previous post, we discussed the basics of Redis and its key use cases. I hope you're now familiar with what Redis is and how it can be helpful in various scenarios. As promised, today we'll explore a real-world example of how to implement Redis in a Django application for a ticketing system.

Use Case: High-Demand Ticketing System

Imagine you're building a ticketing system where users can book tickets for events like concerts or flights. Let's say we have a high demand of booking, how can we make sure that no two person's are booking the same ticket.

In most ticketing systems, when you try to book a ticket, you are given a specific window of time (e.g., 5 minutes) in which the ticket is reserved for you. During this time, the ticket is neither available for other users nor confirmed as booked yet. If another user visits the booking page, they should see that the ticket is already reserved, not available.

Now, let's think about how we can handle this in real time. Should we store the reservation in the database for 5 minutes to mark the ticket as "reserved"? While this might work, there are a couple of issues:

Database Overhead: Continuously writing and updating the database for every reservation request may not be optimal, especially if the system has a high volume of users.
Handling Expiry: After 5 minutes, we need to automatically reset the ticket status back to "Available" if it's not booked. Setting up a cron job to check and update ticket statuses might be one solution, but it's a bit of an overkill and introduces complexity.

How Redis Solves This Problem

Redis, with its ability to handle high-frequency reads and writes in real-time, can help solve both of these problems efficiently. Redis provides a feature called TTL (Time-To-Live), which automatically expires keys after a set duration.

Here's how Redis can work for our ticketing system:

When a user reserves a ticket, we store the reservation in Redis with a TTL of 5 minutes.
If the reservation is not confirmed within that time, Redis will automatically delete the key, making the ticket available again.

Here is the flow,

When user needs to book a ticket, we get all the available tickets (not booked) and took all the tickets (may be, ticketId) from Redis and show this accordingly.

This way, we don't need to constantly update the database. Redis acts as a high-performance, low-latency cache for ticket reservations.

But, what happens if two users try to reserve the same ticket at the same time? 🤔

The answer is that Redis guarantees atomic operations. This means that if two users attempt to reserve the same ticket simultaneously, Redis will ensure that only one succeeds, preventing both users from booking the same ticket.

Setting Up Redis in Django

Before diving into the implementation, ensure you've set up Redis in your Django project. You can follow this excellent tutorial on caching in Django with Redis by Mehedi Khan to configure Redis as your cache backend.

Once Redis is up and running in your project, we'll proceed with implementing the ticket reservation logic.

Implementing Ticket Reservation Logic

Assuming you've set up Redis, let's implement the core logic for reserving tickets.

First, let's define the Ticket model:

class Ticket(models.Model):
    STATUS_CHOICES = [
        ('available', 'Available'),
        ('booked', 'Booked'),
    ]

    price = models.DecimalField(max_digits=10, decimal_places=2)
    status = models.CharField(max_length=10, 
                              choices=STATUS_CHOICES, default='available')
    # Add more fields as necessary...

When a user tries to book a ticket, we need to reserve it for them in Redis:

from django.core.cache import cache
from django.http import HttpResponse
from .models import Ticket

def reserve_ticket_in_redis(ticket_id, timeout=60*5):
    reservation_key = f"ticket_reservation_{ticket_id}"
    # Check if the ticket is already reserved
    if cache.get(reservation_key):
        return False
    # If not reserved, set the reservation key with TTL
    cache.set(reservation_key, "reserved", timeout=timeout)
    return True

def book_ticket(request, ticket_id):
    ticket = Ticket.objects.get(id=ticket_id)

    # Check if the ticket is already booked in the database
    if ticket.status == "booked":
        return HttpResponse("Sorry, this ticket is already booked.")

    # Attempt to reserve the ticket in Redis
    if not reserve_ticket_in_redis(ticket_id):
        return HttpResponse("This ticket is already reserved by another user. Please try again later.")

    return HttpResponse(f"Ticket reserved successfully for 5 minutes. Please complete your booking.")

When users view a particular event, we need to show them a list of available tickets that are neither booked nor reserved. We can check both the ticket status and Redis cache for this:

from django.core.cache import cache
from django.shortcuts import get_object_or_404

def event_details(request, id):
    event = get_object_or_404(Event, pk=id)

    all_tickets = event.tickets.all()
    available_tickets = []

    for ticket in all_tickets:
        # Skip tickets that are booked or reserved in Redis
        if ticket.status == "booked" or cache.get(f"ticket_reservation_{ticket.id}"):
            continue  # Don't show this ticket to the user

        # Add ticket to available list if not booked or reserved
        available_tickets.append(ticket)

    return render(request, 'event_details.html', {'event': event, 'available_tickets': available_tickets})

Explanation

Redis Reservation: The reserve_ticket_in_redis function attempts to reserve the ticket in Redis using cache.set() and cache.get(), which ensures the key is only set if it doesn't already exist.
Atomic Operations: This ensures that if two users try to reserve the same ticket at the same time, only one will succeed.

Conclusion

In this post, we’ve explored how Redis can be used in a Django ticketing system to manage ticket reservations efficiently. By utilizing Redis’ TTL feature, we can reserve tickets for a set period (e.g., 5 minutes), and automatically make them available again if not confirmed. This reduces the load on the database and avoids race conditions by ensuring atomic operations for concurrent reservations.

Let me know if you have any questions or need further clarification!

Happy Designing! 😊💻

Redis Demystified: A Simple Introduction for System Design

Priya — Sun, 26 Jan 2025 09:55:06 +0000

You’ve probably encountered the word "Redis" many times while learning about system design. This tutorial will give you a better understanding (I hope) of what Redis is all about from a beginner's perspective, and in the future, we'll dive deeper into real-world examples of how to implement Redis in your applications.

What is Redis?

Redis is a single-threaded, in-memory data structure server or data store. It’s incredibly fast compared to traditional databases because it operates in memory (RAM) instead of disk storage.

So many terms? No worries! Let’s break it down and understand each one:

Single Threaded

Redis processes all requests on a single thread. While this might seem like a bottleneck, it’s actually a well-thought-out design choice that ensures simplicity and efficiency. Redis achieves this efficiency using a mechanism called I/O Multiplexing.

Understanding I/O Multiplexing with an Analogy

Imagine a waiter in a busy restaurant where customers are lining up to place their orders. If the waiter attends to one customer at a time—waiting for them to browse the menu and decide what to order—other customers would have to wait longer.

Now, let’s make an improvement: The waiter places menus at each table so customers can decide on their orders in advance. Instead of waiting for each customer to be ready, the waiter immediately takes orders from those who are prepared, significantly reducing waiting time.

This is similar to how I/O Multiplexing works in Redis.

The Redis server listens to all incoming requests.
Some clients may be idle (e.g., not sending commands).
Redis processes the requests that are ready to be handled, ensuring smooth and fast operations.

By doing this, Redis optimizes performance and keeps things simple without needing multiple threads or complex locking mechanisms.

In-Memory

Redis is an in-memory data store, meaning it keeps all its data in RAM for fast access. This in-memory design allows Redis to be incredibly fast for read and write operations, as accessing data from RAM is much quicker than from disk storage.

However, because RAM is volatile, meaning the data is lost if the server crashes, Redis provides mechanisms to ensure that data persists even in case of unexpected failures. Redis periodically saves its data to disk using two mechanisms:

Snapshotting: Redis saves the dataset to disk at specified intervals, creating a point-in-time snapshot of the data. By default, Redis writes this snapshot to disk:
- Every 900 seconds (15 minutes) if at least one key has changed.
- Every 300 seconds (5 minutes) if at least 100 keys have changed. (This data was gathered from sources like Google, but it's always good to double-check against Redis documentation for accuracy.)
Append-Only File (AOF): Redis can also log every write operation to an append-only file, allowing the data to be reconstructed in case of a crash.

These settings are configurable, meaning you can adjust how often Redis saves data to disk based on your application’s needs.

Data structure

We often learn more about Data Structures and Algorithms (DSA) than other topics in computer science, but why focus on Data Structures here? Redis allows you to store data as key-value pairs, where the value can be a variety of data structures, from simple strings and integers to more complex ones like Lists, Sets, Sorted Sets, and even Hashes.

This flexibility in data structures is one of the reasons Redis is so powerful. It allows you to efficiently handle and manipulate different types of data based on your needs.

Commands to Start Off With

SET: Set a value for a key.

SET mykey "Hello, World!"

GET: Retrieve the value of a key.

GET mykey

DEL: Delete a key.

DEL mykey

EXPIRE: Set an expiration time on a key.

EXPIRE mykey 60  # Key expires in 60 seconds

HSET: Set a field in a hash (similar to object).

HSET user:1000 name "Priya"
HSET user:1000 email "priya@example.com"

And much more!

For a quick reference on Redis commands, check out the official Redis Quick Start Cheat Sheet.

Practical Example

Imagine you have a web application where users frequently query a product database. Repeated queries for the same product can be slow and waste resources. Here’s how Redis can help:

Set Product Data in Redis:

SET product:1234 "{ 'name': 'Laptop', 'price': 1000 }"

Check Redis Before Querying Database: Before hitting the database for a product, check Redis to see if the data exists.

GET product:1234

Use Expiration: To avoid outdated data, set an expiration time on the cached data.

EXPIRE product:1234 600

Wrap-Up

Redis is a powerful tool that enables fast, flexible data management using in-memory storage. By understanding its core concepts, you can use Redis to improve your application’s performance and scalability.

Feel free to share your experiences with Redis or any tips you have!

Happy Designing! 😊💻

Understanding the CAP Theorem: Simplified

Priya — Sun, 19 Jan 2025 06:19:28 +0000

When discussing system design, the CAP theorem is one of the most fundamental and frequently mentioned concepts. But what does it actually mean? Let’s break it down with a simple example.

Scenario: A Blog Website

Imagine you’re running a blog website that serves a large user base. To efficiently handle the traffic, you deploy multiple servers, with each server processing user requests. Additionally, you implement database redundancy by creating multiple copies of your database that work with these servers.

This setup provides two key advantages:

Fault Tolerance: If the primary (master) database fails, secondary databases can take over, ensuring continuous service.
Improved Availability: Redundant databases ensure users can access content even during server or database failures.

Primary-Secondary Database Architecture: A Quick Overview

The primary-secondary architecture (also called master-slave architecture) is widely used in distributed systems. Here's how it works:

The primary database handles all write operations and replicates updates to secondary databases.
The secondary databases handle read operations, improving system efficiency and fault tolerance.

This design supports high availability and resilience but comes with trade-offs, which the CAP theorem helps us understand.

The CAP Theorem

The CAP theorem highlights the trade-offs that distributed systems face by focusing on three essential properties:

Consistency (C):
- Ensures that all nodes in the system see the same data at the same time.
- Example: If a user updates a blog post, all servers must immediately reflect the updated content, ensuring no stale data is read.
Availability (A):
- Guarantees that every request receives a response (read or write), even if the data is not the most recent.
- Example: Users can still view and interact with the website, even if some database nodes are experiencing issues.
Partition Tolerance (P):
- Ensures the system continues to function despite network partitions or communication breakdowns between servers.
- Example: If servers cannot communicate due to network failure, the system still serves requests to the best of its ability.

The Trade-offs: Which Two Should You Prioritize?

The CAP theorem states that you can’t achieve all three properties at once. So, how do you prioritize?

Consistency and Availability (CA):

This trade-off assumes no network partitions, which is rare in real-world distributed systems. If network partitions don’t occur, the system can maintain consistency and respond to all requests.

Consistency and Partition Tolerance (CP):

When network partitions occur, prioritizing consistency means every read receives the most recent write. This may come at the cost of availability, as the system might reject requests if it cannot guarantee consistency.

Availability and Partition Tolerance (AP):

In scenarios where uptime is critical, the system continues to serve requests even during network partitions. However, data may not always be consistent across nodes, leading to eventual consistency.

Your Use Case: Which Trade-off to Choose?

Think about the system you’re building. Here’s how to approach the trade-offs:

Choose Consistency and Partition Tolerance (CP) if data accuracy is critical (e.g., in financial applications).
Choose Availability and Partition Tolerance (AP) if uptime and accessibility are your priorities (e.g., in social media platforms).
In specific scenarios without network partitions, Consistency and Availability (CA) might be possible, but this is rare.

What about PACELC?

The PACELC theorem extends CAP and adds another dimension:

During a Partition (P), prioritize either Availability (A) or Consistency (C) (as in CAP).
Else (E), when there’s no partition, choose between Latency (L) and Consistency (C).

Latency vs Consistency: What’s the Right Balance?

Latency (L): Systems prioritize quick responses, even if the data might not be up-to-date.
Consistency (C): Systems ensure that users always see the most accurate data, even if responses are slightly slower.

Wrap-Up

Understanding the CAP theorem and the PACELC extension helps in designing systems that align with specific use cases. By balancing the trade-offs, you can design systems optimized for reliability, performance, and user experience.

Have questions or suggestions? Drop them in the comments!

Happy Designing! 💻😊

Kickstarting Weekly System Design Deep Dives: Building Scalable Systems

Priya — Sun, 12 Jan 2025 11:25:37 +0000

To truly master something, you must create an obligation to teach it.

Inspired by this idea, I’m launching this weekly series to master system design and share my journey and insights with you.

How do platforms like Netflix and Amazon handle millions of users daily without breaking a sweat? The answer lies in system design—a crucial skill for building scalable and reliable systems.

At its core, system design is about solving real-world challenges such as:

Scaling systems to accommodate millions of users.
Ensuring high availability, even during failures.
Managing vast amounts of data efficiently.

Take a URL shortener, for example. The system needs to ensure unique links, redirect users quickly, and scale seamlessly as traffic grows.

Netflix, for instance, uses microservices to scale its platform, allowing it to handle millions of users and maintain high availability.

If you’re just starting with system design, I highly recommend reading Designing Data-Intensive Applications by Martin Kleppmann for deeper insights.

Interested? Follow along for weekly posts on system design, and let’s learn together. Got questions or topics you’d like to explore? Drop them in the comments!🚀

Optimizing Query Performance in Django with PostgreSQL: A Case Study

Priya — Sun, 29 Dec 2024 09:51:43 +0000

Recently, I started working on a feature that required me to optimize the database queries being fired from the code I wrote. This optimization is critical for ensuring the home page loads quickly, providing a seamless user experience without delays.

Let me give a short intro about the application I’m working with. It’s a Django app with a PostgreSQL database. The feature I’m working on involves logic that needs data from multiple models, as the application is well modularized.

More modularized? A problem!

We all tend to follow certain coding principles we’ve learned, one of which is writing modularized, reusable pieces of code. This approach is great for maintainability and scalability, but when it comes to database queries, it can sometimes lead to inefficiency.

Checking Query Execution Time in Django

First, I thought of checking the performance of the queries that are being fired from my code. I got the raw SQL and then tried executing that in pgAdmin and analyzed the results using EXPLAIN ANALYZE. For example, If you want to analyze a query, prefix it with EXPLAIN ANALYZE.

Here’s a snippet of how it looked when I used the IN clause:

"Unique  (cost=8.19..8.20 rows=1 width=16) (actual 
time=0.045..0.047 rows=1 loops=1)"
"  ->  Sort  (cost=8.19..8.20 rows=1 width=16) (actual 
time=0.045..0.045 rows=1 loops=1)"
"Planning Time: 0.229 ms"
"Execution Time: 0.076 ms"

Next, I switched to using JOIN, and here's the result:

"HashAggregate  (cost=30.07..32.69 rows=262 width=16) (actual 
time=0.148..0.150 rows=1 loops=1)"
"  Batches: 1  Memory Usage: 37kB"
"  ->  Nested Loop  (cost=4.21..28.76 rows=262 width=16) (actual
 time=0.119..0.140 rows=1 loops=1)"
"Planning Time: 0.455 ms"
"Execution Time: 0.222 ms"

Noted Anything???

Yes, the "Execution Time"!

It shows that using IN is faster than using JOIN for this specific case. However, there’s a key question we need to consider: Will this scale for larger datasets? What happens if the data inside the IN clause is significantly larger? Will it still perform well? The answer to this is A Big No.

Performance Comparison

To better understand the trade-offs between IN and JOIN, let’s analyze how the database handles these two approaches, especially as the dataset grows.

Using IN:

When using IN, the database is essentially checking if each row in the main table exists in a list of values. While this can be fast for smaller datasets, as the list in the IN clause grows, PostgreSQL has to scan a larger set of values. This leads to increased execution time and potentially a full table scan, especially if the subquery or list of values is large.

Using JOIN:

On the other hand, JOIN creates a relationship between tables based on matching values in the columns, allowing the database to optimize the process using indexes. Although the execution time may seem worse for small data sets (as we saw in our initial test), JOIN performs much better when dealing with larger datasets.

What you can use?

It depends! Yes, it depends on your use case and the problem you're trying to solve. It’s not always the case that you should use JOIN—for smaller sets of data, IN might be more efficient.

So, have a good understanding of the use case and get insights from people who have a better understanding than you about it. If you feel like the data is going to be large and it will affect performance, you can definitely go for JOIN. And yes, don't forget to create Indexes on your database to make your JOINS perform better.

Know Indexing better

Indexes are critical when working with joins on large datasets. They allow PostgreSQL to quickly locate rows based on indexed columns, significantly speeding up the query performance. To optimize your JOIN queries, ensure that the columns used in the ON clause, as well as other frequently queried columns like those in WHERE and ORDER BY clauses.

Want to learn more about indexing strategies for PostgreSQL? Check out this resource on choosing table indexes.

My Decision

After evaluating both the IN and JOIN approaches, I decided to use JOIN in cases where the data is expected to grow, as it provides better performance with larger datasets. However, for situations where I know the data will remain small, I opted for IN as it offers faster query execution for smaller datasets.

Additionally, I’ve implemented indexing on key columns (like id's) to ensure that JOIN queries continue to perform well as the application scales.

In conclusion, always evaluate your use case, choose the most appropriate method based on data size, and monitor your queries over time to ensure continued performance optimization as your data scales.

Happy coding! 💻

Docker 101: Basics and Practical Implementation with Spring REST API

Priya — Tue, 22 Oct 2024 10:01:49 +0000

Ever spent hours debugging an application only to find it works perfectly on your machine but breaks in production? This is a common frustration for developers.

Imagine a developer builds a web application that runs on Python 3.8 and needs specific libraries. In development, the app works perfectly. However, when deployed to a server running Python 3.9, it breaks due to compatibility issues.

So, what's the solution? Enter Docker.

By using Docker, the developer can package the app with Python 3.8 and all necessary libraries in a container. This container can then be deployed anywhere without worrying about compatibility, ensuring it runs smoothly in any environment.

In other words, it solves the "works on my machine" problem by ensuring that the application runs the same regardless of the environment.

What is Docker?

Docker is a platform that allows developers to package applications and their dependencies into lightweight, portable containers. These containers ensure that an application runs the same way, regardless of the environment—whether it's on a developer's laptop, a testing server, or a production server.

Understanding the Basics

Image credit: Senali

Docker Hub

Docker Hub is a cloud-based repository where you can store and share Docker images, allowing easy access for developers and teams.

Docker Image

A Docker image is a lightweight, read-only, and executable software package that includes everything needed to run an application: code, runtime, libraries, environment variables, and configuration files.
Think of an image as a blueprint for creating Docker containers.
You can have multiple containers running from the same image.

Docker Container

A Docker container is a running instance of a Docker image. It uses the image's content to execute an application.
Containers can be stopped, started, or removed without affecting the Docker image.

In simpler terms:

Image = Blueprint
Container = Running Application

Dockerfile

A Dockerfile is a script that contains a series of instructions for building a Docker image. It specifies how the application should be packaged and run inside a container.

FROM openjdk:17-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

In this example:

FROM specifies the base image to use (a base image contains the necessary software, libraries, and files required to run your application or service). Here, openjdk is used because we are going to run a Java application.
ARG defines a variable to reference the JAR file. Here, the value assigned is the Spring Boot JAR that is built by Maven, located in the target directory.
COPY copies the JAR file into the container.
ENTRYPOINT defines the command to run the application.

Docker Compose

Docker Compose orchestrates multiple containers (for example, a Spring Boot app and MySQL). It defines how each container will be set up, how they communicate, and their environment configurations. The configuration for Docker Compose is specified in a YAML file, typically named docker-compose.yml.

version: '3'
services:
  mysql-db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: spring_docker_demo
    ports:
      - "3306:3306"
    networks:
      - spring-network

  spring-app:
    image: spring-docker-demo:latest
    container_name: spring-app
    build:
      context: .
      dockerfile: Dockerfile
    depends_on:
      - mysql-db
    ports:
      - "8080:8080"
    networks:
      - spring-network
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql-db:3306/spring_docker_demo
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_PASSWORD: root

networks:
  spring-network:
    driver: bridge

In this example:

version specifies the Docker Compose version that we are using.
services defines individual containers. In this case, mysql-db is the first service and the second one is spring-app.
The networks section defines a network named spring-network. Both the Spring Boot app and MySQL will be on this network, allowing them to communicate with each other.

Image credit: Dhruv Saksena

Brief Overview of Services

1. MySQL (`mysql-db`)

image: Specifies the Docker image to use for this service. In this case, it's the official mysql:8.0 image.
container_name: This gives a name to the MySQL container, making it easier to reference.
environment: Passes environment variables into the container. Here, we’re setting:
- MYSQL_ROOT_PASSWORD: The root password for MySQL.
- MYSQL_DATABASE: The name of the initial database to create.
ports: Maps the MySQL container's internal port (3306) to the host machine’s port (3306), allowing access to the database from the host.
networks: Defines the network (spring-network) that the MySQL container will join.

2. Spring App (`spring-app`)

image: Specifies the Docker image to use for the Spring Boot app. In this case, it’s spring-docker-demo:latest, which will be built from the Dockerfile in this project.
build:
- context: The directory where the Dockerfile and source code are located (. means the current directory).
- dockerfile: The name of the Dockerfile to use (in this case, Dockerfile).
depends_on: Specifies that the spring-app service depends on the mysql-db service, ensuring that MySQL starts before the Spring Boot app.
ports: Maps the Spring Boot container’s internal port (8080) to the host machine’s port (8080), allowing access to the REST API.
networks: Defines the network that the Spring Boot container will join, allowing it to communicate with the MySQL container.
environment: Sets environment variables for the Spring Boot app. These variables override values in application.properties and allow the Spring Boot app to connect to the MySQL container.

Example: Dockerizing a Spring REST API

To understand it better, let me walk you through an example of dockerizing a Spring REST API.

1. Project Structure:

Before diving into the Docker configurations, ensure your project structure looks something like this:

   spring-docker-demo/
   ├── Dockerfile
   ├── docker-compose.yml
   ├── src/
   │   └── main/
   │       └── java/
   │           └── com/
   │               └── example/
   │                   └── demo/
   │                       └── DemoApplication.java
   │                       └── UserController.java
   └── pom.xml

2. Build the Spring Boot Application:

Make sure your Spring Boot application is set up correctly and build it using Maven:

mvn clean package

This command should create a JAR file in the target directory, which the Dockerfile will reference.

3. Using the Dockerfile:

The Dockerfile provided will be used to create an image for your Spring REST API, as discussed earlier.

FROM openjdk:17-jdk-alpine
ARG JAR_FILE=target/*.jar
COPY ${JAR_FILE} app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

4. Using Docker Compose:

The docker-compose.yml file will help you orchestrate the application and its database (MySQL). Here’s the configuration:

version: '3'
services:
  mysql-db:
    image: mysql:8.0
    container_name: mysql-db
    environment:
      MYSQL_ROOT_PASSWORD: root
      MYSQL_DATABASE: spring_docker_demo
    ports:
      - "3306:3306"
    networks:
      - spring-network

  spring-app:
    image: spring-docker-demo:latest
    container_name: spring-app
    build:
      context: .
      dockerfile: Dockerfile
    depends_on:
      - mysql-db
    ports:
      - "8080:8080"
    networks:
      - spring-network
    environment:
      SPRING_DATASOURCE_URL: jdbc:mysql://mysql-db:3306/spring_docker_demo
      SPRING_DATASOURCE_USERNAME: root
      SPRING_DATASOURCE_PASSWORD: root

networks:
  spring-network:
    driver: bridge

5. Running the Application:

Navigate to your project folder where the docker-compose.yml file is located and run the following command:

docker-compose up --build

This command builds the Docker images and starts the containers for your application and the database.

6. Accessing the Application:

Once everything is up and running, you can access your Spring REST API at http://localhost:8080.

Sharing Your Docker Image

Once you've containerized your Spring REST API, sharing the Docker image with others is straightforward.

1. Build the Docker Image

Build your image with the following command:

docker build -t your-username/spring-docker-demo:latest .

Replace your-username with your Docker Hub username and . indicates that the Dockerfile is located in the current directory.

2. Push to Docker Hub

docker login
docker push your-username/spring-docker-demo:latest

Again, replace your-username with your actual Docker Hub username.

3. Pulling the Image

Others can easily pull and run your image by executing:

docker pull your-username/spring-docker-demo:latest
docker run -d -p 8080:8080 your-username/spring-docker-demo:latest

pull command downloads your Docker image from Docker Hub to their local machine.
run command runs a container from the downloaded image.
- -d: Runs the container in detached mode (in the background).
- -p 8080:8080: Maps port 8080 of the host machine to port 8080 of the container, allowing access to the application.

Wrap Up

Docker is a game-changer for developers, making deployment seamless and ensuring your app runs consistently across environments. Say goodbye to "it works on my machine" frustrations!

Ready to dive into Docker? Share your experiences or questions below!

Happy Coding! 🐳

From Contributor to Collaborator: My Hacktoberfest Journey

Priya — Wed, 16 Oct 2024 07:06:20 +0000

The best way to learn is to do; the best way to contribute is to share.

This year, I joined Hacktoberfest 2024 for the first time! Although I’ve contributed to open-source projects before, this was my first time joining Hacktoberfest, and my goal was not only to complete four PRs (Pull Requests) but to learn more in the process. I was excited to learn from the open-source community and make my own impact.

I started by looking for projects that matched my skills, especially something related to Spring Boot. After some searching, I found an interesting project and spent a day setting up my environment and exploring the code.

My First Contribution: Pagination and Sorting 🎯

Many issues were already taken by others, but I didn’t give up. Instead, I suggested my own feature: Pagination and Sorting for API endpoints. The project maintainers liked my idea and assigned the task to me! I worked hard on this and submitted my first PR, which was merged on the same day.

I can’t describe how happy I was when I got the email saying my PR was merged! The maintainers also gave positive feedback, which made me even more excited. We also worked together to improve the project documentation to include my changes.

Learning About Error Handling 🛠️

While I was working on the documentation, I saw some errors in the code. I thought I could improve the project by adding better error handling. So, I submitted another PR to fix that—and it was merged too! This taught me a lot about writing clean code and handling errors properly.

I also submitted a PR to another repository, where I added an algorithm, which helped me expand my contributions.

Overcoming Challenges: Fixing My Algorithm 🔧

Not everything was easy. One of my PRs related to an algorithm faced a check failure due to clang-format issues. After analyzing the situation, I quickly installed clang-format and formatted the code to adhere to the project’s style guidelines. After ensuring that my changes met the required formatting, I committed the updates and submitted the PR again. This experience taught me the importance of attention to detail and the necessity of understanding the tools in my development environment. While I was doing that, I also started exploring security issues in another project, which gave me a new challenge to work on.

Facing My Fears 🚀

Next, I decided to add HTTPS/SSL support to a custom server. At first, I was scared to work on this project because it seemed complicated. However, I broke it down and took the time to understand the code step by step. In the end, I successfully added HTTPS support and included security headers in the response. This was challenging, especially since I was using self-signed certificates. After overcoming these obstacles, I updated the docstring to explain my changes and submitted a PR for review.

More Achievements and a Surprise 🏆

Remember? "Hard work always pays off in the end."

In the end, both my algorithm and SSL/HTTPS PRs were merged. But the best surprise came when I was offered to become a maintainer for one of the repositories! I was so excited and accepted the offer right away. This gave me even more motivation to push myself, and I ended up submitting a total of nine PRs during Hacktoberfest!

Helping Others: Reviewing PRs 🤝

After submitting my PRs, I started reviewing issues and PRs from other contributors. It felt wonderful to help others, and when one of them said, “Thank you for teaching me something new about security; this will elevate my skill,” I was truly happy. This experience motivated me to continue contributing and supporting others in the community. It’s amazing to see how we can all learn from each other in the open-source world.

Lessons Learned 🌱

Reflecting on this journey, here are some key takeaways:

Effective Communication: Contributing features like pagination taught me the importance of clear communication with maintainers to ensure alignment on project goals.
Code Quality Matters: Enhancing error handling reinforced that clean, well-documented code reduces errors and benefits other contributors.
Attention to Detail: The clang-format issue reminded me to adhere to project style guidelines and utilize tools that help maintain consistency.
Community Strength: Reviewing PRs and helping others demonstrated the value of collaboration in the open-source community, inspiring me to continue growing alongside my peers.

My Hacktoberfest Journey ✨

Hacktoberfest 2024 was an amazing experience for me! I learned so much, not just about coding, but also about being part of the open-source community. I recommend Hacktoberfest to everyone—it’s a great way to improve your skills and connect with others who are passionate about coding.

Thank you for reading my Hacktoberfest story! I hope it inspires you to join the event and experience the joy of contributing to open source.

Spring Boot Meets Firebase: My Journey of Building a File Upload System

Priya — Thu, 03 Oct 2024 16:02:53 +0000

Recently, I created a REST API for uploading and retrieving files using Spring Boot and Firebase. This project was driven by my interest after seeing someone mention they were having issues with file uploads in Spring Boot. In an effort to help, I decided to familiarize myself with file uploads using Spring Boot and Firebase.

So, if you’re like me and want to get familiar with file management using Firebase and Spring Boot, let’s get started! 😊

First Up: Setting Up Firebase 🛠️

Before we dive into the code, the first step is setting up Firebase to handle file uploads.

Step 1: Create a Firebase Project

Go to the Firebase Console: Firebase Console
Create a New Project:
- Enter a project name.
- Click "Continue" and select whether to enable Google Analytics (optional).
- Click "Create Project."

Step 2: Enable Cloud Storage

Open Your Project: In the Firebase console, select your project.
Navigate to Cloud Storage:
- Click on “Build > Storage” in the left sidebar.
- Click on “Get Started” and "Start in test mode (or production if needed)" to enable Cloud Storage for your project.

Step 3: Get Your Service Account Key 🔑

Go to "Project Settings" > "Service accounts."
Click on “Generate new private key,” and a JSON file will be downloaded. Keep this file secure.

That’s it for Firebase setup! Now, let’s move on to integrating it with Spring Boot.

Next: Setting Up Spring Boot ⚙️

1. Create a Spring Boot Project

You can create a Spring Boot project using Spring Initializr.

Select the following dependencies:

Spring Web: For building REST APIs.
Spring Boot DevTools (optional, for easier development).

2. Add Firebase Dependencies

Add the Firebase dependency to your pom.xml:

<dependency>
    <groupId>com.google.firebase</groupId>
    <artifactId>firebase-admin</artifactId>
    <version>8.1.0</version>
</dependency>

3. Firebase Configuration

You need to set up Firebase authentication using the .json key file you downloaded earlier.

Place the .json file in your src/main/resources directory.
Then, create a configuration class FirebaseConfig to initialize Firebase:

@Configuration
public class FirebaseConfig {

    @Bean
    FirebaseApp firebaseApp() throws IOException {
        ClassPathResource resource = new ClassPathResource("serviceAccountKey.json"); 
        InputStream serviceAccount = resource.getInputStream();

        FirebaseOptions options = FirebaseOptions.builder()
            .setProjectId("fir-fileuploadapi") 
            .setCredentials(GoogleCredentials.fromStream(serviceAccount))
            .setStorageBucket("fir-fileuploadapi.appspot.com") 
            .setDatabaseUrl("https://fir-fileuploadapi-default-rtdb.firebaseio.com")
            .build();

        return FirebaseApp.initializeApp(options);
    }
}

Here, replace the projectId, bucketName, and databaseUrl with your own details from Firebase.

Where to get those?

Project ID: Firebase console > Your project (that you created earlier) > Project settings.

Bucket Name: Firebase console > Your project > Build > Storage

Database URL: Firebase console > Your project > Build > Realtime Database > Create Database

Then, your database URL will be shown at the top.

4. Create a Service

Create a FileStorageService class with a constructor.

@Service
public class FileStorageService {

    private final Storage storage;
    private final FileMetaDataRepository repo;
    private final String bucketName = "fir-fileuploadapi.appspot.com";

    public FileStorageService(FileMetaDataRepository repo) throws IOException {
        this.repo = repo;

        ClassPathResource resource = new ClassPathResource("serviceAccountKey.json");
        InputStream serviceAccount = resource.getInputStream();

        GoogleCredentials credentials = GoogleCredentials.fromStream(serviceAccount)
                .createScoped(Lists.newArrayList("https://www.googleapis.com/auth/cloud-platform"));

        this.storage = StorageOptions.newBuilder().setCredentials(credentials).build().getService();
    }
}

Here, just replace serviceAccountKey.json with the name of the JSON file stored in the src/main/resources folder and the Bucket Name you got earlier.

Wait! What is FileMetaDataRepository? We haven't created that yet.

Here you go!

@Repository
public interface FileMetaDataRepository extends JpaRepository<FileMetaData, Integer> {
    FileMetaData findByUniqueId(String uniqueId);
}

And the corresponding FileMetaData.java:

@Entity
@Table(name = "files")
public class FileMetaData {

    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Integer id;

    @Column(name = "unique_id", nullable = false)
    private String uniqueId;

    @Column(name = "object_name", nullable = false)
    private String objectName;

    @Column(name = "upload_date", nullable = false)
    private LocalDateTime uploadDate;

    public FileMetaData() {}

    public FileMetaData(Integer id, String uniqueId, String objectName, LocalDateTime uploadDate) {
        this.id = id;
        this.uniqueId = uniqueId;
        this.objectName = objectName;
        this.uploadDate = uploadDate;
    }
    // getters and setters go here...
}

What’s the need for this?

FileMetaData is an object that holds metadata (data about the data) about the file we are storing. It's just for making our retrieval smoother!

5. Create the Uploading and Retrieving Methods

Uploading Files

In the FileStorageService, we’ll create a method for uploading files:

public String uploadFile(MultipartFile file) throws IOException {
    if (file.isEmpty()) {
        throw new IllegalArgumentException("File is empty. Please upload a valid file.");
    }

    String uniqueID = UUID.randomUUID().toString();
    String objectName = uniqueID + "_" + file.getOriginalFilename();

    BlobId blobId = BlobId.of(bucketName, objectName);

    BlobInfo blobInfo = BlobInfo.newBuilder(blobId).build();

    storage.create(blobInfo, file.getBytes());

    FileMetaData metaData = new FileMetaData();
    metaData.setUniqueId(uniqueID);
    metaData.setObjectName(objectName);
    metaData.setUploadDate(LocalDateTime.now());

    repo.save(metaData);

    return uniqueID;
}

Explanation:

We first check if the uploaded file is empty. If it is, we throw an exception.
We generate a unique ID for the file using UUID to ensure no two files have the same identifier.
We create a BlobId and BlobInfo for the file, then store the file in Firebase using the storage.create() method.
Finally, we save the file metadata in our repository for easy retrieval later.

Retrieving Files

Now, let’s create a method to retrieve files by their unique ID:

public FileResponse retrieveFile(String fileId) {
    FileMetaData fileMetadata = repo.findByUniqueId(fileId);

    if (fileMetadata == null) {
        throw new IllegalArgumentException("No file found with the given ID: " + fileId);
    }

    String objectName = fileMetadata.getObjectName();
    BlobId blobId = BlobId.of(bucketName, objectName);
    Blob blob = storage.get(blobId);

    if (blob == null || !blob.exists()) {
        throw new IllegalArgumentException("No file found with the given ID: " + fileId);
    }

    FileResponse fileResponse = new FileResponse(objectName, blob.getContent());
    return fileResponse; 
}

Explanation:

We look up the file metadata by its unique ID. If it doesn't exist, we throw an exception.
We retrieve the Blob from Firebase using the object name stored in our metadata.
If the blob exists, we create a FileResponse object that contains the file name and its content, ready to be returned.

Here is how the FileResponse class looks like,

public class FileResponse {
    private String fileName;
    private byte[] fileContent;

    public FileResponse(String fileName, byte[] fileContent) {
        this.fileName = fileName;
        this.fileContent = fileContent;
    }

    public String getFileName() {
        return fileName;
    }

    public byte[] getFileContent() {
        return fileContent;
    }
}

6. Create a Controller

Next, we’ll set up a controller to handle our HTTP requests:

@RestController
@RequestMapping("/api/files")
public class FileStorageController {

    @Autowired
    private FileStorageService fileStorageService;

    @PostMapping("/upload")
    public ResponseEntity<String> uploadFile(@RequestParam MultipartFile file) {
        try {
            String fileId = fileStorageService.uploadFile(file

);
            return ResponseEntity.ok(fileId);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(e.getMessage());
        }
    }

    @GetMapping("/retrieve/{fileId}")
    public ResponseEntity<FileResponse> retrieveFile(@PathVariable String fileId) {
        try {
            FileResponse fileResponse = fileStorageService.retrieveFile(fileId);
            return ResponseEntity.ok(fileResponse);
        } catch (Exception e) {
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
        }
    }
}

Explanation:

The uploadFile method handles file uploads by calling our service method and returning the unique ID.
The retrieveFile method fetches the file using the unique ID and returns its content.

Testing the API 🧪

Now that everything is set up, you can test your API using Postman or any other tool.

To Upload a File:
- Make a POST request to http://localhost:8080/api/files/upload with the file in the form-data.
To Retrieve a File:
- Make a GET request to http://localhost:8080/api/files/retrieve/{fileId} using the unique ID you received from the upload response.

Conclusion

And there you have it! You’ve successfully created a Spring Boot REST API to upload and retrieve files using Firebase. I hope this guide was helpful and easy to follow! If you have any questions or need further assistance, feel free to drop a comment below!

Happy coding! 💻

Boost Your Java Code Quality with PMD

Priya — Fri, 20 Sep 2024 16:12:41 +0000

Do you ever find yourself struggling with code smells in your Java projects? You’re not alone! Code smells are simply indicators that your code could use some improvement. In this post, we'll explore how PMD (Programming Mistake Detector) can help you find and fix these pesky code smells effectively.

What Are Code Smells?

Code smells aren’t bugs, but they do suggest that your code could use some improvement to make it clearer, easier to maintain, or more efficient. Here are a few common examples:

Long Methods: These are methods that are too long and try to do too many things at once.
Duplicated Code: This is when you see the same code in several places.
Deep Nesting: This happens when your code has too many nested blocks, making it tough to read.

What is PMD?

PMD (Programming Mistake Detector) is a handy tool that analyzes your source code to spot common programming issues. It helps identify things like unused variables, empty catch blocks, and overly complex methods, making it easier for you to improve your code quality.

Rulesets in PMD

PMD uses predefined rulesets to check your code. These rulesets have different rules that look for various kinds of issues. Here’s a quick look at some common rulesets:

Basic: Looks for simple issues like empty catch blocks and unnecessary object creation.
Design: Checks if your code follows good design principles and finds overly complex methods and classes.
Unused Code: Finds code elements that are defined but never used.

How to Integrate PMD into Your Build Process

Integrating PMD into your build process helps you automatically check for code quality. Here’s how to set it up with Maven:

1. Add PMD Plugin to `pom.xml`

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-pmd-plugin</artifactId>
      <version>3.21.0</version>
      <configuration>
        <rulesets>
          <ruleset>java-basic</ruleset>
          <ruleset>java-design</ruleset>
          <ruleset>java-unusedcode</ruleset>
        </rulesets>
      </configuration>
      <executions>
        <execution>
          <phase>verify</phase>
          <goals>
            <goal>pmd</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Explanation:

<rulesets>: This tells PMD which rulesets to use (like basic, design, and unused code).
<phase>verify</phase>: This sets PMD to run during the Maven verify phase, which happens after tests and before packaging your code.

2. Run PMD

You can run PMD during your Maven build or on its own.

During Build: PMD will run automatically during the verify phase when you run:

  mvn clean verify

Manually: If you want to run PMD separately, just use:

  mvn pmd:pmd

This will kick off the PMD analysis.

3. View Reports

After PMD runs, it generates a report showing any issues it found.

Locate the Report: You can find the PMD report at:

  target/site/pmd.html

Report Contents:
- Summary: A quick overview of how many violations were found.
- Details: A list of issues, including file names, line numbers, and descriptions.
- Rulesets: Information about which rulesets were used and their results.

Example Walkthrough

Here’s a simple example to show PMD in action! You can check out the code in my Replit.

Consider the following code:

public class UnusedCode {
    // This field is never used
    private int unusedField;

    public void usedMethod() {
        System.out.println("This method is used.");
    }
}

public class Main {
    public static void main(String[] args) {
        UnusedCode unusedCode = new UnusedCode();
    }
}

After running mvn pmd:pmd, you’ll find the report pmd.html in the target/site/ folder.

If you open it in your browser, it will look something like this:

Understanding the PMD Report

Overview: Displays the PMD version (6.55.0) and last published date.
Violations by Priority:
- Main.java:
  - Rule: UseUtilityClass
  - Violation: "All methods are static. Consider using a utility class."
  - Line: 1–5
- UnusedCode.java:
  - Rule: UnusedPrivateField
  - Violation: "Avoid unused private fields."
  - Line: 3
Files Section: Details about violations for each analyzed file, highlighting areas for improvement.

Stopping Build Process if There Are Violations

When PMD finds errors during a Maven build, the build doesn’t stop by default. It will report the violations and keep going.

You can change this behavior so the build fails if certain limits of violations are hit. Here’s how:

<build>
  <plugins>
    <plugin>
      <groupId>org.apache.maven.plugins</groupId>
      <artifactId>maven-pmd-plugin</artifactId>
      <version>3.21.0</version>
      <configuration>
        <rulesets>
          <ruleset>java-basic</ruleset>
          <ruleset>java-design</ruleset>
          <ruleset>java-unusedcode</ruleset>
        </rulesets>
      </configuration>
      <executions>
        <execution>
          <phase>verify</phase>
          <goals>
            <goal>pmd</goal>
            <!-- Checks for violations and fails the build if found -->
            <goal>check</goal>
          </goals>
        </execution>
      </executions>
    </plugin>
  </plugins>
</build>

Explanation:

<goal>check</goal>: This tells PMD to check for violations in the report. If any are found, it will fail the build.

Now, if you run mvn clean verify, your build will stop if there are violations.

Before adding the check goal,

After adding it,

Conclusion

By integrating PMD into your Java projects, you can automatically spot and fix code smells, making your code more maintainable and efficient.

Feel free to share your experiences with PMD or ask any questions in the comments below.

Happy coding! 😊

DEV Community: Priya

Breaking Down the Cloud: A Simple Guide for Beginners

What the Cloud Actually Means

🔹 On-demand delivery

🔹 IT resources

🔹 Over the internet

🔹 Pay-as-you-go pricing

What are virtual machines?

Types of Cloud Services

🔹 IaaS (Infrastructure as a Service)

🔹 PaaS (Platform as a Service)

🔹 SaaS (Software as a Service)

Why you can try it

Wrap Up

Fixing ChatGPT’s Hidden Edit Button – A Reminder That Testing Matters!

The Issue?

The Fix?

Why This Matters – The Importance of Testing

Wait... Should We Be Doing It This Way?

1. API Naming 🔍

What’s the Problem?

The Fix:

2. DOM Manipulation in Ember.js 🔧

Why This Matters:

The Fix:

3. Passwords Over HTTPS 🔐

Why It’s Risky:

The Fix:

4. XSS Attacks🛡️

The Risks:

How We Fought Back:

Wrap-Up

Django + Redis: Simplifying Data Caching with a Real-World Example

Use Case: High-Demand Ticketing System

How Redis Solves This Problem

Setting Up Redis in Django

Implementing Ticket Reservation Logic

Conclusion

Redis Demystified: A Simple Introduction for System Design

What is Redis?

Single Threaded

In-Memory

Data structure

Commands to Start Off With

Practical Example

Wrap-Up

Understanding the CAP Theorem: Simplified

Scenario: A Blog Website

Primary-Secondary Database Architecture: A Quick Overview

The CAP Theorem

The Trade-offs: Which Two Should You Prioritize?

Your Use Case: Which Trade-off to Choose?

What about PACELC?

Wrap-Up

Kickstarting Weekly System Design Deep Dives: Building Scalable Systems

Optimizing Query Performance in Django with PostgreSQL: A Case Study

Checking Query Execution Time in Django

Performance Comparison

What you can use?

Know Indexing better

My Decision

Docker 101: Basics and Practical Implementation with Spring REST API

What is Docker?

Understanding the Basics

Docker Hub

Docker Image

Docker Container

Dockerfile

Docker Compose

Brief Overview of Services

1. MySQL (mysql-db)

2. Spring App (spring-app)

Example: Dockerizing a Spring REST API

1. Project Structure:

2. Build the Spring Boot Application:

3. Using the Dockerfile:

4. Using Docker Compose:

5. Running the Application:

6. Accessing the Application:

Sharing Your Docker Image

1. MySQL (`mysql-db`)

2. Spring App (`spring-app`)

1. Add PMD Plugin to `pom.xml`