DEV Community: The Polyglot Academy

TPA is now on Discord!

Abhinav Jha — Tue, 15 Mar 2022 06:32:29 +0000

Hello Everyone,
The Polyglot Academy is now on Discord! Hurray!

FAQ for helping you get started!

What is Discord?

If you are new to technology, you may not know about the discord. Let us help you with that. Discord is a free voice, video, and text chat app that's used by tens of millions of people ages 13+ to talk and hang out with their communities and friends.

About The Polyglot Academy

The Polyglot Academy is a One-Stop Solution for learning and getting hired in the IT industry. We believe your Hard-work can beat lazy Talents. We mentor your journey with industry professionals and provide experience and certification for your professional training roles.
At TPA you will learn core industrial concepts and then decide on which role you want to excel in your carrier path. Our graduates excel at their jobs and provide team leadership for building products.

P3: Programming Design Patterns

Abhinav Jha — Sun, 07 Nov 2021 07:28:17 +0000

Abstract Factory

Book Definition: The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

My Definition: Abstract factory pattern allows clients(in our case NYStylePizzaFactory) to use an abstract interface to create a set of relative(similar) products(like NYStyleCheesePizza) without actually knowing actual products that are actually produced.

Problem

I have a successful Pizza Stores so far but, I received some complaints on the quality of pizza produced by NYStylePizzaFactory. After investigating this issue, I found they are using low-quality ingredients for preparing pizza which they acquire from the local market place. This problem leads me to a situation where I need to find a solution to monitor and maintain my quality of ingredients that my franchises use for creating pizzas. So I read my Design Pattern Bible Head First Design Pattern.

So I found my solution with Abstract Factory Pattern this helped me to create an Ingredients Factory that will provide the ingredients for NYStylePizzaFactory and ChicagoStylePizzaFactory. Which I have implemented later in this article.

Solution

That's fairly complicated class diagram to draw; let's look at it all in terms of our PizzaStore:

What I have done?

Code Implementation

I have not changed a lot in code for implementing abstract factory. Lets follow few steps to implement new changes.

Step 1: Create Ingredients factory to create pizza ingredients.

// filePath : Factory\IIngredientsFactory.cs
public interface IIngredientsFactory
{
    Dough CreateDough();
    Sauce CreateSauce();
    Cheese CreateCheese();
    Veggies[] CreateVeggies();
    Pepperoni CreatePepperoni();
    Clams CreateClam();
}

Step 2: Implement IIngredientsFactory and create NYPizzaIngredientFactory and ChicagoPizzaIngredientsFactory for supplying ingredients.

// filePath : Factory\NYPizzaIngredientFactory.cs
public class NYPizzaIngredientFactory : IIngredientsFactory
{
    public Cheese CreateCheese()
    {
        return new MozzarellaCheese();
    }
    public Clams CreateClam()
    {
        return new FreshClams();
    }
    public Dough CreateDough()
    {
        return new ThinCrustDough();
    }
    public Pepperoni CreatePepperoni()
    {
        return new Pepperoni();
    }
    public Sauce CreateSauce()
    {
        return new MarinaraSauce();
    }
    public Veggies[] CreateVeggies()
    {
        return new Veggies[] { new GarlicVeggie(), newOnionVeggie() };
    }
}

Step 3: Now you can create your own ChicagoPizzaIngredientsFactory by implementing Ingredients.

Step 4: For Ingredients I have used class inheritance for implementing different type of ingredients. Let see how I implemented this.

// filePath: Factory\Ingredients\Cheese.cs
public class Cheese
{
}

// filePath: Factory\Ingredients\Categories\ReggianoCheese.cs
public class ReggianoCheese : Cheese
{
}

// filePath: Factory\Ingredients\Categories\MozzarellaCheese.cs
public class MozzarellaCheese : Cheese
{
}

Step 5: Follow the same order of this category and create you own classes for Clams, Dough, Pepperoni, Sauce and Veggies

Step 6: We have to change the pizza categories for using Ingredients factory and creating pizza.

// filePath: PizzaItems\Pizza.cs
public abstract class Pizza
{
    public string name { get; set; }
    public Dough dough { get; set; }
    public Sauce sauce { get; set; }
    public Veggies[] Veggies { get; set; }
    public Cheese cheese { get; set; }
    public Clams clams { get; set; }
    public abstract void prepare();
    public virtual void bake()
    {
        Console.WriteLine("Bake for 25 minute at 350.");
    }
    public virtual void cut(string cutStyle)
    {
        Console.WriteLine("Cutting the pizza into " +cutStyle + " slices.");
    }
    public virtual void box()
    {
        Console.WriteLine("Place pizza in official PizzaStore box.");
    }
    public void setName(string name)
    {
        this.name = name;
    }
    public string getName()
    {
        return name;
    }
}

// filePath: PizzaItems\Types\CheesePizza.cs
public class CheesePizza : Pizza
{
    private readonly IIngredientsFactory _ingredientFactory;

    public CheesePizza(IIngredientsFactory ingredientFactory)
    {
        _ingredientFactory = ingredientFactory;
    }
    public override void prepare()
    {
        Console.WriteLine("Preparing " + name);
        dough = _ingredientFactory.CreateDough();
        sauce = _ingredientFactory.CreateSauce();
        cheese = _ingredientFactory.CreateCheese();
        clams = _ingredientFactory.CreateClam();
    }
}

Step 7: Sit back and relax a bit, now our ingredients factory implementation is completed, so lets pass it to our regional factories. I'm implementing it on NY Pizza Factory you can implement in your Chicago Pizza Factory.

public class NYStylePizzaStore : PizzaStore
{
    public override Pizza CreatePizza(string type)
    {
        Pizza pizza = null;
        IIngredientsFactory ingredientsFactory = newNYPizzaIngredientFactory();
        switch (type)
        {
            case "Cheese":
                pizza = new CheesePizza(ingredientsFactory);
                pizza.setName("NY StyleCheese Pizza");
                break;
            case "Clam":
                pizza = new ClamPizza(ingredientsFactory);
                pizza.setName("NY StyleClam Pizza");
                break;
            default:
                Console.WriteLine("Please select valid pizza type.");
                break;
        }
        return pizza;
    }
}

Share your view

If you want me to write more on design patterns please feel free to comment. It make me feel appreciated.
Also, mention patterns you want to learn.

P2: Programming Design Patterns

Abhinav Jha — Sat, 06 Nov 2021 12:45:07 +0000

Creational - Factory Method Pattern

Factory method pattern encapsulates object creation by letting subclasses decide what object to create. Here is the class diagram showing how this pattern works:

This self explanatory UML diagram is the example stated in Head First Design Pattern.

Problem Statement

Hello guys, I am glad that you have followed my story with my Simple Pizza Factory, I have earned huge success and got offers to start franchises of my Pizza Store in New York and California.

Before modifying my code for these franchises, I want to list out my quality control rules and cost calculation as I don't want them to misuse my name by not maintaining the quality that I give to my customers, and also I want them to feel free for taking orders and inventing pizza based on the competition.

Franchises Requirements

I want all the franchise pizza store to leverage my PizzaStore code, so that pizzas are prepared in the same way.
NY style pizza will have thin crust, tasty sauce and little cheese. (based on the requirements)
Chicago style pizza will have thick crust, rich sauce and tons of cheese. (based on the requirements)
Need to control quality control to prevent mistake in Cutting and Boxing pizza.

Solution

There is a way to localize all the pizza making activities in the pizza store.
First, lets look into the changes in the Pizza Store:

// Making Pizza Store abstract helped me to move our CreatePizza logic
// to sub classes (NYStylePizzaStore) (ChicagoStylePizzaStore)
public abstract class PizzaStore
{
    public IPizza OrderPizza(string type)
    {
        IPizza pizza;
        pizza = CreatePizza(type);

        pizza.prepare();
        pizza.bake();
        pizza.cut();
        pizza.box();

        return pizza;
    }

    // All the responsibility for instantiating Pizzas has been moved into
    // a method that acts as a factory.
    public abstract IPizza CreatePizza(string type);  // Now this method will create factory.

    // Other methods here
}

One more thing I want to change in my PizzaStore, I have to change my IPizza Interface to Pizza abstract class, with the help of which I can force the steps required in pizza making process. This abstract class will help my franchises to follow the basic steps mention in this abstract class and can override their step if they want to update the process.

public abstract class Pizza
{
    public abstract string name { get; set; }
    public abstract string dough { get; set; }
    public abstract string sauce { get; set; }
    public abstract List<string> toppings { get; set; }
    public virtual void prepare()
    {
        Console.WriteLine("Preparing " + name);
        Console.WriteLine("Tossing dough...");
        Console.WriteLine("Adding sauce...");
        Console.WriteLine("Adding toppings: ");
        foreach (string topping in toppings)
        {
            Console.WriteLine(" " + topping);
        }
    }
    public virtual void bake()
    {
        Console.WriteLine("Bake for 25 minute at 350.");
    }
    public virtual void cut()
    {
        Console.WriteLine("Cutting the pizza into diagonal slices.");
    }
    public virtual void box()
    {
        Console.WriteLine("Place pizza in official PizzaStore box.");
    }
    public string getName()
    {
        return name;
    }
}

You must be wondering how this will help me, wait for a min and look into some of the pizza class.

// My NY Style Sauce and Cheese Pizza
public class NYStyleCheesePizza : Pizza
{
    public override string name { get; set; }
    public override string dough { get; set; }
    public override string sauce { get; set; }
    public override List<string> toppings { get; set; }= new List<string>();
    public NYStyleCheesePizza()
    {
        name = "NY Style Sauce and Cheese Pizza";
        dough = "Thin Crust Dough";
        sauce = "Marinara Sauce";
        toppings.Add("Grated Reggiano Cheese");
    }
}

// My Chicago Style Sauce and Cheese Pizza
public class ChicagoStyleCheesePizza : Pizza
{
    public override string name { get; set; }
    public override string dough { get; set; }
    public override string sauce { get; set; }
    public override List<string> toppings { get; set; } = new List<string>();
    public ChicagoStyleCheesePizza()
    {
        name = "Chicago Style Deep Dish Cheese Pizza";
        dough = "Extra Thick Crust Dough";
        sauce = "Plum Tomato Sauce";
        toppings.Add("Shredded Mozzarella Cheese");
    }
    public override void cut()
    {
        Console.WriteLine("Cutting the pizza into square slices.");
    }
}

In the above implementation you can see the difference from Simple Factory to Factory Method.

Usage

You've waited long enough. Time for some pizzas!

$ cd FactoryMethod
$ dotnet build
$ dotnet run
Welcome to my Pizza Store!
Please enter your pizza type from
(Cheese)(Clam)

Cheese

Preparing NY Style Sauce and Cheese Pizza
Tossing dough...
Adding sauce...
Adding toppings:
Grated Reggiano Cheese

Bake for 25 minute at 350.

Cutting the pizza into diagonal slices.

Place pizza in official PizzaStore box.

Thank for Ordering FactoryMethod.PizzaItems.Types.NYStyleCheesePizza please collect your order from front desk in 15 min

Preparing Chicago Style Deep Dish Cheese Pizza

Tossing dough...
Adding sauce...
Adding toppings:
 Shredded Mozzarella Cheese

Bake for 25 minute at 350.

Cutting the pizza into square slices. 

Place pizza in official PizzaStore box.
Thank for Ordering FactoryMethod.PizzaItems.Types.ChicagoStyleCheesePizza please collect your order from front desk in 15 min

Moving Forward

Hurray! My pizza franchises are thanking me for this great effort that I have put to create my stores.

Share your view

If you want me to write more on design patterns please feel free to comment. It make me feel appreciated.
Also, mention patterns you want to learn.

Now, my stores is going popular and I will look for Abstract Factory Pattern to make implement some more compatibility with my Pizza Store.

P1: Programming Design Patterns

Abhinav Jha — Fri, 05 Nov 2021 14:20:33 +0000

The Simple Factory

The Simple Factory isn't actually a Design Pattern; it's more of a programming idiom. Some developers do mistake this idiom for the "Factory Pattern," so the next time there is an awkward silence between you and another developer, you've got a nice topic to break the ice.

This is a UML diagram shown in Head First Design Pattern :

This is a self explanatory diagram of Simple Factory idiom.

Problem Statement

I want to start my Pizza Store and want my store to have four types of pizza shown on the above UML diagram. But, since I don't have any knowledge of design patterns, I have created my store application as shown below:

I think this will be the default approach that most of the developers will use to create their pizza store:

public Pizza OrderPizza(string type)
{
    Pizza pizza;
    // This is wrong to specify pizza creational logic within orderPizza() method.
    // we need to move this somewhere else lets discuss that below.
    if(type == "CheesePizza")
        pizza = new CheesePizza();
    else if(type == "VeggiePizza")
        pizza = new VeggiePizza();
    else if(type == "ClamPizza")
        pizza = new ClamPizza();
    else if(type == "PepperoniPizza")
        pizza = new PepperoniPizza();
    else
        pizza = new CheesePizza();
    // ----------

    pizza.prepare();
    pizza.bake();
    pizza.cut();
    pizza.box();

    return pizza;
}

This program will work for me but when I read about the object oriented design patterns and came across Head First Design Pattern book, I found that I am thinking it in a wrong way.

But being a Software Developer, I wanted my store to be more loosely coupled, as time passes I will have more competitions in my region. So, if I want to add or remove any pizza I have to update my OrderPizza method all the time. Which will bring me in a situation where i will end up with pile of garbage code since I have to write all the logic in the same class.

But, where can I move this code from here.

Move in the new Method : Moving this login to a new method will not solve the problem for me as I have to again edit my Program class for adding and removing order and when I want my application to calculate the cost of pizza I will end up mixing all the code in a single class which is a voilation of SRP(Single Responsibility Principle).

So, how I solved this problem, I have created my store class PizzaStore and given it the responsibility to take orders based on the type of pizza, I have also injected my PizzaFactory class that will help my store to create pizza using PizzaFactory. My PizzaFactory will take the type of pizza and by using IPizza interface it will prepare, bake, cut and box the pizza and send it back to PizzaStore.

So, Lets see how it looks on the directory:

- PizzaStore.cs
- PizzaFactory.cs
- PizzaModel
    IPizza.cs
    - Types
        - CheesePizza.cs
        - VeggiePizza.cs
        - ClamPizza.cs
        - PepperoniPizza.cs

So, with this model when ever we have any update in the menu item, we will update the factory and the store will not be effected.

Usage

Let me run my pizza store application:

$ cd SimpleFactory
$ dotnet build
$ dotnet run
Welcome to my Pizza Store!
Please enter your pizza type from
(Cheese)(Veggie)(Clam)(Pepperoni)
Cheese

Preparing Cheese Pizza
Backing Cheese Pizza
Cutting Cheese Pizza
Boxing Cheese Pizza

Thank for Ordering SimpleFactory.PizzaModel.Types.CheesePizza please collect your order from front desk in 15 min.

Moving Forward

Hurray! My pizza store is looking great now and I am getting a lot of profit from it.

Now, my store is going popular and I want to start franchises in the next town to increase my profit. I will update my current architecture with Factory Method Pattern and introduce the cost calculator to calculate pizza cost based on item used. To understand how I have expended my store app follow my next design pattern.