I have some interesting stories about how I lost my baby teeth. One time, I bit into the white part of a coconut, and my tooth got stuck and pulled out. On another occasion, I was biting down on a towel when one of my cousins snatched it away, causing me to lose a few more teeth. New teeth grew in, but probably in kindergarten, I lost a few more teeth, and the new ones that came in were not straight. Suddenly, I had crooked teeth, and two of my front teeth were severely crooked, which caused me a lot of issues. I was constantly cutting my lips and would get severe injuries from those cuts. As time went on, I got used to the cuts, and the number of cuts slowly decreased but never went to zero. Or maybe I just got used to it.

When I first noticed my crooked teeth, I always wanted to get them straightened, but I was a kid and didn't have the power to go to the dentist for that. I probably learned from my mom that there are ways to straighten them using some wire or something. I always dreamed of getting them straightened.

Fast forward to university life when I had money but was still not considering getting braces, probably due to the issue of it not being Halal. However, I saw Mufti Menk with braces and learned that if I'm not doing it just for cosmetic purposes, then it is not prohibited. Yet, I was still hesitant because it is mostly a lifelong commitment. As time passed, I began to notice more issues with my dental health, especially since I almost never used my front teeth. Thinking about my future old age, I started researching for months and finally decided to get braces.
I started searching for the best dental office around me, but at the time, I was living in Rupganj, Narayanganj near my campus 70% of the time and 30% in Dhaka with my family. However, searching online (hmm, that’s the only tool I have) and around Dhaka, close to my family home, I couldn’t find any dental office that had an orthodontic program. Also, in Narayanganj, there were none around me as well. So, searching online, I ended up choosing Promident Dental Clinic in Banani, which is easier to reach from my campus.

I went for my first appointment, and they told me to come back with an x-ray the next week, which I did. They took some measurements and asked me to come again the following week. In the next appointment, the doctor sat with me and mentioned that I might need to undergo tooth extraction to get things 100% straightened. However, I refused to go that route and chose to have nearly straightened teeth while keeping all my teeth intact. The doctor partially agreed and mentioned that we might need to extract in the middle of the treatment, but we most probably won't have to do that.

Regarding options, there were three: traditional braces, self-ligating braces, and Invisalign. I went with self-ligating braces, which would cost around 165K over the span of 1 and a half years. So finally, in mid-July'23, I got my braces on!

The first few weeks were very painful and uncomfortable, and I thought it would be a nightmare to endure this for the next 1.5 years! But as time went on, I started to feel normal, and only every 3 weeks would the braces be adjusted, which would bring back pain for a few days and then return to normal. In the beginning, I noticed a huge shift in my teeth. After about half a year, things were almost there.

And after one year passed, things were pretty good already. But it was only for the upper jaw; for the lower jaw, I got braces after about 4 months, and it took a while for those to get close to straight.

And finally, in February'25, I got my braces off!

Now I no longer have braces and have nearly straight teeth. However, I’ll have to wear a retainer every night for 2 more years to ensure they stay straight without returning to their original position.

My journey into Software Development began in January 2019 when I was a second-year student (12th grade) at Dania College. I already had some knowledge of HTML/CSS but had never coded because I was afraid of it. I was more interested in graphic design and animation, but unfortunately, my computer at the time couldn't run the programs needed for animation. Determined to do something, I decided to learn JavaScript as my first programming language.

Learning Phase

I researched different programming languages and chose JavaScript. I started learning it using various resources, and these were the most helpful:

• W3Schools [Interactive Learning Platform]

• Eloquent JavaScript [Book]

• Zero to Mastery [Video Tutorial]

I studied and practiced on W3Schools while at home and printed the book to take to college for practice during class breaks. I also worked on practice projects late at night. Five months into my journey, I learned and built various real-world projects. One of my instincts was to never rebuild the same project shown in a tutorial but to use the knowledge for other interesting and useful projects. For example, a classmate and I built a website for our Science Club at Dania College. Personally, I created a full-stack mini banking system for one of my initiatives, where I set up a mini bank for kids to help them learn about banking and saving small amounts.

Landing Job

While working on the project, I came across this news post and thought about building an app where people could scan and verify their own or others' NID. I searched for the API documentation and built the app, but while working with the sandbox API, I encountered many issues in the documentation and the API itself. I contacted them via the email provided on the website to report the issues and also shared a corrected version of the documentation. After much communication, I completed the project, but when I requested production access, I realized it was only available for government organizations, not developers. They appreciated my initiative and asked for my CV for future opportunities. Initially, I declined because I was still a student and couldn't take a job. However, I shared this portfolio site. A month later, they asked me to help with load testing some APIs they provided, so I assisted with that. They liked my work and referred me to a US company as a QA Engineer, working remotely. I researched what a remote job was and figured I could replace my current home tutoring work with it. After some thought, I accepted the offer, and in mid-September 2019, I joined. Initially, everything at the job was overwhelming, but I didn't give up and gave it my all, spending almost all my available time on the job. When I received my first salary of around 35K BDT (~400 USD), I couldn't believe it.

Growth at Job

Getting a job can be tough, but for me, it seemed easy. However, staying in the job was not as simple. Everything I encountered was new, but instead of losing hope, I took the time to learn. I didn't take weekends or time off for the first two years. Fortunately, the COVID-19 shutdown allowed me to dedicate even more time to work, spending 15-20 hours a day working and learning. I started taking on more responsibilities than I was assigned, which helped me grow and become a team player, leading to not just survival but also promotions! This approach of taking on more responsibilities has brought me to where I am today.

Job and Study

Until 2022, I didn't worry about my studies because, due to the COVID shutdown, there were no classes, and our High School Exam was canceled. We were all given an automatic pass based on our Junior School Exam. However, in late 2021, I had to choose between my job and my studies. I was unsure if it was possible to pursue both at the same time, so I did a lot of research and asked my colleagues and others I knew. If I did both, I would have to choose one as my main priority. I've always been focused on academics, but I didn't want to fall behind at work either. Initially, I decided to work part-time and focus more on my studies. But four years seemed like too long to invest in a degree, especially since I learned that a computer science degree might not offer much new knowledge. However, I didn't want to miss out on the university experience. So, I decided to stay full-time at my job and see if I could manage university at the same time. If not, I would switch to part-time work. The first two semesters were extremely challenging. To save time, I moved into the university hostel, even though I had never lived away from my family. I couldn't afford to spend 2-3 hours commuting. Imagine working late until 3 AM and then going to campus by 8 AM. It gradually became harder, but I started to adapt to this tough routine, hoping for a better future. Life is still hard, but instead of complaining, I just deal with it. I also wrote an article on how I manage both studying and a full-time job here.

Concluding

Reflecting on my journey into software development, it's clear that determination and adaptability have been crucial for me. From overcoming my initial fears of coding to getting a job and balancing work with studies, each step has been a learning experience. Embracing challenges and taking on responsibilities outside my comfort zone have helped me grow. As I continue to navigate the complexities of both my career and education, I stay committed to learning constantly.

Here is a quick summary of what the events that took place in this year!

• Saint Martin Tour: It was my first time visiting a beach and an island, and it was fantastic!

• Umrah: Alhamdulillah, I was able to complete my Umrah by the mercy of the Almighty.

• CodeSamurai’24: For the first time, I participated in a national hackathon and was part of the winning team, placing 9th.

• Promotion: I got promoted to the Staff Engineer role at my current workplace.

Saint Martin Tour

January’24 — A big thanks to my amazing university friends for organizing such a smooth and memorable tour. Initially, it was challenging to gather enough participants, but in the end, we had a group of 20 people, and everyone thoroughly enjoyed the experience.

We spent five days on the island, with each day bringing its own unique activities. From cycling and playing football to multiple barbecue parties, every moment was filled with fun and excitement. I missed out on a few activities because, once again, I couldn’t take a full vacation and had to spend some time working.

Despite that, the tour was absolutely fantastic and particularly special as it was my first trip with both my siblings and university friends.

Here is more on Saint Martin Island.

Umrah

March’24 — Following my "one international tour a year" schedule, I started exploring nearby Middle Eastern countries for my next trip. Initially, the United Arab Emirates and Saudi Arabia came to mind, but then I thought, why not do the Umrah? So, I booked the trip with a group of amazing elderly religious people. The Umrah was scheduled right in the middle of Ramadan, making it the best time for this spiritual journey.

Our flight had a transit at Kuwait Airport from Dhaka Airport, where we entered into the state of Ihram. It was an indescribable feeling! After a 3-hour layover at Kuwait Airport, we continued our journey to Jeddah. By around 2 PM local time, we landed at Jeddah Airport and completed the immigration process. From there, we began our journey to the holy city of Mecca by bus. Since we were fasting, and due to the time zone difference, it ended up being the longest fast any of us had experienced.

Once we reached our hotel in Mecca, we took a short rest and then broke our fast with Iftar. After the Isha prayer, we went to the Kaaba to perform Tawaf and Sa'ay. For the first time in my life, I shaved my head and exited the state of Ihram.

It was an awe-inspiring experience, seeing Muslims from all over the world and visiting all the sacred places. We spent the first week in Mecca, visiting every sacred site and mosque. The following week, we traveled to Medina and similarly visited all the sacred places and mosques there.

An interesting part of my trip was that I had to spend some time in Medina coding for the CodeSamurai’24 Hackathon. It felt surreal to be coding while in such a holy city, but that's how my life goes. The picture below was taken right in front of Al-Masjid an-Nabawi (the Prophet's Mosque).

CodeSamurai’24

December’23 - May’24 — It was the first hackathon I had ever participated in. I’m not much into competitions, but circumstances led me to join this one with my mates, Zahin Afsar and Suaeb Ahmed. We had zero expectations for the competition since all of us had full-time jobs and couldn’t take time off for a vacation.

After a disastrous performance in the mock preliminary round, we failed because our program couldn’t even execute properly. However, in the actual preliminary round, we managed to place 5th out of 400+ registered teams. From there, 91 teams were selected for the second phase (essentially the main phase) in March 2024.

Unfortunately, the second phase coincided with my Umrah schedule, which left me unable to contribute much during that stage. Nevertheless, we got selected for the final onsite phase, where we were tasked with enhancing what we had built in phase 2 and creating a mobile app.

We were lagging behind in phase 2, but somehow (well, not “somehow”—we worked incredibly hard during the final 24 hours!) we managed to make it to the winners' list with a rank of 9. The top 10 teams were honored as winners, and making it onto that list was an incredible feeling.

Learn more about CodeSamurai here: https://www.codesamuraibd.net/

Promotion

June’24 — I’ve been leading the engineering team for a while now, but my CEO encouraged me to further enhance my leadership skills and suggested transitioning to a Staff Engineer role. Initially, I was skeptical and felt unprepared for such a significant position, thinking I was too young for the role. Nevertheless, I decided to embrace the opportunity, knowing that my experience outweighed any doubts tied to my age.

Since then, I’ve been actively working on refining my leadership abilities and started following the principles outlined in the book How to Win Friends and Influence People. This journey has been both challenging and rewarding, pushing me to grow as a leader.

Concluding

In conclusion, the moments I’ve highlighted above were just a few standout occasions that I felt deserved their own mention, but so much more happened beyond these events. I made several transformative changes to my future plans—changes I could never have imagined before.

Amid all these personal milestones, my motherland, Bangladesh, witnessed a historic mass student uprising, which ultimately led to the toppling of the government. It was a year of profound personal and societal change, shaping both my perspective and the world around me.

Ensures a class has only one instance and provides a global point of access to it.

When to use: When exactly one instance of a class is needed to control the action.
Why to use: To prevent multiple instances of a class and provide a single point of access.

class Singleton {
    private static instance: Singleton;
    private constructor() {}
    static getInstance(): Singleton {
        if (!Singleton.instance) {
            Singleton.instance = new Singleton();
        }
        return Singleton.instance;
    }
}
const instance1 = Singleton.getInstance();
const instance2 = Singleton.getInstance();
console.log(instance1 === instance2); // true

2. Factory Pattern

Creates objects without specifying the exact class of object that will be created.

When to use: When the exact type of the object is determined at runtime.
Why to use: To encapsulate object creation.

interface Product {
    operation(): string;
}

class ConcreteProduct1 implements Product {
    operation(): string {
        return 'ConcreteProduct1';
    }
}

class ConcreteProduct2 implements Product {
    operation(): string {
        return 'ConcreteProduct2';
    }
}

class Creator {
    static factoryMethod(type: string): Product {
        if (type === '1') {
            return new ConcreteProduct1();
        } else {
            return new ConcreteProduct2();
        }
    }
}

const product1 = Creator.factoryMethod('1');
console.log(product1.operation()); // ConcreteProduct1

3. Abstract Factory Pattern

Provides an interface for creating families of related or dependent objects without specifying their concrete classes.

When to use: When families of related objects need to be created.
Why to use: To ensure consistency among products.

interface AbstractFactory {
    createProductA(): AbstractProductA;
    createProductB(): AbstractProductB;
}

class ConcreteFactory1 implements AbstractFactory {
    createProductA(): AbstractProductA {
        return new ProductA1();
    }
    createProductB(): AbstractProductB {
        return new ProductB1();
    }
}

interface AbstractProductA {
    usefulFunctionA(): string;
}

interface AbstractProductB {
    usefulFunctionB(): string;
}

class ProductA1 implements AbstractProductA {
    usefulFunctionA(): string {
        return 'The result of ProductA1';
    }
}

class ProductB1 implements AbstractProductB {
    usefulFunctionB(): string {
        return 'The result of ProductB1';
    }
}

const factory1 = new ConcreteFactory1();
const productA1 = factory1.createProductA();
const productB1 = factory1.createProductB();
console.log(productA1.usefulFunctionA()); // The result of ProductA1
console.log(productB1.usefulFunctionB()); // The result of ProductB1

4. Builder Pattern

Separates the construction of a complex object from its representation, allowing the same construction process to create various representations.

When to use: When an object needs to be created with various configurations.
Why to use: To construct a complex object step by step.

class Product {
    public parts: string[] = [];
    public listParts(): void {
        console.log(`Product parts: ${this.parts.join(', ')}`);
    }
}

class Builder {
    private product: Product;
    constructor() {
        this.product = new Product();
    }
    public reset(): void {
        this.product = new Product();
    }
    public addPartA(): void {
        this.product.parts.push('PartA');
    }
    public addPartB(): void {
        this.product.parts.push('PartB');
    }
    public getProduct(): Product {
        return this.product;
    }
}

const builder = new Builder();
builder.addPartA();
builder.addPartB();
const product = builder.getProduct();
product.listParts(); // Product parts: PartA, PartB

5. Prototype Pattern

Creates new objects by copying an existing object, known as the prototype.

When to use: When the cost of creating a new object is expensive.
Why to use: To reduce the cost of creating objects.

class Prototype {
    public primitive: any;
    public component: object;
    public circularReference: ComponentWithBackReference;

    public clone(): this {
        const clone = Object.create(this);
        clone.component = Object.create(this.component);
        clone.circularReference = {
            ...this.circularReference,
            prototype: { ...this }
        };
        return clone;
    }
}

class ComponentWithBackReference {
    public prototype;
    constructor(prototype: Prototype) {
        this.prototype = prototype;
    }
}

const prototype = new Prototype();
prototype.primitive = 245;
prototype.component = new Date();
prototype.circularReference = new ComponentWithBackReference(prototype);

const clone = prototype.clone();
console.log(clone.primitive); // 245
console.log(clone.component); // Date object
console.log(clone.circularReference.prototype === prototype); // false

6. Adapter Pattern

Allows incompatible interfaces to work together.

When to use: When you want to use an existing class, but its interface is not compatible with the rest of your code.
Why to use: To enable collaboration between classes with incompatible interfaces.

class Target {
    request(): string {
        return 'Target: The default target\'s behavior.';
    }
}

class Adaptee {
    specificRequest(): string {
        return '.eetpadA eht fo roivaheb laicepS';
    }
}

class Adapter extends Target {
    private adaptee: Adaptee;

    constructor(adaptee: Adaptee) {
        super();
        this.adaptee = adaptee;
    }

    request(): string {
        return `Adapter: (TRANSLATED) ${this.adaptee.specificRequest().split('').reverse().join('')}`;
    }
}

const adaptee = new Adaptee();
const adapter = new Adapter(adaptee);
console.log(adapter.request()); // Adapter: (TRANSLATED) Special behavior of the Adaptee.

7. Bridge Pattern

Decouples an abstraction from its implementation so that the two can vary independently.

When to use: When you want to separate a monolithic class into several class hierarchies.
Why to use: To avoid a permanent binding between an abstraction and its implementation.

interface Implementation {
    operationImplementation(): string;
}

class ConcreteImplementationA implements Implementation {
    operationImplementation(): string {
        return 'ConcreteImplementationA: Here\'s the result on the platform A.';
    }
}

class ConcreteImplementationB implements Implementation {
    operationImplementation(): string {
        return 'ConcreteImplementationB: Here\'s the result on the platform B.';
    }
}

class Abstraction {
    protected implementation: Implementation;

    constructor(implementation: Implementation) {
        this.implementation = implementation;
    }

    operation(): string {
        return `Abstraction: Base operation with:\n${this.implementation.operationImplementation()}`;
    }
}

const implementationA = new ConcreteImplementationA();
let abstraction = new Abstraction(implementationA);
console.log(abstraction.operation()); // Abstraction: Base operation with: ConcreteImplementationA: Here's the result on the platform A.

const implementationB = new ConcreteImplementationB();
abstraction = new Abstraction(implementationB);
console.log(abstraction.operation()); // Abstraction: Base operation with: ConcreteImplementationB: Here's the result on the platform B.

8. Composite Pattern

Composes objects into tree structures to represent part-whole hierarchies.

When to use: When you need to treat individual objects and compositions of objects uniformly.
Why to use: To simplify client code that deals with complex tree structures.

interface Component {
    operation(): string;
}

class Leaf implements Component {
    operation(): string {
        return 'Leaf';
    }
}

class Composite implements Component {
    private children: Component[] = [];

    add(component: Component): void {
        this.children.push(component);
    }

    remove(component: Component): void {
        const index = this.children.indexOf(component);
        this.children.splice(index, 1);
    }

    operation(): string {
        const results = [];
        for (const child of this.children) {
            results.push(child.operation());
        }
        return `Branch(${results.join('+')})`;
    }
}

const leaf = new Leaf();
const tree = new Composite();
const branch1 = new Composite();
const branch2 = new Composite();

branch1.add(leaf);
branch2.add(leaf);
tree.add(branch1);
tree.add(branch2);

console.log(tree.operation()); // Branch(Branch(Leaf)+Branch(Leaf))

9. Decorator Pattern

Adds additional responsibilities to an object dynamically.

When to use: When you need to add responsibilities to objects dynamically.
Why to use: To avoid subclassing for functionalities.

interface Component {
    operation(): string;
}

class ConcreteComponent implements Component {
    operation(): string {
        return 'ConcreteComponent';
    }
}

class Decorator implements Component {
    protected component: Component;

    constructor(component: Component) {
        this.component = component;
    }

    operation(): string {
        return this.component.operation();
    }
}

class ConcreteDecoratorA extends Decorator {
    operation(): string {
        return `ConcreteDecoratorA(${super.operation()})`;
    }
}

class ConcreteDecoratorB extends Decorator {
    operation(): string {
        return `ConcreteDecoratorB(${super.operation()})`;
    }


}

const simple = new ConcreteComponent();
console.log(simple.operation()); // ConcreteComponent

const decorator1 = new ConcreteDecoratorA(simple);
const decorator2 = new ConcreteDecoratorB(decorator1);
console.log(decorator2.operation()); // ConcreteDecoratorB(ConcreteDecoratorA(ConcreteComponent))

10. Facade Pattern

Provides a simplified interface to a complex subsystem.

When to use: When you need to provide a simple interface to a complex subsystem.
Why to use: To hide the complexities of the system.

class Subsystem1 {
    operation1(): string {
        return 'Subsystem1: Ready!';
    }
    operationN(): string {
        return 'Subsystem1: Go!';
    }
}

class Subsystem2 {
    operation1(): string {
        return 'Subsystem2: Get ready!';
    }
    operationZ(): string {
        return 'Subsystem2: Fire!';
    }
}

class Facade {
    protected subsystem1: Subsystem1;
    protected subsystem2: Subsystem2;

    constructor(subsystem1: Subsystem1, subsystem2: Subsystem2) {
        this.subsystem1 = subsystem1;
        this.subsystem2 = subsystem2;
    }

    operation(): string {
        let result = 'Facade initializes subsystems:\n';
        result += this.subsystem1.operation1() + '\n';
        result += this.subsystem2.operation1() + '\n';
        result += 'Facade orders subsystems to perform the action:\n';
        result += this.subsystem1.operationN() + '\n';
        result += this.subsystem2.operationZ();
        return result;
    }
}

const subsystem1 = new Subsystem1();
const subsystem2 = new Subsystem2();
const facade = new Facade(subsystem1, subsystem2);
console.log(facade.operation());

11. Flyweight Pattern

Uses sharing to support large numbers of fine-grained objects efficiently.

When to use: When a large number of similar objects are needed.
Why to use: To reduce memory consumption.

class Flyweight {
    private sharedState: any;

    constructor(sharedState: any) {
        this.sharedState = sharedState;
    }

    operation(uniqueState: any): void {
        const s = JSON.stringify(this.sharedState);
        const u = JSON.stringify(uniqueState);
        console.log(`Flyweight: Displaying shared (${s}) and unique (${u}) state.`);
    }
}

class FlyweightFactory {
    private flyweights: { [key: string]: Flyweight } = {};

    constructor(initialFlyweights: string[][]) {
        for (const state of initialFlyweights) {
            this.flyweights[this.getKey(state)] = new Flyweight(state);
        }
    }

    private getKey(state: string[]): string {
        return state.join('_');
    }

    getFlyweight(sharedState: string[]): Flyweight {
        const key = this.getKey(sharedState);

        if (!(key in this.flyweights)) {
            console.log('FlyweightFactory: Can\'t find a flyweight, creating new one.');
            this.flyweights[key] = new Flyweight(sharedState);
        } else {
            console.log('FlyweightFactory: Reusing existing flyweight.');
        }

        return this.flyweights[key];
    }
}

const factory = new FlyweightFactory([
    ['Chevrolet', 'Camaro2018', 'pink'],
    ['Mercedes Benz', 'C300', 'black'],
    ['Mercedes Benz', 'C500', 'red'],
]);

const flyweight1 = factory.getFlyweight(['Chevrolet', 'Camaro2018', 'pink']);
flyweight1.operation(['John Doe', 'CL234IR']);
const flyweight2 = factory.getFlyweight(['Mercedes Benz', 'C300', 'black']);
flyweight2.operation(['Jane Doe', 'CL234IR']);

12. Proxy Pattern

Provides a surrogate or placeholder for another object to control access to it.

When to use: When you need a more versatile or sophisticated reference to an object.
Why to use: To control access and add additional functionality.

interface Subject {
    request(): void;
}

class RealSubject implements Subject {
    request(): void {
        console.log('RealSubject: Handling request.');
    }
}

class Proxy implements Subject {
    private realSubject: RealSubject;

    constructor(realSubject: RealSubject) {
        this.realSubject = realSubject;
    }

    request(): void {
        if (this.checkAccess()) {
            this.realSubject.request();
            this.logAccess();
        }
    }

    private checkAccess(): boolean {
        console.log('Proxy: Checking access prior to firing a real request.');
        return true;
    }

    private logAccess(): void {
        console.log('Proxy: Logging the time of request.');
    }
}

const realSubject = new RealSubject();
const proxy = new Proxy(realSubject);
proxy.request(); // Proxy: Checking access prior to firing a real request. RealSubject: Handling request. Proxy: Logging the time of request.

13. Chain of Responsibility Pattern

Passes a request along a chain of handlers.

When to use: When more than one object can handle a request.
Why to use: To decouple sender and receiver.

interface Handler {
    setNext(handler: Handler): Handler;
    handle(request: string): string;
}

abstract class AbstractHandler implements Handler {
    private nextHandler: Handler;

    public setNext(handler: Handler): Handler {
        this.nextHandler = handler;
        return handler;
    }

    public handle(request: string): string {
        if (this.nextHandler) {
            return this.nextHandler.handle(request);
        }
        return null;
    }
}

class MonkeyHandler extends AbstractHandler {
    public handle(request: string): string {
        if (request === 'Banana') {
            return `Monkey: I'll eat the ${request}.`;
        }
        return super.handle(request);
    }
}

class SquirrelHandler extends AbstractHandler {
    public handle(request: string): string {
        if (request === 'Nut') {
            return `Squirrel: I'll eat the ${request}.`;
        }
        return super.handle(request);
    }
}

const monkey = new MonkeyHandler();
const squirrel = new SquirrelHandler();

monkey.setNext(squirrel);

console.log(monkey.handle('Banana')); // Monkey: I'll eat the Banana.
console.log(monkey.handle('Nut')); // Squirrel: I'll eat the Nut.

14. Command Pattern

Turns a request into a stand-alone object that contains all information about the request.

When to use: When you want to parameterize objects with operations.
Why to use: To encapsulate requests as objects.

interface Command {
    execute(): void;
}

class SimpleCommand implements Command {
    private payload: string;

    constructor(payload: string) {
        this.payload = payload;
    }

    public execute(): void {
        console.log(`SimpleCommand: See, I can do simple things like printing (${this.payload})`);
    }
}

class ComplexCommand implements Command {
    private receiver: Receiver;
    private a: string;
    private b: string;

    constructor(receiver: Receiver, a: string, b: string) {
        this.receiver = receiver;
        this.a = a;
        this.b = b;
    }

    public execute(): void {
        console.log('ComplexCommand: Complex stuff should be done by a receiver object.');
        this.receiver.doSomething(this.a);
        this.receiver.doSomethingElse(this.b);
    }
}

class Receiver {
    public doSomething(a: string): void {
        console.log(`Receiver: Working on (${a}).`);
    }

    public doSomethingElse(b: string): void {
        console.log(`Receiver: Also working on (${b}).`);
    }
}

class Invoker {
    private onStart: Command;
    private onFinish: Command;

    public setOnStart(command: Command): void {
        this.onStart = command;
    }

    public setOnFinish(command: Command): void {
        this.onFinish = command;
    }

    public doSomethingImportant(): void {
        if (this.onStart) {
            this.onStart.execute();
        }

        if (this.onFinish) {
            this.onFinish.execute();
        }
    }
}

const invoker = new Invoker();
invoker.setOnStart(new SimpleCommand('Say Hi!'));
const receiver = new Receiver();
invoker.setOnFinish(new ComplexCommand(receiver, 'Send email', 'Save report'));

invoker.doSomethingImportant();

15. Iterator Pattern

Provides a way to access elements of a collection sequentially without exposing its underlying representation.

When to use: When you need to traverse a collection without exposing its implementation.
Why to use: To provide a standard way to iterate over a collection.

interface Iterator<T> {
    next(): T;
    hasNext(): boolean;
}

interface Aggregator {
    getIterator(): Iterator<string>;
}

class ConcreteIterator implements Iterator<string> {
    private collection: ConcreteCollection;
    private position: number = 0;

    constructor(collection: ConcreteCollection) {
        this.collection = collection;
    }

    public next(): string {
        const item = this.collection.items[this.position];
        this.position += 1;
        return item;
    }

    public hasNext(): boolean {
        return this.position < this.collection.items.length;
    }
}

class ConcreteCollection implements Aggregator {
    public items: string[] = [];

    public getIterator(): Iterator<string> {
        return new ConcreteIterator(this);
    }
}

const collection = new ConcreteCollection();
collection.items.push('Item 1');
collection.items.push('Item 2');
collection.items.push('Item 3');

const iterator = collection.get

Iterator();
while (iterator.hasNext()) {
    console.log(iterator.next());
}

16. Mediator Pattern

Defines an object that encapsulates how a set of objects interact.

When to use: When you need to reduce the complexity of communication between objects.
Why to use: To promote loose coupling by keeping objects from referring to each other explicitly.

interface Mediator {
    notify(sender: object, event: string): void;
}

class ConcreteMediator implements Mediator {
    private component1: Component1;
    private component2: Component2;

    constructor(c1: Component1, c2: Component2) {
        this.component1 = c1;
        this.component1.setMediator(this);
        this.component2 = c2;
        this.component2.setMediator(this);
    }

    public notify(sender: object, event: string): void {
        if (event === 'A') {
            console.log('Mediator reacts on A and triggers following operations:');
            this.component2.doC();
        }

        if (event === 'D') {
            console.log('Mediator reacts on D and triggers following operations:');
            this.component1.doB();
            this.component2.doC();
        }
    }
}

class BaseComponent {
    protected mediator: Mediator;

    public setMediator(mediator: Mediator): void {
        this.mediator = mediator;
    }
}

class Component1 extends BaseComponent {
    public doA(): void {
        console.log('Component 1 does A.');
        this.mediator.notify(this, 'A');
    }

    public doB(): void {
        console.log('Component 1 does B.');
        this.mediator.notify(this, 'B');
    }
}

class Component2 extends BaseComponent {
    public doC(): void {
        console.log('Component 2 does C.');
        this.mediator.notify(this, 'C');
    }

    public doD(): void {
        console.log('Component 2 does D.');
        this.mediator.notify(this, 'D');
    }
}

const c1 = new Component1();
const c2 = new Component2();
const mediator = new ConcreteMediator(c1, c2);

c1.doA();
c2.doD();

17. Memento Pattern

Captures and externalizes an object's internal state without violating encapsulation, so the object can be restored to this state later.

When to use: When you need to restore an object to a previous state.
Why to use: To provide the ability to restore an object to its previous state.

class Memento {
    private state: string;

    constructor(state: string) {
        this.state = state;
    }

    public getState(): string {
        return this.state;
    }
}

class Originator {
    private state: string;

    public setState(state: string): void {
        console.log(`Originator: Setting state to ${state}`);
        this.state = state;
    }

    public save(): Memento {
        return new Memento(this.state);
    }

    public restore(memento: Memento): void {
        this.state = memento.getState();
        console.log(`Originator: State after restoring from Memento: ${this.state}`);
    }
}

class Caretaker {
    private mementos: Memento[] = [];
    private originator: Originator;

    constructor(originator: Originator) {
        this.originator = originator;
    }

    public backup(): void {
        console.log('Caretaker: Saving Originator\'s state...');
        this.mementos.push(this.originator.save());
    }

    public undo(): void {
        if (!this.mementos.length) {
            return;
        }
        const memento = this.mementos.pop();
        console.log('Caretaker: Restoring state to:', memento.getState());
        this.originator.restore(memento);
    }
}

const originator = new Originator();
const caretaker = new Caretaker(originator);

originator.setState('State1');
caretaker.backup();
originator.setState('State2');
caretaker.backup();
originator.setState('State3');

caretaker.undo(); // Caretaker: Restoring state to: State2
caretaker.undo(); // Caretaker: Restoring state to: State1

18. Observer Pattern

Defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically.

When to use: When you need many other objects to receive an update when another object changes.
Why to use: To allow a single object to notify multiple other objects about changes in its state.

interface Observer {
    update(subject: Subject): void;
}

class ConcreteObserverA implements Observer {
    public update(subject: Subject): void {
        if (subject.state < 3) {
            console.log('ConcreteObserverA: Reacted to the event.');
        }
    }
}

class ConcreteObserverB implements Observer {
    public update(subject: Subject): void {
        if (subject.state === 0 || subject.state >= 2) {
            console.log('ConcreteObserverB: Reacted to the event.');
        }
    }
}

class Subject {
    public state: number;
    private observers: Observer[] = [];

    public attach(observer: Observer): void {
        const isExist = this.observers.includes(observer);
        if (isExist) {
            return console.log('Subject: Observer has been attached already.');
        }
        this.observers.push(observer);
    }

    public detach(observer: Observer): void {
        const observerIndex = this.observers.indexOf(observer);
        if (observerIndex === -1) {
            return console.log('Subject: Nonexistent observer.');
        }
        this.observers.splice(observerIndex, 1);
    }

    public notify(): void {
        console.log('Subject: Notifying observers...');
        for (const observer of this.observers) {
            observer.update(this);
        }
    }

    public someBusinessLogic(): void {
        console.log('Subject: I\'m doing something important.');
        this.state = Math.floor(Math.random() * 10);
        console.log(`Subject: My state has just changed to: ${this.state}`);
        this.notify();
    }
}

const subject = new Subject();

const observer1 = new ConcreteObserverA();
subject.attach(observer1);

const observer2 = new ConcreteObserverB();
subject.attach(observer2);

subject.someBusinessLogic();
subject.someBusinessLogic();

19. State Pattern

Allows an object to alter its behavior when its internal state changes. The object will appear to change its class.

When to use: When an object must change its behavior at runtime depending on its state.
Why to use: To simplify state-specific behavior and transitions.

class Context {
    private state: State;

    constructor(state: State) {
        this.transitionTo(state);
    }

    public transitionTo(state: State): void {
        console.log(`Context: Transition to ${(<any>state).constructor.name}.`);
        this.state = state;
        this.state.setContext(this);
    }

    public request1(): void {
        this.state.handle1();
    }

    public request2(): void {
        this.state.handle2();
    }
}

abstract class State {
    protected context: Context;

    public setContext(context: Context) {
        this.context = context;
    }

    public abstract handle1(): void;
    public abstract handle2(): void;
}

class ConcreteStateA extends State {
    public handle1(): void {
        console.log('ConcreteStateA handles request1.');
        console.log('ConcreteStateA wants to change the state of the context.');
        this.context.transitionTo(new ConcreteStateB());
    }

    public handle2(): void {
        console.log('ConcreteStateA handles request2.');
    }
}

class ConcreteStateB extends State {
    public handle1(): void {
        console.log('ConcreteStateB handles request1.');
    }

    public handle2(): void {
        console.log('ConcreteStateB handles request2.');
        console.log('ConcreteStateB wants to change the state of the context.');
        this.context.transitionTo(new ConcreteStateA());
    }
}

const context = new Context(new ConcreteStateA());
context.request1();
context.request2();

20. Strategy Pattern

Defines a family of algorithms, encapsulates each one, and makes them interchangeable.

When to use: When you have multiple algorithms for a specific task and you want to switch between them at runtime.
Why to use: To choose the appropriate algorithm at runtime.

interface Strategy {
    doAlgorithm(data: string[]): string[];
}

class ConcreteStrategyA implements Strategy {
    public doAlgorithm(data: string[]): string[] {
        return data.sort();
    }
}

class ConcreteStrategyB implements Strategy {
    public doAlgorithm(data: string[]): string[] {
        return data.reverse();
    }
}

class Context {
    private strategy: Strategy;

    constructor(strategy: Strategy) {
        this.strategy = strategy;
    }

    public setStrategy(strategy: Strategy) {
        this.strategy = strategy;
    }

    public doSomeBusinessLogic(): void {
        const result = this.strategy.doAlgorithm(['a', 'b', 'c', 'd', 'e']);
        console.log(result.join(','));
    }
}

const context = new Context(new ConcreteStrategyA());
context.doSomeBusinessLogic(); // a,b,c,d,e

context.setStrategy(new ConcreteStrategyB());
context.doSomeBusinessLogic(); // e,d,c,b,a

21. Template Method Pattern

Defines the skeleton of an algorithm in a method, deferring some steps to subclasses.

When to use: When you want to let subclasses redefine certain steps of an algorithm without changing its structure

.
Why to use: To prevent code duplication and ensure the algorithm's structure stays unchanged.

abstract class AbstractClass {
    public templateMethod(): void {
        this.baseOperation1();
        this.requiredOperations1();
        this.baseOperation2();
        this.hook1();
        this.requiredOperations2();
        this.baseOperation3();
        this.hook2();
    }

    protected baseOperation1(): void {
        console.log('AbstractClass says: I am doing the bulk of the work');
    }

    protected baseOperation2(): void {
        console.log('AbstractClass says: But I let subclasses override some operations');
    }

    protected baseOperation3(): void {
        console.log('AbstractClass says: But I am doing the bulk of the work anyway');
    }

    protected abstract requiredOperations1(): void;
    protected abstract requiredOperations2(): void;

    protected hook1(): void { }
    protected hook2(): void { }
}

class ConcreteClass1 extends AbstractClass {
    protected requiredOperations1(): void {
        console.log('ConcreteClass1 says: Implemented Operation1');
    }

    protected requiredOperations2(): void {
        console.log('ConcreteClass1 says: Implemented Operation2');
    }
}

class ConcreteClass2 extends AbstractClass {
    protected requiredOperations1(): void {
        console.log('ConcreteClass2 says: Implemented Operation1');
    }

    protected requiredOperations2(): void {
        console.log('ConcreteClass2 says: Implemented Operation2');
    }

    protected hook1(): void {
        console.log('ConcreteClass2 says: Overridden Hook1');
    }
}

const concreteClass1 = new ConcreteClass1();
concreteClass1.templateMethod();

const concreteClass2 = new ConcreteClass2();
concreteClass2.templateMethod();

22. Visitor Pattern

Lets you separate algorithms from the objects on which they operate.

When to use: When you need to perform operations across a heterogeneous collection of objects.
Why to use: To avoid polluting object classes with unrelated behaviors.

interface Visitor {
    visitConcreteComponentA(element: ConcreteComponentA): void;
    visitConcreteComponentB(element: ConcreteComponentB): void;
}

class ConcreteVisitor1 implements Visitor {
    public visitConcreteComponentA(element: ConcreteComponentA): void {
        console.log(`${element.exclusiveMethodOfConcreteComponentA()} + ConcreteVisitor1`);
    }

    public visitConcreteComponentB(element: ConcreteComponentB): void {
        console.log(`${element.specialMethodOfConcreteComponentB()} + ConcreteVisitor1`);
    }
}

class ConcreteVisitor2 implements Visitor {
    public visitConcreteComponentA(element: ConcreteComponentA): void {
        console.log(`${element.exclusiveMethodOfConcreteComponentA()} + ConcreteVisitor2`);
    }

    public visitConcreteComponentB(element: ConcreteComponentB): void {
        console.log(`${element.specialMethodOfConcreteComponentB()} + ConcreteVisitor2`);
    }
}

interface Component {
    accept(visitor: Visitor): void;
}

class ConcreteComponentA implements Component {
    public accept(visitor: Visitor): void {
        visitor.visitConcreteComponentA(this);
    }

    public exclusiveMethodOfConcreteComponentA(): string {
        return 'A';
    }
}

class ConcreteComponentB implements Component {
    public accept(visitor: Visitor): void {
        visitor.visitConcreteComponentB(this);
    }

    public specialMethodOfConcreteComponentB(): string {
        return 'B';
    }
}

const components = [new ConcreteComponentA(), new ConcreteComponentB()];

console.log('The client code works with all visitors via the base Visitor interface:');
const visitor1 = new ConcreteVisitor1();
for (const component of components) {
    component.accept(visitor1);
}

console.log('It allows the same client code to work with different types of visitors:');
const visitor2 = new ConcreteVisitor2();
for (const component of components) {
    component.accept(visitor2);
}

Decision

I’ve been working full-time even before I enrolled for a bachelor’s degree so I was a little skeptical whether I can manage both. But I decided to give it a try anyway and go part-time at work if I can’t manage both. I’m glad I did because I didn’t want to miss out on the experience of studying at a university.

Is it possible?

It is certainly possible just a little hard to do well at both. I chose to prioritize my work over my study. Luckily my work is related to my study so most core courses are easy for me to get good grades without needing to study. On non-core courses, I just attend classes that are enough to pass the exam.

Schedule

The schedule I follow is tight but not crazy. I attend classes during the day time and work at night. I also try to get some work or sleep done during class breaks and/or class time. 😀

• 08:00 AM — Wake up
• 08:00 AM — Get ready, breakfast, etc.
• 09:00 AM — Classes
• 12:30 PM — Lunch + Work
• 02:00 PM — Classes
• 05:00 PM — Break
• 06:00 PM — Work
• 02:00 AM — Sleep

Takeaways

• Use time wisely
• Make use of class breaks

The Don’ts

• Don’t waste time
• Don’t procrastinate
• Don’t skip classes
• Don’t skip work

Study

You don’t have to study every day to do well at university but make sure you are attending classes and doing assignments and projects as these can make a big difference in your grade. I usually study on weekends if I think I need to for a particular course to get a passing grade. So a few things to keep in mind:

Takeaways

• Attend classes
• Do assignments and projects
• Study on weekends

Work

My main work schedule is from afternoon to midnight but I work throughout the day whenever I get a chance to keep ahead of my work schedule so that I can sleep early and get enough rest otherwise I’ll have to sleep during class. At work, most of my time is spent on communicating requirements, learning new technologies, coding, and screaming when I can get out of a bug 😂.

Offloading Things

I try my best to offload or remove things that don’t need to be done by me or don’t align with my goals. For example, I don’t eat food at all to save time just kidding I just don’t do things that are not a must.

Social Life

You may wonder after all of this I don’t have any time left for social life. Well, I don’t have much time every day but I do have time on weekends and I try my best to communicate with classmates on social media, spend time with family and friends, and go out on weekends. So I don’t feel like I’m missing out on anything. And yeah it makes my weekends the busiest days of the week.

Conclusion

I just shared my experience, it doesn’t mean you have to do the same. But I must say that just go above and beyond your limit, you don’t even know what you can do. And don’t forget to have fun along the way. 😊

Here are some basic tips to begin typing fast:

• Learn to use all 10 fingers while typing. (this is called touch typing)

• Use a better keyboard. (mechanical keyboards are preferable)

• Practice, practice, practice.

Touch Typing

If you haven’t learn touch typing yet or you know but doesn’t feel comfortable with it, I know the feeling it is hard to get to start feeling comfortable unless you get out of your comfort zone and start practicing. I have been there and I know how it feels but you will eventually start feeling comfortable after few weeks of practice.

Here are some resources to learn touch typing:

• Typing Club

• Rapid Typing

• Keybr

You can try them all and see which one works best for you. I personally like Rapid Typing because it has a lot of lessons and it is free.

Keyboard

Keyboard does affect your typing speed a bit. If you are a student, programmer, gamer or anyone who types a lot, I would recommend you to get a mechanical keyboard because they are more compfortable and durable.

Here are some mechanical keyboards that I loved using:

• Keychron K2 Pro

• Keychron K2

• Keychron K6

• RK Royal Kludge RK84

I personally like simpler design and smaller keyboard as I can carry them in my backpack, I use Keychron K2 for that reason. but you can choose any keyboard that you like.

Practice

Practice is the key to building muscle memory and getting comfortable and fast at typing. You don’t have to practice for hours, just 5–10 minutes a day is enough. You can practice while chatting with your friends, writing for work/school or anything that involves typing.

Here are some resources to practice typing:

• Monkeytype

• Typing.com

Monkeytype is my favorite typing practice website because it is simple and has very modern design. You can also practice typing code with it.

Conclusion

I’m 100% sure that if you start typing faster it will make you more productive personal overall. So why not plan and begin practice typing from today?

Remove Distraction

Distraction is something that breaks your focus, so it’s important to remove distractions. Here are some tools and tips to help you remove distraction.

Tools

• News Feed Eradicator — Browser Extension
• ESUIT — Browser Extension
• Digital Wellbeing — Android
• Screen Time — iOS

Use News Feed Eradicator to remove the news feed from Facebook. This will help you focus on the things that matter. Digital Wellbeing/Screen Time is a tool that helps you monitor your phone usage. It will help you see how much time you spend on your phone and how much time you spend on each app. This will help you see how much time you spend on social media and other distractions. Also using Digital Wellbeing you can turn on focus mode where certain apps will be blocked for a certain amount of time.

The do’s and don’ts

The don’ts

• Don’t play videos on Facebook because the algorithm is designed to keep you on the app longer and play more videos.
• Don’t use the native Facebook app but the web version (facebook.com) if you really need to use Facebook app then keep notifications off.

The Do’s

• Prefer to use a single social media platform.
• Keep your phone away from you when you are working on things that matter.
• Set a time limit for social media.

Focus on one thing at a time

Multitasking seems very productive but it’s not. But from my experience finishing one thing at a time then moving to the next thing is more productive. Here are some tips to help you focus on one thing at a time.

The do’s and don’ts

The don’ts

• Don’t jump from one task to another unless it’s an emergency.

The Do’s

• Focus on one thing at a time.
• Set a timer for 25 minutes and work on one thing for 25 minutes and then take a 5 minute break.
• Use the Pomodoro technique.

In conclusion

Removing distractions and staying focused is essential for achieving success in today’s fast-paced world. The tips I shared in this article might be helpful for you with some tweaks based on your preferences.