DEV Community: Dnyaneshwar Dhakane

Sending Invoices Shouldn’t Be a Headache — So I Built Free Invoice Generator Tool

Dnyaneshwar Dhakane — Sun, 13 Jul 2025 04:13:20 +0000

💸 Sending Invoices Shouldn’t Be a Headache — So I Built This Free Invoice Generator Tool

You're done with the project. Client is ready to pay. Now you just need to generate a professional invoice...

But if you’re a freelancer or shop owner, you know the struggle:

Searching for a professional invoice template every time
Manually editing Word or Excel files
Forgetting to include tax details or payment terms
Or worse... sending an outdated, unprofessional invoice 😓

That’s why I built Pro-InvoiceGenerator.com — a clean and powerful free invoice generator to help you create professional invoices online and download them as PDFs in just a few clicks.

✅ What Makes It Useful?

🧾 Choose from 3 Professional Templates — Freelancer Invoice, Standard tax Invoice, and a Modern Clean Look — all designed for real-world use cases

⚡ No Sign-Up, No Delay Just fill the form, download your PDF, send to client. That’s it.

📱 Works Great on Mobile Need to send an invoice from your shop or on the go? This tool has your back.

🎨 Customizable Add your logo, tax info, client details, payment instructions — in seconds.

💡 Who Should Use It?

Freelancers: Designers, developers, writers, marketers, consultants who are tired of ugly Word templates
Shop Owners & Small Businesses: Service providers, vendors, agencies who don’t want to rely on pen and paper
Anyone who wants to send a clean, professional invoice PDF in under 2 minutes and get paid faster

👉 Try it now: Pro-InvoiceGenerator.com It's free, fast, and built to make your work look as professional as it is.

🙏 I’d love to hear your feedback:

Was it useful?
Any features you'd want added?
What could be improved?

Drop your thoughts in the comments or DM me. And if you know someone who needs this — feel free to share.

Abstract Factory vs Factory Pattern in C# .NET: UML & Code Guide

Dnyaneshwar Dhakane — Sun, 09 Feb 2025 12:39:19 +0000

Factory Design Pattern vs Abstract Factory Design Pattern

Design patterns are powerful tools for building scalable and maintainable software. When it comes to Factory and Abstract Factory patterns, understanding their differences can get tricky if you learn one after the other. This blog offers a comparative approach to clarify their concepts and uses.

Let's start with the Factory Design Pattern.

Factory Design Pattern

The Factory Design Pattern provides an interface for creating objects, allowing subclasses to alter the type of objects that will be created.

In the UML diagram above, the IDbServerFactory returns a DbServer object based on the parameter passed by the user.

This approach abstracts the creation process, making it simple for clients. For instance, if new providers are integrated, the client code remains unchanged—it simply specifies the provider, and the factory handles the object creation.

Example Code:

Imagine a client (FactoryDesignPattern) that needs an Azure DB server. By calling GetDbServer("azure"), the desired server is created seamlessly.

using Contracts;

namespace FactoryDP.Services
{
    public class FactoryDesignPattern : IDesignPattern
    {
        public object ExecuteDesignPattern()
        {
            IDbServerFactory dbServerFactory = new DbServerFactory();
            var dbServer = dbServerFactory.GetDbServer("azure");
            dbServer.SetupDatabse();
            return (dbServer.GetType().ToString() + " Created");
        }
    }
}

Key Factory Components:

Factory Interface (IDbServerFactory): Defines a method to return a DbServer instance.
Concrete Factory (DbServerFactory): Implements logic to decide which specific object to create.
Abstract Product (DbServer): Declares the interface for concrete products.
Concrete Products (AzureDbServer, AwsDbServer): Implement the product interface.

Sample Implementation:

namespace FactoryDP.Services
{
    public interface IDbServerFactory
    {
        DbServer GetDbServer(string serverProvider);
    }

    public class DbServerFactory : IDbServerFactory
    {
        public DbServer GetDbServer(string serverProvider)
        {
            return serverProvider.ToLower() switch
            {
                "aws" => new AwsDbServer(),
                "azure" => new AzureDbServer(),
                _ => new AzureDbServer(),
            };
        }
    }
}

By using this design, clients no longer need to manage the complexity of object creation.

Abstract Factory Design Pattern

If you have grasped the Factory pattern, it’s time to move to Abstract Factory.

In simple terms, the Abstract Factory is a factory that itself returns other factories. Think of it as a "factory of factories."

Real-Life Analogy:

Factory Pattern: You walk into a Honda showroom and buy a car.
Abstract Factory Pattern: You walk into a multi-brand showroom that offers Honda, Toyota, and other cars, and you choose a Honda.

UML Example:

In the diagram, the ICloudService factory acts as a wrapper around DbServer and AppServer factories. Clients can create either type by calling CreateDbServer("azure") or similar methods.

Example Code:

Imagine AbstractFactoryDesignPattern as a client needing cloud servers.

using Contracts;

namespace AbstractFactoryDP.Services
{
    public class AbstractFactoryDesignPattern : IDesignPattern
    {
        public object ExecuteDesignPattern()
        {
            ICloudServers cloudServers = new CloudServers();
            var dbServer = cloudServers.CreateDbServer("azure");
            dbServer.SetupDatabase();
            return dbServer;
        }
    }
}

Key Components:

Abstract Factory (ICloudServers): Defines methods for creating related objects (e.g., DbServer, AppServer).
Concrete Factory (CloudServers): Implements the creation logic.
Abstract Products (DbServer, AppServer): Define interfaces for the concrete products.
Concrete Products (AzureDbServer, AwsDbServer, etc.): Implement these interfaces.

Complete Code Sample:

namespace AbstractFactoryDP.Services
{
    public interface ICloudServers
    {
        public DbServer CreateDbServer(string provider);
        public AppServer CreateAppServer(string provider);
    }

    public class CloudServers : ICloudServers
    {
        public DbServer CreateDbServer(string provider)
        {
            return provider.ToLower() switch
            {
                "azure" => new AzureDbServer(),
                "aws" => new AwsDbServer(),
                _ => new AzureDbServer()
            };
        }

        public AppServer CreateAppServer(string provider)
        {
            return provider.ToLower() switch
            {
                "azure" => new AzureAppServer(),
                "aws" => new AwsAppServer(),
                _ => new AzureAppServer()
            };
        }
    }
}

By leveraging Abstract Factory, you achieve a more scalable design for creating related products.

Final Thoughts

Both Factory and Abstract Factory patterns help decouple object creation logic, but their use cases differ:

Use Factory Pattern when you need to create a single type of product.
Use Abstract Factory Pattern when you need to create multiple related products.

If you have any questions or need further clarification, or if I miss something feel free to drop a comment. If this post helped you, don’t forget to share it with others!

Happy Coding! ✨

Why I Revisited MS SQL Server Basics: A Deep Dive into String Data Types

Dnyaneshwar Dhakane — Thu, 29 Aug 2024 04:22:20 +0000

Today, when I raised PR with my manager (It was regarding store procedure), my manager asked me a couple of questions about that.

Like, Why do you declare the data type of string as varchar(n) instead of nvarchar(n) and other scenario-based questions?

You might also have faced a similar situation with seniors or with teachers in college.

Although I gave answers to him, that debate raised questions for me on my basics.

And I decided to revise from the start.

While revising I noticed a few points, which I thought to share with you all, so I am writing this article.

Let's start from the start.

When we create a database 2 files get generated behind the scene.

Data file: This has a (.mdf) extension and is known as a primary data file.
Log file: This has a (.ldf) extension and is known as a transactional log file.

Although, we can configure how many files should be generated. And if we configure more than 2 files there is 3rd category which is :

User-defined files: and those known as secondary data files having the extension (.ndf)

Whenever we perform any DB transaction it first gets stored in the log file and once the transaction is completed it gets updated into the Primary data file.

The default and the lowest size of each file is 8 MB and maximum there is no limit. And for the database, according to Microsoft, one database can be up to 524 PB.

Select vs Print query

If you have used the "select" query then, you might have heard about the "Print" query also.

Let's understand when to use which.

Basically "select" query returns the table data in grid format whereas the "Print" query returns data as text.

So whenever we need to perform an operation on table data we use the "select" query and mostly to print logs or errors we use the "print" query.

Now, Let's discuss the most favorite interview question.

Char vs Varchar vs Nvarchar?

Char:

Char store max 8000 characters, and hold 1 byte per character space.

If we don't specify size, by default SQL assigns 1 byte to it and holds only one character.
If we give more input than the defined size, it auto-truncates the data.
Char follows the static memory allocation, so if we allocate a 20-byte size and store 10 characters, SQL still allocates all 20-byte storage and the remaining 10 bytes will be considered a waste of space.

Varchar:

Varchar can store max 2GB of data, and hold 1 byte per character space. Although it stores up to 8000 bytes of data in the table anything beyond that is stored in the text file.
So you might have noticed its limit as 8000 bytes in multiple articles.
To declare a column to store 2GB data, we can use varchar(max).
Varchar follows the dynamic memory allocation. So if we allocate a 20-byte size and store 10 characters, SQL will allocate only 10-byte storage and the remaining 10 bytes will get saved.

Nvarchar:

Nvarchar follows the same properties as varchar, the only difference is that it uses 2 bytes to store one character.
because it follows Unicode standard data, to support multiple languages.
And char, varchar follows ASCCI standard data.

There is one more datatype called Text, but it has been deprecated, so you can ignore it.

There is one article that I found very useful during my research. It has detailed information about all data types.

You can go through it for more information.

If you think I have missed something or need to update feel free to comment. It will help me as well as our community.

Let's Understand Recursion in JS: Types, Time-complexity

Dnyaneshwar Dhakane — Mon, 19 Aug 2024 14:00:44 +0000

What is recursion?
Head recursion
Tail recursion
Tree recursion
Indirect recursion

What is recursion?

The process in which the function calls itself is called recursion and the responsible function is called the recursion function.

Types of recursion:
On a high level, there are four types

Head recursion : Here, the recursion function calls itself immediately after checking the base condition and before executing any logic.

function getSquares(n){

    if(n>0){
       getSquares(n-1);
       console.log(n*n);
       return;
    }    
}

getSquares(3)

Output for n = 3 is: 1 4 9

If you notice, we are printing the square of a number and then calling the function by reducing the number by 1.

so you are getting all the squares in ascending order.

But if you write the same logic for the tail recursion you will get the output in descending order. The time complexity of the above code will be O(n+1) i.e. O(n).

Tail recursion : The recursion function calls itself and the end i.e. after executing all the logic.

function getSquares(n) {

    if (n == 0)
        return;
    print(n * n);
    getSquares(n - 1);
}

getSquares(3)

Output for n=3 is: 9 4 1

The time complexity for this is O(n+1) i.e. O(n).

Tree recursion: The recursion function calls itself more than one time within the same condition.

function doSomething(n) {
    if (n <= 2)
        return n;
    return doSomething(n - 1) + doSomething(n - 2);
}

console.log(doSomething(5))

Output for n=5 is: 8

If you have noticed in the diagram, we are calling the self function in a tree-like format, that is why we call this type a tree recursion.

The time complexity for this is O(2^(n+1)+1) i.e. O(2^n).

Indirect recursion : The recursion function A calls the recursion function B and function B calls the recursion function A. So, you can get the point why we call it indirect recursion.

function doSomethingA(n) {
    if (n <= 2)
        return n;
    return doSomethingB(n - 1)
}

function doSomethingB(n) {
    if (n <= 2)
        return n;
    return doSomethingA(n - 1)
}

console.log(doSomethingA(5))

Output for n=5 is: 2

To be honest there is not much logic in this example, I have taken this example just to explain you the concept.

if you notice we are calling doSomethingA() and doSomethingA is calling doSomethingB() function and further doSomethingB is calling doSomethingA() function.

This type of recursion calling is called the indirect recursion.

Question for you:
Try to calculate time complexity for indirect recursion. if you have any doubt about it or don't understand any point, you can ask by writing a comment, and I'll try to resolve it with an explanation.

DEV Community: Dnyaneshwar Dhakane

Sending Invoices Shouldn’t Be a Headache — So I Built Free Invoice Generator Tool

💸 Sending Invoices Shouldn’t Be a Headache — So I Built This Free Invoice Generator Tool

✅ What Makes It Useful?

💡 Who Should Use It?

Abstract Factory vs Factory Pattern in C# .NET: UML & Code Guide

Factory Design Pattern vs Abstract Factory Design Pattern

Factory Design Pattern

Example Code:

Key Factory Components:

Sample Implementation:

Abstract Factory Design Pattern

Real-Life Analogy:

UML Example:

Example Code:

Key Components:

Complete Code Sample:

Final Thoughts

Why I Revisited MS SQL Server Basics: A Deep Dive into String Data Types

Let's start from the start.

Select vs Print query

Char vs Varchar vs Nvarchar?

Let's Understand Recursion in JS: Types, Time-complexity

Table Of Contents

What is recursion?