DEV Community: Prabath Kavinda

Exploring Nature: Top Adventure Spots Near Sabaragamuwa University, Sri Lanka

Prabath Kavinda — Fri, 30 May 2025 00:49:22 +0000

If you’re studying or visiting Sabaragamuwa University, you’re in luck—some of Sri Lanka’s most beautiful landscapes are right at your doorstep. Here are a few adventure spots you shouldn’t miss:

• Pahanthuduwa Waterfall & Citrine River: A haven for hikers and nature lovers.

• Samanala Dam: Stunning reservoir views and a peaceful escape.

• Non-pareil: Great for scenic walks and mountain views.
• Surathali Ella: A local favorite for river swims and picnics.
• Adara Kantha: The ultimate hiking challenge with seven peaks.

Want to know more about the university and its surroundings? Check out Sabaragamuwa University of Sri Lanka

** Image credits go to the original owners **

🍪 “Wait, Cookies Know My Name?!” — A Tech Tale You Didn’t Know You Were Living

Prabath Kavinda — Tue, 22 Apr 2025 07:09:48 +0000

Picture this: You walk into your favorite café, and the barista smiles, “Hey! Your usual caramel latte?” You nod, amazed they remember. Now imagine the internet doing the exact same thing — but instead of a friendly barista, it’s tiny files called cookies working behind the scenes.

Wait — what?

That’s right. Digital cookies aren’t the kind you dunk in milk. They’re little trackers that websites use to remember you. Some are helpful (like remembering your login), while others… well, let’s just say they’re the overly clingy type.

🧠 So, What Are Cookie Files?

Cookies are small text files that websites save on your device when you visit them. Think of them like Post-it notes, your browser leaves for itself:

“User X loves cat videos — show more!”
“This person left items in their cart — send a reminder!”
“Dark mode ON, language: English.”

Without cookies, you’d have to log in every single time you open Instagram or re-add items to your Amazon cart. Annoying, right?

🎯 A Real-Life Cookie Scenarios

Scenario 1: You search for “best gaming laptops” on Google. Later, every website you visit shows you ads for gaming laptops. Creepy? Yep. That’s tracking cookies sharing your data.

Scenario 2: You log into Netflix on your friend’s laptop but forget to log out. Next time they open Netflix, your profile shows up. That’s a session cookie doing its job (until you clear it).

That’s cookies at work. They silently whisper to sites, “Hey, this user was interested in these items, maybe remind them?”

👨‍💻 What Do We Do With Cookies?

Websites use cookies to:

Keep you logged in (lifesaver if you hate passwords)
Personalize your experience (like showing dark mode by default)
Show you targeted ads (yes, those sneakers keep following you)
Track usage for analytics (they learn what students click most)

As users, we can:

View and clear cookies from browser settings
Block third-party cookies for privacy
Use incognito mode to avoid tracking (kinda)

✅ Advantages of Cookies

Convenience: You don’t have to type your username every time.
Personalization: Netflix knows what type of weird documentaries you binge.
Speed: Faster loading for websites you’ve visited before.

❌ But Not All Cookies Are Sweet

Privacy concerns: Some cookies track you across multiple sites.
Security risks: In rare cases, cookies can be hijacked.
Storage clutter: Over time, too many cookies can slow your browser.

💡 One Last Crumb of Thought

Cookies aren’t good or bad — they’re tools. The key? Control them. Clear cookies often, use incognito mode when needed, and remember: the internet remembers.

🔥 Liked this?

Smash the clap button, follow for more tech-simplified stories, and comment: “What’s the weirdest ad you’ve gotten thanks to cookies?” Let’s compare notes! 👇

Factory Pattern-

Prabath Kavinda — Sun, 20 Apr 2025 14:30:39 +0000

Factory Design Pattern in Java: Brew Up Scalable Coffee Shop Software

Imagine you own a coffee shop that’s booming. More customers mean more coffee types: Espresso, Latte, Cappuccino, you name it. But, your ordering system becomes a mess. Each new drink requires changes, making things slow and hard to manage. How do you handle creating different objects without creating a headache? The Factory Design Pattern helps solve the problem. It helps you make your code flexible and easier to handle.

What is the Factory Design Pattern?

The Factory Design Pattern is like a coffee machine. You select a drink, and it gives you the correct cup. It handles the creation of objects. This pattern lets you create objects without knowing how they’re made. It’s a blueprint for making your code more adaptable.

Key Components

This pattern has key ingredients that make it work well.

Product: This is the interface or abstract class. It defines what kind of object the factory creates. In our shop, it’s the Coffee interface.
Concrete Product: These are the real implementations of the Product. Think Espresso, Latte, and Cappuccino classes.
Factory: An interface or abstract class that defines a method to create objects. It’s like the coffee machine’s button panel.
Concrete Factory: This class creates specific products. EspressoFactory makes espressos. Each factory handles its own type of coffee.

Benefits of Using the Factory Pattern

Why should you care about this pattern?

It makes your code less dependent on specific classes.
Your code becomes easier to update and grow.
It hides the details of object creation.
It follows the Open/Closed Principle. This means you can add new types without changing existing code.

Implementing the Factory Pattern in Java: The Coffee Shop Example

* Defining the Product Interface: Coffee

First, we define a Coffee interface:

interface Coffee {
    void prepare();
    void brew();
    void pour();
}

This interface declares the actions a coffee must perform.

* Creating Concrete Products: Espresso, Latte, Cappuccino

Next, create classes that implement the Coffee interface:

class Espresso implements Coffee {
    @Override
    public void prepare() {
        System.out.println("Grinding espresso beans...");
    }

@Override
    public void brew() {
        System.out.println("Brewing espresso...");
    }
    @Override
    public void pour() {
        System.out.println("Pouring espresso into a cup.");
    }
}
class Latte implements Coffee {
    @Override
    public void prepare() {
        System.out.println("Steaming milk...");
    }
    @Override
    public void brew() {
        System.out.println("Adding espresso...");
    }
    @Override
    public void pour() {
        System.out.println("Pouring latte into a cup.");
    }
}
class Cappuccino implements Coffee {
    @Override
    public void prepare() {
        System.out.println("Frothing milk...");
    }
    @Override
    public void brew() {
        System.out.println("Adding espresso...");
    }
    @Override
    public void pour() {
        System.out.println("Pouring cappuccino into a cup.");
    }
}

Each class has its own way of preparing, brewing, and pouring.

* Designing the Factory Interface: CoffeeFactory

Now, create a CoffeeFactory interface:

interface CoffeeFactory {
    Coffee createCoffee(String type);
}

This interface has a method to create coffee based on type.

* Implementing Concrete Factories: EspressoFactory, LatteFactory, CappuccinoFactory

Finally, implement the factory:

class SimpleCoffeeFactory implements CoffeeFactory {
    public Coffee createCoffee(String type) {
        Coffee coffee = null;
        if ("espresso".equalsIgnoreCase(type)) {
            coffee = new Espresso();
        } else if ("latte".equalsIgnoreCase(type)) {
            coffee = new Latte();
        } else if ("cappuccino".equalsIgnoreCase(type)) {
            coffee = new Cappuccino();
        }
        return coffee;
    }
}

Now you can create different kinds of coffee with ease. The factory handles the creation details.

Types of Factory Patterns

The Factory Pattern comes in different flavors.

*** Simple Factory**

This is the easiest type. It’s a single class that creates objects. But, it can become complex if you have many types. If you only need a factory once, then use it.

*** Factory Method**

This pattern lets subclasses decide which class to create. It’s great for frameworks where the parent class cannot know the exact object type.

*** Abstract Factory**

This creates families of related objects. Imagine a UI factory that makes buttons and windows for different operating systems.

Real-World Applications and Examples

The Factory Pattern isn’t just theory. It is used everywhere.

*** Database Connection Factories**

It can create connections to different databases. Your code doesn’t need to know the specific database details.

*** UI Component Factories**

It makes UI elements for different platforms. For example, create buttons or text fields.

Conclusion:

The Factory Design Pattern brings flexibility and order to object creation. It makes your code easier to maintain and grow. Embrace this pattern and make your software shine. Design patterns are like secret tools that help you solve tough problems. Start using them.

Singleton Pattern-

Prabath Kavinda — Fri, 18 Apr 2025 17:01:58 +0000

01) What?

1.1) Real World Scenario

Imagine a scenario where having multiple copies of something could cause problems. Think about a database connection, or maybe a printer. If everyone had their own connection or tried to print at the same time, things could get messy real fast. The Singleton pattern is a clever way to make sure you only have one instance of a particular class. It’s a common pattern in software design, and it’s super useful for managing resources efficiently. In this guide, we’ll explore what the Singleton pattern is, why it matters, and how you can use it. You’ll learn how to implement it and when it’s the right tool for the job.

1.2) What is the Singleton Pattern?

The Singleton pattern is all about control. It ensures that a class has only one instance.

Plus, it provides a single, global point of access to that instance. Think of it like the principal of your school. There’s only one principal, and everyone knows who to go to if they need to talk to them. That’s essentially what the Singleton pattern does for classes in your code.

Singleton Pattern comes under the Creational Design Patterns. There are two more types in Design Patterns, need to know? read my previous story

Prabath Kavinda

Apr 12 '25

Design Patterns in Software Development

#designpatterns #softwaredevelopment #programming #oop

Comments 1

3 min read

02) Why?

Why would you want only one instance of a class? Well, there are many reasons. Sometimes, it’s about managing a shared resource, like a database connection. Only one connection is needed, and it’s more efficient to share it. Other times, it’s about ensuring consistent behavior across your application. If you have multiple instances, they might get out of sync, leading to unexpected issues. The Singleton pattern helps avoid these problems by guaranteeing that everyone is using the same instance.

03) Benefits?

3.1) Controlled Resource Access,

Singletons are great for managing shared resources. Imagine you have a logging system. You want to make sure all parts of your application write logs to the same place. A Singleton logger can ensure this, preventing different parts of the code from creating separate log files or messing with each other’s logs. This makes debugging and monitoring much easier. For example, a print spooler is a great use of the singleton pattern because it ensures only one job prints at a time.

3.2) Lazy Initialization and Performance,

Singletons can be lazily initialized. This means the instance is only created when it’s first needed. This can improve startup performance. If you have a class that takes a long time to initialize, you don’t want to create it when your application starts. You only want to create it when it’s actually used. This is where lazy initialization comes in handy. But there’s a trade-off: the first time you access the instance, there might be a slight delay while it’s being created.

3.3) Namespace Management,

Singletons help keep your code organized. They provide a single, well-defined point of access, reducing the risk of naming conflicts. Think of it like having one official address for a company. Instead of having multiple addresses floating around, everyone knows to use the same one. This simplifies your code and makes it easier to understand and maintain.

04) Step by Step?

Let’s look at how to implement the Singleton pattern. Here I use Java to implement this. You can use your familiar language, structure and the concept is same only the syntax will change as according to language.

4.1) Basic Implementation,

public class Singleton {
    private static Singleton instance;

    private Singleton() {
        // Use Private constructor to prevent from instantiation
    }

      // When user needs to use this instance, get method will help

    public static Singleton getInstance() {
        if (instance == null) {
            instance = new Singleton();
        }
        return instance;
    }
}

This code shows the three key elements: a private constructor, a static instance variable, and a static getInstance() method. The getInstance() method checks if an instance already exists. If not, it creates one and returns it.

4.2) Thread-Safe Singleton Implementation,

In a multi-threaded environment, you need to be careful. Multiple threads might try to create an instance at the same time, which would break the Singleton pattern. To prevent this, you can use locking mechanisms. Here’s an example using double-checked locking:

public class Singleton {
    private static volatile Singleton instance;

    private Singleton() {
        // Use Private constructor to prevent from instantiation
    }

    // When user needs to use this instance, get method will help

    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }
}

05) Where?

5.1) Database Connection Management

5.2) Configuration Settings

5.3) Logging

5.4) Cache Manager

Design Patterns in Software Development

Prabath Kavinda — Sat, 12 Apr 2025 03:32:20 +0000

Design Patterns in Software Development: A Practical Guide

Ever worked on a software project that turned into a tangled mess? Maybe adding a simple feature became a nightmare. Or perhaps the code was so confusing that nobody dared to touch it. These problems often stem from poor design choices. But there's a solution!

Design patterns are like blueprints for solving common software design problems. They're reusable solutions that can make your code easier to understand, maintain, and scale. By using design patterns, you can write better code, faster.

What are Design Patterns?

Design patterns are proven solutions to recurring problems in software design. Think of them as templates you can adapt to solve specific issues. They are not finished designs that can be transformed directly into code. A design pattern is a description or template for how to solve a problem that can be used in many different situations.

Unlike algorithms or data structures, design patterns aren't specific pieces of code. They are more like general guidelines for structuring your code. These patterns show how to arrange classes and objects to solve a design problem.

Categories of Design Patterns

Design patterns are typically grouped into three main categories. These categories reflect the type of problem they solve:

Creational: These patterns deal with object creation mechanisms. They help you create objects in a flexible and controlled way.
Structural: These patterns focus on how to compose objects into larger structures. They help you define relationships between objects.
Behavioral: These patterns address object interaction and responsibility assignment. They define how objects communicate and collaborate.

Benefits of Using Design Patterns

Using design patterns offers several key advantages. They improve code reusability. Once you understand a pattern, you can apply it in different projects. Code that follows established patterns is easier to understand and modify.

Design patterns can also improve scalability. A well-designed application can handle increasing workloads and new features without major rework. For example, using the Observer pattern can allow you to add new features that react to events, with minimal impact to the system. This saves time in the long run.

Choosing the Right Design Pattern

Choosing the right design pattern is important. You need to understand the problem you're trying to solve. Consider the tradeoffs involved. Don't just apply a pattern because it sounds cool.

Understanding the Problem

Carefully analyze the problem domain. Identify the core design challenges. What are the key requirements? What are the constraints? A clear understanding of the problem will guide you towards the right pattern. You have to know what you're solving to pick the right pattern.

Evaluating Tradeoffs

Each design pattern has its own tradeoffs. Some patterns add complexity to the code. Some could impact performance. Others may make the code harder to maintain. Consider these factors before choosing a pattern. There isn't a free lunch.

When NOT to Use Design Patterns

Not every problem requires a design pattern. Sometimes, simpler solutions are better. Overusing patterns can lead to over-engineering. This makes the code more complicated than it needs to be. Remember, the goal is to solve the problem. Keep the code simple and easy to understand.

Conclusion

Design patterns offer numerous benefits in software development. They improve code quality. Also, they reduce development time.

Understanding different types of design patterns is key. Pick the right one for the problem. Do it to make good code.

Continue to learn and experiment with design patterns. Your software development skills will improve.

Have you used design patterns in your projects? What are your experiences? Share your thoughts and ask questions in the comments below!

DEV Community: Prabath Kavinda

Exploring Nature: Top Adventure Spots Near Sabaragamuwa University, Sri Lanka

🍪 “Wait, Cookies Know My Name?!” — A Tech Tale You Didn’t Know You Were Living

🧠 So, What Are Cookie Files?

🎯 A Real-Life Cookie Scenarios

👨‍💻 What Do We Do With Cookies?

✅ Advantages of Cookies

❌ But Not All Cookies Are Sweet

💡 One Last Crumb of Thought

🔥 Liked this?

Factory Pattern-

Factory Design Pattern in Java: Brew Up Scalable Coffee Shop Software

What is the Factory Design Pattern?

Key Components

Benefits of Using the Factory Pattern

Implementing the Factory Pattern in Java: The Coffee Shop Example

*** Defining the Product Interface: Coffee**

*** Creating Concrete Products: Espresso, Latte, Cappuccino**

*** Designing the Factory Interface: CoffeeFactory**

*** Implementing Concrete Factories:** EspressoFactory, LatteFactory, CappuccinoFactory

Types of Factory Patterns

Real-World Applications and Examples

Conclusion:

Singleton Pattern-

01) What?

Design Patterns in Software Development

02) Why?

03) Benefits?

04) Step by Step?

05) Where?

Design Patterns in Software Development

Design Patterns in Software Development: A Practical Guide

What are Design Patterns?

Categories of Design Patterns

Benefits of Using Design Patterns

Choosing the Right Design Pattern

Understanding the Problem

Evaluating Tradeoffs

When NOT to Use Design Patterns

Conclusion

* Defining the Product Interface: Coffee

* Creating Concrete Products: Espresso, Latte, Cappuccino

* Designing the Factory Interface: CoffeeFactory

* Implementing Concrete Factories: EspressoFactory, LatteFactory, CappuccinoFactory