DEV Community: Saheed hussain

Simply Explained : Top 5 Design Patterns

Saheed hussain — Tue, 06 Jun 2023 04:08:30 +0000

Introduction
Design patterns are reusable solutions to common programming problems. They provide proven approaches to solve recurring design challenges and promote code reuse, maintainability, and flexibility. In this blog, we will explore three popular design patterns, discussing their pros, cons, and providing code examples for better understanding.

1. Singleton Pattern:
The Singleton pattern ensures that a class has only one instance and provides a global point of access to it.

Pros:

Allows a single instance of a class to be shared across the application.
Provides a global access point, making it easy to use and manage the instance.
Lazy initialization allows the instance to be created when needed.

Cons:

Can introduce tight coupling and make unit testing difficult.
Not suitable for scenarios where multiple instances of a class are required.

Code Example:

public class Singleton {
    private static Singleton instance;

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

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

2. Factory Pattern:
The Factory pattern provides an interface for creating objects, but delegates the responsibility of instantiation to subclasses.

Pros:

Encapsulates object creation, making it easier to manage and maintain.
Provides a flexible way to create objects without tightly coupling the client code to concrete classes.
Supports adding new product variants without modifying existing client code.

Cons:

Requires the creation of additional classes, which can increase code complexity.
May lead to a proliferation of factory classes if used excessively.

Code Example:

public interface Product {
    void doSomething();
}

public class ConcreteProduct1 implements Product {
    @Override
    public void doSomething() {
        // Implementation of doSomething method
    }
}

public class ConcreteProduct2 implements Product {
    @Override
    public void doSomething() {
        // Implementation of doSomething method
    }
}

public class ProductFactory {
    public Product createProduct(String type) {
       if (type.equalsIgnoreCase("Type1")) {
           return new ConcreteProduct1();
         } else if (type.equalsIgnoreCase("motorcycle")) {
            return new ConcreteProduct2();
        }
        throw new IllegalArgumentException("Invalid type: " + type);
    }
}

3. Observer Pattern:
The Observer pattern establishes a one-to-many relationship between objects, so that when one object changes its state, all its dependents are notified and updated automatically. Its like a subscription to a newspaper or a magazine where all the subscribers are notified with the new version of the newspaper or magazine.

Pros:

Promotes loose coupling between objects, as the subject and observers interact through interfaces.
Supports the principle of open-closed design, allowing for easy addition or removal of observers.
Provides a clear separation between the subject and its observers, making the code more modular.

Cons:

Care must be taken to prevent memory leaks or excessive updates if not implemented carefully.
Overuse of the Observer pattern can lead to complexities and performance issues.

Code Example:

public interface Observer {
    void update();
}

public class ConcreteObserver implements Observer {
    @Override
    public void update() {
        // Update logic
    }
}

public interface Subject {
    void attach(Observer observer);
    void detach(Observer observer);
    void notifyObservers();
}

public class ConcreteSubject implements Subject {
    private List<Observer> observers = new ArrayList<>();

    @Override
    public void attach(Observer observer) {
        observers.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        observers.remove(observer);
    }

    @Override
    public void notifyObservers() {
        for (Observer observer : observers) {
            observer.update();
        }
    }
}

4. Decorator Pattern:
The Decorator pattern allows for adding behavior to an object dynamically by wrapping it with one or more decorator objects.

Pros:

Provides a flexible alternative to subclassing for extending functionality.
Allows for adding or removing responsibilities at runtime.
Enhances the readability and maintainability of code by keeping classes focused on a single responsibility.

Cons:

Can result in a large number of small, specialized classes if used excessively.
Requires careful design to prevent unnecessary complexity and confusion.

Code Example:

public interface Component {
    void doSomething();
}

public class ConcreteComponent implements Component {
    @Override
    public void doSomething() {
        // Implementation of doSomething method
    }
}

public abstract class Decorator implements Component {
    protected Component component;

    public Decorator(Component component) {
        this.component = component;
    }

    @Override
    public void doSomething() {
        component.doSomething();
    }
}

public class ConcreteDecorator extends Decorator {
    public ConcreteDecorator(Component component) {
        super(component);
    }

    @Override
    public void doSomething() {
        super.doSomething();
        // Additional behavior
    }
}

5. Strategy Pattern:
The Strategy pattern defines a family of interchangeable algorithms and encapsulates each one, allowing them to be easily swapped at runtime.

Pros:

Provides a flexible way to select and change algorithms dynamically.
Enhances code modularity and maintainability by encapsulating algorithms into separate classes.
Supports the open-closed principle, allowing new strategies to be added without modifying existing code.

Cons:

Requires the client to be aware of different strategies and select the appropriate one.
Can increase the number of classes if there are many strategies to be implemented.

Code Example:

public interface Strategy {
    void execute();
}

public class ConcreteStrategyA implements Strategy {
    @Override
    public void execute() {
        // Implementation of strategy A
    }
}

public class ConcreteStrategyB implements Strategy {
    @Override
    public void execute() {
        // Implementation of strategy B
    }
}

public class Context {
    private Strategy strategy;

    public Context(Strategy strategy) {
        this.strategy = strategy;
    }

    public void executeStrategy() {
        strategy.execute();
    }
}

Conclusion:
Design patterns provide proven solutions to common programming challenges. In this blog, we explored five popular Java design patterns: Singleton, Factory, Observer, Decorator, and Strategy. Each pattern has its pros and cons, and understanding when and how to apply them can greatly improve the quality, maintainability, and flexibility of your code. By using these design patterns effectively, you can enhance your software development skills and build more robust and scalable applications.

When to Singularity, is it before 2060?

Saheed hussain — Mon, 08 May 2023 08:32:08 +0000

It is evident that since the launch of ChatGPT, there has been a surge in the development of new AI systems, such as AutoGPT, Lalama variants, and many others. This trend has raised the question of when AI will reach the level of AGI, or Artificial General Intelligence.

Artificial Intelligence (AI) experts believe that singularity, which refers to machines capable of human-level thinking, could happen before the end of this century. The majority of participants in five surveys with around 1700 respondents expect AI singularity to occur before 2060. AI entrepreneurs are more optimistic than researchers, with estimates ranging from 2030 to 2050. Reaching AGI seems inevitable to most experts because human intelligence is fixed unless we merge our cognitive capabilities with machines, and machine intelligence depends on algorithms, processing power, and memory, which have been growing at an exponential rate.

The fear of singularity arises from the potential of a machine capable of continuously improving itself, reaching beyond human capabilities, and possibly becoming conscious. AI experts estimate that there is a 50% chance that high-level machine intelligence will occur until 2059. The estimates vary based on geography, with Asian respondents expecting AGI to occur in 30 years, whereas North Americans expect it to happen in 74 years. While these estimates seem reasonable, they could be over-optimistic as AI researchers have made similar predictions before, which did not come to pass.

In conclusion, while reaching AGI seems inevitable to most AI experts, the predictions on the timeline for this achievement vary widely. Most of these predictions range between 2030 and 2075, with the majority expecting it to occur before 2060. However, there is a significant difference of opinion based on geography, and AI entrepreneurs are more optimistic than researchers. Despite the historical experience of over-optimistic predictions by AI researchers, the rapid development of algorithms, processing power, and memory suggests that the timeline for AGI might be closer to the optimistic estimates.

Boosting Your Productivity

Saheed hussain — Wed, 12 Apr 2023 04:39:11 +0000

Abraham Lincoln once famously said, "Give me six hours to chop down a tree and I will spend the first four sharpening the axe." I am huge fan of productivity as it helps me save time for my personal as my work load is quite high most of the time. As a software developer I use following productivity tools for saving time in my personal and professional work:

Bullet Journaling - I learned about bullet journalling in 2021 from the book "The bullet journal method" and ever since I have been using this method for managing my work and personal life. Bullet journal is a journal where I plan my coming months, weeks and days. At the start of the year I create yearly planner with one section for each of 12 months and put tasks, activity I would be doing in that particular month that year. I keep adding new items there as and when I need to throughout the year. Then every month I create a monthly day wise planner where I add task which I need to do on a particular day in that month by referring yearly planner, Also I create a section where I put items which needs to be done but not necessarily on a particular day. Then every day I create day planner before starting my day by picking up tasks from this monthly backlog. This helps in completing tasks without missing things and helps keep things organised.
Alfred - Alfred is one of the best tool I have found in last few years that helps me automate many of my tasks and help look up quickly. All my bookmarks in the browser are searchable in it and with one click it opens them. Also workflows help me speeds up my daily work e.g. searching some piece of data and complex queries in db(in web interface) is done with one click saving me around 5-10 mins with every search and I often needs to do it multiple times on variety internal tools. You can create different workflow to automate your tasks as per you need, possibilities are endless.
Focus Keeper - Human mind tend to get tired with longer concentration periods, thus needs to take break to relax and recover. So I use focus keeper to divide my work day into short intervals for 25 mins or 50 mins sessions and take 5-10 mins of break thereafter to relax so as to be able regain focus. At the start of interval I decide in next 25/50 mins session what will I be focusing and targeting to complete and then dedicate that time to that work item only and ignore any distraction that come up during that time as I have a target to complete in limited time.
Happiness - As per a study Happiness can make you around 12% more productive. So I try to plan for my weekly and daily happiness quota - playing sports, watching comedy, exercising, practicing gratitude etc. Also In the 5-10 mins break during my focus time,I use breathing techniques, jokes, gratitude logs, revisiting happy memories to keep myself in sound state.
SmartWatch - I use smartwatch to keep track of my daily physical activity, my daily meeting calendar, weather conditions, time in other timezone where interact more. All this save me time as I don't have to open my calendar in mobile/laptop to view next meeting, all that is on my wrist. Similarly when stepping out I don't have to check weather which is must for me as London weather is quite unpredictable. All these things on the wrist helps me work faster as don't have to search for them explicitly.
Task Tool - We have an internal company tool for managing tasks(similar to JIRA), I use that for project planning.

These are the tools I used to boost my productivity, let me know in the comments what tools you use to boost your productivity and save time.

Tips for Effective 1:1s with Your Manager

Saheed hussain — Tue, 11 Apr 2023 10:38:49 +0000

For fair share of my career I never thought that 1:1s with manager were ever useful to me, 99% of the time they were just a status update and everything was fine. They look redundant to me as they were like the status update meetings which team already had and I considered them a sheer waste of my time and they seemed to be a checkbox to tick for my manager and nothing else.

But then I met a manager who stopped me from sharing status updates and instead asked me to bring agendas that I would want to discuss, like things that were bothering me, career progressions, process difficulties, 2-way feedbacks between me and my manager etc. Then I slowly started preparing agendas and realised that 1:1s are for me and not for my manager and I should be deriving them to get my concerns addressed, work on my career progression, get feedback from manager etc.

Here are few things I learned which can also help one in having an effective 1:1 with their manager and get the most value out of it:

Understand why you do 1:1s: Realise that 1:1s are your time to take most out of your manager's experience and get support/guidance from him and you should be deriving it, not your manager and avoid them falling into status update pitfall.
Prepare an Agenda: Just showing up won't make 1:1s effective, having an agenda to discuss would help you get most out of them. Share agenda before meeting with your manager if it needs a preparation from them.
Have Regular 1:1s: Having regular weekly/biweekly 1:1s prevent disconnect and keep the discussion in flow without loosing context on the ongoing discussion topics.
Take Notes & Track Follow ups: Use one document for all the 1:1s so that you have continuous trail of the progress and discussion you had or if you want to continue from previous 1:1. Share it with your manager so that you two can collaborate on one doc and follow up on any action items post the meeting.
Focus on your career goals: Discuss about your career goals, how are you doing, what you should be doing more to help you move in the right direction towards achieving those goals.
Discuss Your concerns/blocker: Discuss things that are bothering you / blocking you, seek manager's help on resolving them.
Seek & Give Feedback: Feedback can help you realise how you are doing with regards to expectations for your level and what could you do to fill in the gaps if any. Managers can also help you get feedback that he might have from others in the team. Also, provide feedback to your manager and about the team overall if you have any.

Hopefully, these tips would help you have an effective 1:1 with your manager and grow in your career with your manager's help.