Friday, May 6, 2022

The tribute from a #guru to his own gurus...

here is the #guru inside me is paying his tributes to his #guru from the #techworld and other walks of his life

they are Linus Torvalds, the authors of the #gangoffour #designpatern book, the creator of #android, and many more people who contributed to this enormous effort while still keeping it open source, the authors of the #effectivecpp and #moreeffectivecpp and the similar category of books, professor Doug of the USA for his insights about android internals in the lectures, I think at #coursera, my family/wife for providing me a caring #home and taking care of all the external noises and giving me enough room for in-depth study and research, and last but not the least, my currently 11-years-old son #ridit - my best student so far - for still keeping the fire in the belly alive.

the term Techworld is significant.

they showed me the way to move forward in the maze of the software world.

at last, I am able to claim to be a true engineer

it takes time to gain real expertise.

I look up to other gurus for another purpose - like morality, character, philosophy, or mindset

today is the right time to mention them as well

the #guru that I adore a lot is the avatar of #lordkrishna uttering #gita in the deadly battlefield of #mahabharata and I have learned a lot from this #guru about how to motivate myself in difficult times

the other character that attracts me is #shabari feeding the tired #lordrama - which shows that many times just a bit of kindness is enough to make a dead person alive

the other character I am attracted to is #daupradi who showed what exactly is meant by #agnikanya - a really powerful image of the ancient #bharat - always took the center stage of #mahabharata by her sheer intelligence and beauty - energizing all of her lions in the right direction. there is a lot for the modern-day feminists to learn from her

the other character that has attracted me is #karna - the real fighter - being struck by #destiny - yet never became a coward soul for any selfish reason

the other #guru to mention here is #dronacharya - the man behind creating skills

the other #guru is #vivekananda - who showed that by sheer determination and good intention, we can really move a mountain - a real #guru for the youth of the nation - a #karmyogi

the other few gurus I must mention is my #grandfather who enlightened me with the real history of #bharat - without any manipulation from the people like Romila Thaper and all such leftist propaganda machine

my parents showed me that hard work pays off

and then all of my childhood teachers who taught me - most of the time without even taking a penny must be mentioned here

the childhood friends of #purulia created a really jealousy free environment where collaboration was the real fun way

the raw environment of #purulia where actually there was no restriction as such helped me live the life on my own terms - which was of course a boon in the disguise

and last but not the least all the negative people who actually created hurdles in the journey helped me to become more resilient instead of becoming a weak-hearted guy

The State Design pattern in C++ using timer and notification

As a #guru, let me pay my respects today to my #guru in the tech world, who has influenced my technical skills and mindset.

Although I have never seen them, nor do they know I exist.

But I am grateful to them - and because of them, I have at last become an engineer in the true sense.

First guru: The authors of The Gang of Four Design Pattern Book

Second Guru: Linus Torvalds for offering Linux and rather helping me come out of the vicious cycle of windows

Third Guru: The Android creator and Google for showing me the different nitty-gritty of a complicated framework that i learnt through delving into the Android framework code

Fourth Guru: A professor of a USA University by the name Doug, from whom I got insights of how to study the Android OS difficult parts of the code like the AsyncTask Framework, and he showed me the right approach of taking the OS study from an engineer’s perspective - delving into the difficult concurrent framework of the Android OS

And my all-time Guru: My family for giving me a sweet, caring, loving #home and my only son, #ridit, for becoming my best student from his early childhood. He is still driving me to burn the midnight oil in front of the laptop to explore the deep ocean of Computer science.

And I am sure, the way the whole professional world of technology is moving, very soon somebody will have to dismiss the book called

#theworldisflat - The World Is Flat

and write a new one

#theflatistheworld - The Flat Is The World

Now let's come back to the subject. Let's discuss the technical side of the State Design Pattern.

The state design pattern is a powerful tool in software design, allowing you to encapsulate an object's behavior based on its internal state.

The main participants in this design pattern are:

Context: This object represents the entire entity experiencing state changes. It holds a reference to the current state object and exposes an interface for external interaction.

State: These are concrete classes representing each possible state the object can be in. Each state class defines its own behavior for responding to events and transitions.

Transitions: These define how the object can move from one state to another. They can be triggered by events, user actions, or internal conditions.

In my example, I have cited the process of cooking chicken - how the chicken states alter from an uncleaned state to a cleaned state to a marinated state to a cooked state and finally served to the guests.

Here is the class diagram of the design pattern...

Runtime Behaviour

The runtime interaction follows these steps:

The application creates the Context.
The Context delegates execution to the current State.
The State starts a Timer.
The Timer expires.
The Timer invokes the notification callback.
The callback requests the Context to change its current State.
The Context delegates subsequent operations to the new State.

The source code...

Callback.h

#ifndef CALLBACK_H_
#define CALLBACK_H_

class Callback {
public:
    virtual void goToNextStateFromCallback() = 0;
    virtual ~Callback() = default;
};

#endif

ChickenState.h

#ifndef CHICKENSTATE_H_
#define CHICKENSTATE_H_

#include <string>

class ChickenState {
public:
    virtual ~ChickenState() = default;
    virtual void wash(int period, int totalTime) {}
    virtual void marinate(int period, int totalTime) {}
    virtual void cook(int period, int totalTime) {}
    virtual void serve(int period, int totalTime) {}
    virtual void goToNextState() = 0;
    virtual std::string getTag() const = 0;
};

#endif

UncleanedState.h

#ifndef UNCLEANEDSTATE_H_
#define UNCLEANEDSTATE_H_

#include "ChickenState.h"
#include "Mamma.h"
#include "CleanedState.h"
#include <iostream>

class UncleanedState : public ChickenState {
private:
    Mamma* mamma;
    std::string tag = "Uncleaned";

public:
    UncleanedState(Mamma* ctx) : mamma(ctx) {}

    void wash(int period, int totalTime) override {
        std::cout << "[Uncleaned] Chicken is getting washed... please wait...\n";
        mamma->t.setTimeout([this]() {
            mamma->goToNextStateFromCallback();
        }, totalTime);
    }

    void goToNextState() override {
        mamma->isUncleanedStateDone = true;
        mamma->changeChickenState(std::make_unique<CleanedState>(mamma));
    }

    std::string getTag() const override { return tag; }
};

#endif

CleanedState.h

#ifndef CLEANEDSTATE_H_
#define CLEANEDSTATE_H_

#include "ChickenState.h"
#include "Mamma.h"
#include "MarinatedState.h"
#include <iostream>

class CleanedState : public ChickenState {
private:
    Mamma* mamma;
    std::string tag = "Cleaned";

public:
    CleanedState(Mamma* ctx) : mamma(ctx) {}

    void marinate(int period, int totalTime) override {
        std::cout << "[Cleaned] Chicken is getting marinated... please wait...\n";
        mamma->t.setTimeout([this]() {
            mamma->goToNextStateFromCallback();
        }, totalTime);
    }

    void goToNextState() override {
        mamma->isCleanedStateDone = true;
        mamma->changeChickenState(std::make_unique<MarinatedState>(mamma));
    }

    std::string getTag() const override { return tag; }
};

#endif

MarinatedState.h

#ifndef MARINATEDSTATE_H_
#define MARINATEDSTATE_H_

#include "ChickenState.h"
#include "Mamma.h"
#include "CookedState.h"
#include <iostream>

class MarinatedState : public ChickenState {
private:
    Mamma* mamma;
    std::string tag = "Marinated";

public:
    MarinatedState(Mamma* ctx) : mamma(ctx) {}

    void cook(int period, int totalTime) override {
        std::cout << "[Marinated] Chicken is getting cooked... please wait...\n";
        mamma->t.setTimeout([this]() {
            mamma->goToNextStateFromCallback();
        }, totalTime);
    }

    void goToNextState() override {
        mamma->isMarinatedStateDone = true;
        mamma->changeChickenState(std::make_unique<CookedState>(mamma));
    }

    std::string getTag() const override { return tag; }
};

#endif

CookedState.h

#ifndef COOKEDSTATE_H_
#define COOKEDSTATE_H_

#include "ChickenState.h"
#include "Mamma.h"
#include <iostream>

class CookedState : public ChickenState {
private:
    Mamma* mamma;
    std::string tag = "Cooked";

public:
    CookedState(Mamma* ctx) : mamma(ctx) {}

    void serve(int period, int totalTime) override {
        std::cout << "[Cooked] Chicken is ready! Enjoy the delicious Ajwaini Chicken!\n";
        mamma->isCookedStateDone = true;
        mamma->timerRunning = false; // Break the execution loop
    }

    void goToNextState() override {}
    std::string getTag() const override { return tag; }
};

#endif

Mamma.h

#ifndef MAMMA_H_
#define MAMMA_H_

#include <memory>
#include <atomic>
#include "Callback.h"
#include "ChickenState.h"
#include "timer.h"

class Mamma : public Callback {
private:
    std::unique_ptr<ChickenState> currentState;

public:
    Timer t;
    std::atomic<bool> timerRunning{true};

    // Flags tracking state milestones safely
    std::atomic<bool> isUncleanedStateDone{false};
    std::atomic<bool> isCleanedStateDone{false};
    std::atomic<bool> isMarinatedStateDone{false};
    std::atomic<bool> isCookedStateDone{false};

    Mamma();
    ~Mamma() override = default;

    void changeChickenState(std::unique_ptr<ChickenState> nextState);
    void startPreparation();
    void goToNextStateFromCallback() override;

    ChickenState* getCurrentState() { return currentState.get(); }
};

#endif

Mamma.cpp

#include "Mamma.h"
#include "UncleanedState.h"
#include "CleanedState.h"
#include "MarinatedState.h"
#include "CookedState.h"
#include <iostream>

Mamma::Mamma() {
    t.setCallback(this);
    // Initialize with the starting state
    currentState = std::make_unique<UncleanedState>(this);
}

void Mamma::changeChickenState(std::unique_ptr<ChickenState> nextState) {
    currentState = std::move(nextState);
}

void Mamma::startPreparation() {
    while (timerRunning) {
        if (!isUncleanedStateDone) {
            currentState->wash(1000, 1500);
        } else if (!isCleanedStateDone) {
            currentState->marinate(1000, 1500);
        } else if (!isMarinatedStateDone) {
            currentState->cook(200, 2000);
        } else if (!isCookedStateDone) {
            currentState->serve(200, 1000);
        }
    }
    std::cout << "Mamma - the cook is leaving the kitchen.\n";
}

void Mamma::goToNextStateFromCallback() {
    t.justStop();
    currentState->goToNextState();
}

Timer.h

#ifndef TIMER_H_
#define TIMER_H_

#include <thread>
#include <chrono>
#include <atomic>
#include "Callback.h"

class Timer {
private:
    Callback* cb = nullptr;
    std::atomic<bool> active{true};

public:
    Timer() = default;

    void setCallback(Callback* callback) {
        cb = callback;
    }

    void setTimeout(auto function, int delay) {
        active = true;
        std::thread t([this, function, delay]() {
            if (!active.load()) return;
            std::this_thread::sleep_for(std::chrono::milliseconds(delay));
            if (!active.load()) return;
            function();
        });
        t.join(); // Blocks parent execution sequentially per step
    }

    void stop() {
        if (cb) cb->goToNextStateFromCallback();
    }

    void justStop() {
        active = false;
    }
};

#endif

Main.cpp

//============================================================================
// Name        : Main.cpp
// Author      : Som
// Version     :
// Copyright   : som-itsolutions
// Description : Hello World in C++, Ansi-style
//============================================================================

#include "Mamma.h"

int main() {
    auto mamma = std::make_unique<Mamma>();
    mamma->startPreparation();
    return 0;
}

To compile the above code, we need to activate the -pthread option for the compiler and linker.

Enjoy...

Wednesday, May 4, 2022

The State Pattern in C++ using raw pointer...

Sunday, April 17, 2022

Magic of the weak_ptr to break the cyclic reference...

Tuesday, April 12, 2022

Tackling the circular dependency in C++...

Wednesday, March 30, 2022

Logic vs Imagination...

To start this topic, I can quote Einstein and many such great people to raise the standard. However, as I see myself just as a pure worker, the #karmyogi, for whom working with sweat and blood, having scars are real marks of a leader, i will tell you about how the fake world of fashionable leadership camouflage and stop the real imagination power of the real engineers to run their agenda and create a flock of sheep instead of a pride of lions in the tech world.

We should strive for

#passion…

not…

#fashion…

Please closely observe a few so-called highly paid, dashing personalities in various professions, like medicine, software consultancy, and see how they earn money by stopping others from imagining and asking them just to be satisfied with foolish logic.

I will give you an example.

When you attend a very important tech meeting in a big MNC, meeting, you will find some of the smartest people use their charisma to first dig out problems in the system.

There is a flaw in the design….

and then he will start drawing some esoteric diagrams describing the flaw.

and then the discussion continues for hours after hours, months after months.

new recruitment. new joiners. and then training them specifically on that flaw.

the hourly bill of the consultant will be rising

In #bharat, we say it like aapka meter charne laga

A new #gillbates is born.

On the contrary, Linus Torvalds sir will continue writing high-class code in his bath-rope.

there are few #fools like me who will adore Linus Torvalds sir maybe sometimes because of his such attire and sometimes maybe by remembering his own hostel days and training his son to use Linux

In the corporate world, the new Windows11 will be launched with a little bit of flavor of Linux in it

but don't try to add any extra xxx after the Linux used there

because #kids must be protected

too much xxx may damage their real #manhood

The first sign of a boy attaining manhood with nightfall happens through imagination, not logic..

So cut the crap from your kid's life

let him imagine and enjoy…

There is life beyond algorithms and logic...

Som's Tech World...