DEV Community: Abhinav Pandey

5 productivity hacks that nobody talks about

Abhinav Pandey — Sun, 21 Aug 2022 07:22:20 +0000

In this article, we will look at a few hacks which can enhance the productivity of an individual or a team.

All these ways are sustainable to follow and work well when incorporated as habits.

1. Reusing tools and knowledge

One of the biggest mistakes people make is to start from scratch and re-invent the wheel.

When faced with a problem, the first step should be to look for existing solutions.

If an exact solution is not found, the target should be to compare the requirements to similar solved problems.
Find similarities and differences.

Reuse what you can and more importantly, document the new findings on every iteration.

This is effective on a personal level but works even better when done on a team or organization level.

Successful organizations spend a lot of effort in enforcing this re-usability which in turn helps their developers to be more productive.

2. Speed over Perfection

While perfection can be a target in some cases, speed is usually mandatory. Perfection on a high level design is not a bad idea, but it starts hurting the speed when it's desired on every small detail.

Delivering quality depends a lot on doing a lot of repetitive and trivial tasks correct and quickly.

Here are a few ideas to achieve this.

Delegate without micro-managing

As developers, out state of mind is always to provide solutions. This becomes tough when you're dividing work with other people.

While it's good to care about the big picture, it's a waste of time trying to ensure others are performing their tasks according to your thought process.

Trust the other person to do their job without you being involved at every step. Their output may not match your expectations for the first few times, but it gets better after a few iterations.

It helps them figure things out on their own and they build a better working relationship with you if they feel you trust them.

Have an Acceptance Criteria

Establish an acceptance criteria early to give an idea of when to stop. The maintainability and adaptability of your code is also a part of this acceptance criteria.

When you write down your target, it makes it difficult to overthink and over-engineer beyond it.

Meeting this criteria is the first target of the developer. It takes priority over refactoring and making code look pretty.

Reduce Review Cycles

Build guidelines that a team follows rather than relying on long reviews. This should be done for both code and processes.

Use automated code quality and testing tools to validate PRs rather than a reviewer having to do it manually.

3. Prototyping

The best way to check the feasibility of a solution is to build a prototype and test it.
Focus of the prototype should be to test the risky and unfamiliar parts of the solution.

Once its successful(or unsuccessful), it is important to document the new findings.

It is not required to do extensive research, long courses of study or multiple rounds of planning before getting your hands dirty with the code.

Working code brings more confidence than any notes, documentation or minutes of the meetings.

4. Power of the people

Whether you work in a team or build a product on your own, it is important to leverage the power of the people.

Doing it all alone is not a good idea. It makes your chances of success limited to your own efforts.

Here are a few things when you should consider involving other people:

Asking for advice

If you know someone who is good at the skills or problems you are trying to conquer, ask for their advice. Learn how they do things. Build upon their knowledge.

Validation and feedback

Let your team or friends validate your ideas and give feedback.

The earlier you get someone else's perspective on what you're about to do, the more time you have to make it better. Feedback at a late stage is not always helpful and harder to incorporate.

Ask for contributions

Ask people to contribute in whatever way they can. They could share the workload with you, fix some bugs, review your code, or even help you with the design.

Brainstorm together

Working on ideas together is a great way to get ideas flowing. It is a way to learn new approaches to solving a problem. It can also bring constant validation and feedback.

Share knowledge

Sharing knowledge can build a community of like-minded people. It helps you network and builds trust.

It can unintentionally lead to people pointing out flaws in your implementation or documentation and getting you to fix them.

5. Self-reflection

Everyone should take planned periodic breaks and reflect on their progress. This is similar to a sprint retrospective and let's use the same principles for our personal reflection.

Here are a few things to consider in your reflection:

What can you do better?

Focus on saving time and effort by finding opportunities to optimize the little things you do every day.

Find opportunities to automate processes. Find ways to clear out the junk. Improve your work environment (physical and software) to support the plans you have for the near future.

What's hurting you?

Reflect on the habits that are keeping you from getting things done. Find a sustainable way to reduce the time you spend on those habits.

It's also important to figure out your mental blockages. Pending tasks and annoying people weigh a lot on your subconscious mind and you are better off without them.

What's working well?

Reflect on the things that are going well for you. It could be beneficial to invest more time and effort into it.

If you work in a team, it's important to share this with people who's productivity affects yours.

Thanks for reading. If you found this article useful, consider sharing it with your friends. I'd also love to know your own advice in the comments.

And if you want to connect with me, you can find me on Twitter

Why Cloud is the Future?

Abhinav Pandey — Fri, 05 Aug 2022 04:46:38 +0000

Let's look at a few reasons why organizations will keep investing in cloud computing and why learning about it will provide you a competitive edge over others.

Lowers Infrastructure Cost

Instead of buying hardware, you are renting it. This means you only pay for what you use and for the time you use it.

The cloud provider takes care of maintaining and upgrading the hardware for you. This reduces the need for IT specialists.
It also reduces the time required to procure hardware, software and licenses.
Temporarily required instances can be spun up and down for the duration that they are required. This is a great way to save cost of infrastructure required for testing.

Supports Fast-paced Innovation

By abstracting the infrastructure setup, cloud enables you to focus on the application development.

It provides PaaS and SaaS services which you can build on top of. This further reduces the need to reinvent the wheel for repetitive tasks.
Cost-effective concepts like Serverless make it easier to experiment with new products without requiring a significant initial investment.

All these factors reduce the time to market and help organizations stay ahead of their competition.

Battle-tested Security

You would rather use a tried and tested security solution than build you own. Moreover, with cloud its mostly a matter of enabling a few configurations.

Cloud providers provide a wide range of security features like:

Firewalls,
DDoS protection,
Fine-grained access control,
Encryption,
Compliance with data privacy and security regulations,
and more.

Geographical Distribution

It makes it easier to geographically distribute data and services.

Database redundancy can be set up to replicate data across the world. Similarly, services can be deployed to several regions.

This can have benefits like:

Low latency service to people in multiple countries,
Safeguard against downtimes and data loss due to natural disasters.
Eliminates single point of failures at a regional level.

Your services can keep running even if a data center burns down.

Elastic Scalability

You can scale your cloud services to meet spikes in load.
More importantly, you can scale down to save cost when your users are less active. -This makes it suitable for small to medium-sized businesses where it's important to save money in every way.

High Availability

Most cloud services come with an availability guarantee.This means that if a service fails, it's the provider's responsibility to ensure that the service is available again.

If it fails to meet the availability SLA, you get compensated for it.

Please note that you don't get compensated for downtimes due to your own fault - e.g. bad code, bad deployment strategy, under-provisioning, etc.

These benefits motivate big organizations to more towards the cloud. These savings in cost, reliability and speed convert to millions of dollars for them.

On the other hand, it enables startups to get started quickly and avoid huge initial investments.

This translates into demand for skilled professionals with knowledge and experience in cloud technologies.

Cloud skills have become a part of most usual software roles like DevOps, Backend development, Data, ML and AI. Additionally, new cloud specific roles have emerged.

Building an Effective Code Review Process

Abhinav Pandey — Wed, 03 Aug 2022 16:38:00 +0000

Code reviews are not just a great way to ensure code quality, they're also a way to build standards, mentor people and learn from mistakes.

Here are a few tips that can help a team in building an effective review process.

1. Create Small PRs

The longer the PR, greater the chance that parts of it will be overlooked. Small and frequent PR reviews create a better feedback loop.

Break down big stories into smaller chunks which can be developed and reviewed independent of the rest of the code.

2. Document Requirements

Referring requirements and acceptance criteria makes it easier for the reviewer to understand the intent of the code. It reduces the need for synchronous communication during the review.

Include links to document or tickets in the PR description.

3. Make Atomic Changes

A PR should not have inconsistent code.

There should be no TODOs, unfinished methods, commented code or failing test cases.

Whatever purpose the PR solves, it solves it completely. Otherwise, it's not ready for review.

4. Build Team Checklists

A team should maintain a list of guidelines that developers must follow while coding and raising PRs. It helps establish expectations early.

Before raising a PR, developers should refer to the guidelines and ensure they are followed. For e.g., these are some guidelines that should be followed while raising PRs:

Code formatting
Comment guidelines
Variable naming conventions
Unit test coverage

5. Use Automated Code Quality Tools

Use static code analyzers to validate PRs rather than having the reviewer decide if the code stinks or not.

Reviewers should focus more on business requirements and rules that are specific to the project.

Use code quality checks in the build pipeline to break builds if quality or unit test metrics are not met.

6. It's a Learning Opportunity

It's important to make code reviews a learning process and not one person pointing out mistakes of the other person.

Reviewing and being reviewed is a great way to share knowledge and perspectives.

Write useful review comments which help the developer understand the 'why' behind the suggestions.

As a developer, take time to understand why the reviewer made a particular suggestion rather than just blindly accepting it.

7. Use Round-robin Reviews

Give everyone a chance to review code and give more developers a chance to look at each other's code.

It makes them comfortable in communicating with each other, distributes the review work efficiently and breaks knowledge silos within the team.

8. Use Positive Language

The language used in a code review should be positive and constructive.

As a reviewer, include positive comments if the code is well-written and well-commented.

Suggestions should be soft like, "can we try this?" or "I think this is a good idea".

There should be no rigid and commanding language like "do this instead". Any review comment should be open to discussion.

Thanks for reading. I hope it gives you a few ideas on what to improve in your current review process. If you have some code review tips, feel free to add them in the replies.

If you want to connect with me, you can find me on Twitter

An Approach to Continuous Learning

Abhinav Pandey — Sun, 17 Jul 2022 05:27:18 +0000

Being a successful developer requires continuous learning and skill improvement. But there are simply too many things to learn and too little time.

Let's see a few principles with which we can invest our learning efforts effectively and receive maximum gains.

Small improvements everyday

First and foremost it's important to invest a little time and energy every (normal) day.

Build a habit with a set time and place to try something new - learn, build, practice.
1% better everyday makes you twice as good in 70 days. (probably has been said too many times)

Building this habit requires a little effort but everything seems effortless once we get there.

A few things that help in the process:

Making long-term and short-term to-do lists
Setting learning reminders(on a calendar rather than in the mind)
An environment that enables learning and avoids distraction

Get Good Enough at Your Niche

Everyone needs to be good at the particular technologies they are working with.

If you work, the first target is to get good at your job.
If you're looking for work, focus on the role you want to land.

Invest your learning time and efforts on the most essential skills needed for your job. This includes both technical skills and soft skills.

Then Diversify

Once you're good at the necessary skill, it's time to look into more technologies.

There are two directions to explore:

1. Tools that go well with your niche.

My personal trick is to look at job descriptions corresponding to my current role and look for gaps in my knowledge.

The execution strategy is to first master the essentials, then build and then go deeper.

Getting good at what works well with your niche gets you those hikes, promotions, job switches. It makes the most sense to spend time on this.

2. Tools that compete with your niche.

If something exists as a competition to your current tools, its worth knowing why it exists, what are the differences and how to choose between the two.

A different database, framework, library and sometimes programming language comes into this category.

This makes you capable of taking informed decisions at work. It also makes you future-ready if you ever need to switch your tech stack or parts of it.

Keep an eye on shiny objects

Too much time spent into shiny objects or switching from one context to other can waste time and energy. However, it doesn't mean you ignore upcoming technologies.

It is worth keeping an eye at promising things happening around you. Learning something that is still in the process of getting popular can be a head-start for you. If the thing has a good future, it can be highly rewarding for you.

Have a little FOMO when you see people hyping something. But at the same time, invest your time responsibly.

The first questions to ask are,

What are the chances of this new thing being used at scale in the industry?
What are the chances of you using it as part of your job?

Continuous retrospection and re-planning

To not get overwhelmed by the number of technologies to learn and also to stay on the right course, it's important to keep yourself in check.

Make time for reviewing your path once in a while. To check where you're investing time and if there are any changes you can make to make it more effective.

Questions to ask yourself during the review:

what's urgent and needs to be prioritised,
what's outdated and needs to be cut down and
what needs to be revisited.

Thanks for reading. Hopefully it gives you a few helpful points. If you want to connect with me, you can find me on Twitter.

Tips to Optimize Backend Performance

Abhinav Pandey — Wed, 22 Jun 2022 15:53:50 +0000

As the number of users/requests of an application increases, it becomes important that it maintains its performance.

Let's look at a few improvements that we can do to enhance application performance.

Query Optimization

Make database queries more efficient using one of these ways:

Use only indexed columns in a query
Make fewer database calls by using joins when advantageous.
Use a query cache to avoid making duplicate queries.

Caching

Use a cache(distributed or local) to store data that is frequently accessed. This may include:

results of database queries
results of expensive computations
responses to frequent idempotent requests

Database optimization

Don't just optimize the queries, also optimize the way data is being stored.

Use indexes to make queries faster
Use normalization to clean up data, separate data into meaningful chunks, or make it easier to query
Alternatively, use denormalization when possible to reduce the need to use joins for tables always queried together.
If using NoSQL, make use of shards and partitions for faster lookup.

CDN

CDNs are content delivery networks that provide content to the user.

The main use of CDNs is to serve static content such as images, CSS, and JavaScript from locations that are geographically close to the user.

They can also serve dynamically generated content including:

JSON data in GET requests which does not change frequently with respect to its URL
HTML content that is generated on the server-side

Fail fast

Make sure your application does not spend time processing bad requests.

Validate requests as soon as they are received
Use rate limiting and deduplication to avoid DDoS attacks.
If calling other services, use a circuit breaker to prevent cascading failures

Keep the network light

Use lighter request and response formats to reduce the amount of data that is sent over the network.

Use PATCH requests instead of PUT if updating small parts of a resource
Prefer JSON over XML because of the compactness of the format.
Use the GraphQL approach if querying large amounts of data but need only specific values back.
Use compression for APIs which return large sizes (MBs) of data.

Thanks for reading. This should give you some ideas which you can implement in your low-level design to optimize performance.

These are only some of the popular techniques. Feel free to add any of your advice in the comments. If you want to connect with me, you can find me on Twitter

A Guide to Java Records

Abhinav Pandey — Sun, 15 May 2022 06:44:06 +0000

In this tutorial, we will cover the basics of how to use records in Java.
Records were introduced in Java 14 as a way to remove boilerplate code around the creation of value objects while incorporating the benefits of immutable objects.

1. Basic Concepts

Before moving on to Records, let's look at the problem Records solve. To understand this, let's examine how value objects were created before Java 14.

1.1. Value Objects

Value objects are an integral part of Java applications. They store data that needs to be transferred between layers of the application.

A value object contains fields, constructors and methods to access those fields.
Below is an example of a value object:

public class Contact {
    private final String name;
    private final String email;

    public Contact(String name, String email) {
        this.name = name;
        this.email = email;
    }

    public String getName() {
        return name;
    }

    public String getEmail() {
        return email;
    }
}

1.2. Equality between Value Objects

Additionally, the value objects may provide a way to compare them for equality.

By default, Java compares the equality of objects by comparing their memory address. However, in some cases, objects containing the same data may be considered equal.
To implement this, we can override the equals and hashCode methods.

Let's implement them for the Contact class:

public class Contact {

    // ...

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Contact contact = (Contact) o;
        return Object.equals(email, contact.email) &&
                Objects.equals(name, contact.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(name, email);
    }
}

1.3. Immutability of Value Objects

Value objects should be immutable. This means that we should restrict ways to change the fields of the object.

This is advisable for the below reasons:

To avoid the risk of accidentally changing the value of a field.
To make sure equal objects remain equal throughout their lifetime.

The Contact class is already immutable. We have:

Made the fields private and final.
Provided only a getter for each field and no setters.

1.4. Logging Value Objects

We will often need to log the values that the objects contain. This is done by providing a toString method.
Whenever an object is logged or printed, the toString method is called.

The easiest way is to print each field's value. Here is an example:

public class Contact {
    // ...
    @Override
    public String toString() {
        return "Contact[" +
                "name='" + name + '\'' +
                ", email=" + email +
                ']';
    }
}

2. Reducing Boilerplate with Records

Since most value objects have the same needs and functionality, it was a good idea to make the process of creating them easier.
Let's look at how Records achieve this.

2.1. Converting Person Class to a Record

Let's create a record of the Contact class which has the same functionality as the Contact class defined above.

public record Contact(String name, String email) {}

The 'record' keyword is used to create a record class. Records can be treated exactly like a class by a caller.
For e.g, to create a new instance of the record, we can use the new keyword.

Contact contact = new Contact("John Doe", "johnrocks@gmail.com");

2.2. Default Behaviour

We have reduced the code to a single line. Let's list down what this includes:

The name and email fields are private and final by default.
It defines a constructor which takes the fields as parameters.
The fields are accessible via getter-like methods - name() and email(). There is no setter for the fields so the data in the object becomes immutable.
A toString method is implemented to print the fields the same as we did for the Contact class.
The equals and hashCode methods are implemented. They include all the fields just like the Contact class.

3. Working with Records

We may want to change the behavior of the record in multiple ways. Let's look at some use cases and how to achieve them.

3.1. Overriding default implementations

Any default implementation can be changed by overriding it. E.g. if we want to change the behavior of the toString method, we can override it between the braces {}.

public record Contact(String name, String email) {
    @Override
    public String toString() {
        return "Contact[" +
                "name is '" + name + '\'' +
                ", email is" + email +
                ']';
    }
}

Similarly, we can override the equals and hashCode methods as well.

3.2. Compact Constructors

Sometimes, we want constructors to do more than just initialize the fields.
We can add these operations to our record in a compact constructor. It's called compact because it does not need to define the initialization of fields or the parameter list.

public record Contact(String name, String email) {
    public Contact {
        if(!email.contains("@")) {
            throw new IllegalArgumentException("Invalid email");
        }
    }
}

Note that there is no parameter list and initialization of name and email takes place in the background before the validation is performed.

3.3. Adding Constructors

We can add more constructors to our record. Let's see a few examples and a couple of restrictions.

First, let's add new valid constructors:

public record Contact(String name, String email) {
    public Contact(String email) {
        this("John Doe", email);
    }

    // replaces the default constructor
    public Contact(String name, String email) {
        this.name = name;
        this.email = email;
    }
}

In the first constructor, the default constructor is accessed using the this keyword.
The second constructor overrides the default constructor because it has the same parameter list. In this case, the record will not create a default constructor on its own.

There are a few restrictions on the constructors.

1. The default constructor should always be called from any other constructor.
E.g., the below code will not compile:

public record Contact(String name, String email) {
    public Contact(String name) {
        this.name = "John Doe";
        this.email = null;
    }
}

This rule ensures that fields are always initialized. It also ensures that the operations defined in the compact constructor are always executed.

2. Cannot override the default constructor if a compact constructor is defined.
When a compact constructor is defined, a default constructor is automatically constructed with the initialization and compact constructor logic.
In this case, the compiler won't allow us to define a constructor with the same arguments as the default constructor.

E.g., this won't compile:

public record Contact(String name, String email) {
    public Contact {
        if(!email.contains("@")) {
            throw new IllegalArgumentException("Invalid email");
        }
    }
    public Contact(String name, String email) {
        this.name = name;
        this.email = email;
    }
}

3.4. Implementing Interfaces

Just like any class, we can implement interfaces in our record.

public record Contact(String name, String email) implements Comparable<Contact> {
    @Override
    public int compareTo(Contact o) {
        return name.compareTo(o.name);
    }
}

Important Note: To ensure complete immutability, records are not allowed to participate in inheritance. Records are final and cannot be extended. Nor can they extend other classes.

3.5. Adding Methods

In addition to constructors, overriding methods and implementing interfaces, we can also add any methods we want.

For example:

public record Contact(String name, String email) {
    String printName() {
        return "My name is:" + this.name;
    }
}

We can also add static methods. For example, if we wanted to have a static method that returns the regex against which emails can be validated, we can define it as below:

public record Contact(String name, String email) {
    static Pattern emailRegex() {
        return Pattern.compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);
    }
}

3.6. Adding Fields

We cannot add instance fields to our record. However, we can add static fields.

public record Contact(String name, String email) {
    private static final Pattern EMAIL_REGEX_PATTERN = Pattern
            .compile("^[A-Z0-9._%+-]+@[A-Z0-9.-]+\\.[A-Z]{2,6}$", Pattern.CASE_INSENSITIVE);

    static Pattern emailRegex() {
        return EMAIL_REGEX_PATTERN;
    }
}

Note that there are no implicit restrictions on the visibility of static fields. They can be public if needed and may not be final.

Conclusion

Records are a great way to define data classes. They are a lot more powerful than the JavaBeans/POJO approach.
Because of their ease of implementation, they should be preferred over other approaches for creating value objects.

Thanks for reading. If you have any questions/suggestions, please feel free to mention them in the comments.

If you want to connect with me, you can find me on Twitter

Tips for Faster Debugging in IntelliJ

Abhinav Pandey — Fri, 22 Apr 2022 03:34:00 +0000

Top IntelliJ tricks to debug issues faster. (excluding the debugger)

Fold Logs

Running an application can produce a lot of console output. Most of it is not useful and comes from third party libraries. You can fold console output lines coming from these libraries. This will help you focus on the important information.

Select the class name on the log line and right click
Select "Fold lines like this".

It will open a window and add this class to the list of classes to fold. You can further edit this class name to a package name to fold all classes in that package.

Search With Google

You can trigger a Google search from anywhere in the IDE - code, console, log files, text files, etc.

For e.g., when you see an error in the logs,

Select the piece of text you want to search
Right click
Search with Google.

While this is a trivial thing, it gets you to StackOverflow faster.

If you want to take this one step further and stop the monopoly, use the Smart Search plugin which lets you use custom search engines.

You can even search on StackOverflow directly and cut out the middleman.

Compare files with Clipboard

You can compare contents of a file with the content in the clipboard. This is useful in comparing files which are not part of version control.

This can also serve as a quick way to compare and merge two files.

A usual usage scenario is to compare configuration files.

Show Git History for a Piece of Code

You see a code, but you don't know what it does (or why it does what it does).

To get an idea, you need to know why the code was written and/or who wrote it.

Find it out using the Git history.

Select the piece of code
Right click
Go to the Git section and select "Show history for selection".

This will list down all the old commits which included changes in the code.

Compare code with a working copy

Something worked in the past, but now it doesn't. A great way to debug it is to check the changes that have been made to it since then.

There are multiple ways to do this.

Use the Git option "Compare with branch" and compare the current code to the code in a branch that worked fine.
Use the Git option "Compare with Revision" and compare it to the code in a commit that worked fine.
Compare entire current branch with another branch. This is useful to understand multiple changes together instead of looking at a small piece of code.

Local History

You can see the history of changes you made to a file in the local history. IntelliJ maintains a local history for each file (yes, even uncommitted code is safe).

This can be helpful when recovering from accidental deletions or to recover an intermediate state of a file.

For e.g. You made the code work, tested it and then went on to refactor it before committing. If the code doesn't work, you can recover the previous working state of the file from the local history or just compare it to understand what you did wrong.

Thank you for reading.

More importantly, if you have any tips of your own, feel free to share them in the comments.

The Ultimate Guide to Backtracking

Abhinav Pandey — Tue, 19 Apr 2022 17:13:07 +0000

Backtracking is a technique for solving problems by exploring all possible solutions.

Backtracking problems ask us to find combinations or permutations. These Ps & Cs are then matched against certain conditions or smallest/greatest logic. Here are a couple of examples:

Given an array of numbers, find all the possible combinations of numbers that add up to a given number.
Given a collection of distinct integers, return all possible permutations of them.

In this article, we will use backtracking to solve these two problems. In doing so, we will go through each step of the process in detail.

We will also look at a few important variations of these problems and how to change our solution to solve them.

In short, we can drill down backtracking to the below steps:

Start from a state.
If the current state is a solution, add the current state to the result.
If not, try each of the possible moves from the current state.
Once we have tried all the possible moves, backtrack to the previous state.
Repeat the above steps until a solution is found or all possibilities have been exhausted.

Problem 1: Combinations

Let's solve the below problem:

_Given a list of distinct positive numbers, find all combinations that add up to a given number.

Input: [1, 2, 3, 4], target = 5
Output: [[2, 3], [1, 4]]_

Let's use the backtracking technique to solve this problem.

Disclaimer: There are many ways to solve this problem. I have chosen a way that will be easy to explain. I have left out any clever tricks to keep the code simple.
The programming examples are in Java but do not use any special data structures.

Initial State

The initial state is an empty list. We are going to start from this state and try to add numbers to it.

We will keep track of:

The current state or list of numbers used.
The sum of the numbers in the list.

public List<List<Integer>> combinationSum(int[] nums, int target) {
    // will store the final result
    List<List<Integer>> res = new ArrayList<>(); 

    // keeps track of the current state
    List<Integer> current = new ArrayList<>();

    // call the helper function which does the processing 
    // first 0 is the sum of the numbers in the current state
    // second 0 is the index to start from
    backtrack(nums, target, 0, 0, current, res);
    return res;
}

Check if the current state is a solution

We need to check if the current state is a solution.
To do so, we need to check if the sum of the numbers in the current state is equal to the target.

If yes, we will add the current state to the final result.

void backtrack(int[] nums, int target, int sum, int index, List<Integer> current, List<List<Integer>> res) {
    // if the sum of the numbers in the current state is equal to the target,
    // then we have found a solution
    if (target == sum) {
        // copy the content of the current state to a new list and save to result
        res.add(new ArrayList<>(current));
        return;
    } else if(sum > target) {
        // short circuit, if the sum of the numbers in the current state is greater than the target,
        return;
    }

    // to be continued...
}

Try each of the possible moves and backtrack

If the current state is not a solution, we need to try each of the possible moves.

The possible moves are all the numbers in the nums array that comes on or after the index.

We can divide this into 3 steps:

Add a number to the current list to get to the next state.
Call the backtrack function to check if the next state is a solution. Update the index and sum being sent to the backtrack function.
Remove the number from the current list to get back to the previous state. The next iteration will try the next number.

void backtrack(int[] nums, int target, int sum, int index, List<Integer> current, List<List<Integer>> res) {
    // checking for solution - omitted

    for (int i = index; i < nums.length; i++) {
        // add the current number to the current state
        current.add(nums[i]);

        // call the helper function to try the next state - Current sum is updated and index is increased to the next number
        backtrack(nums, target, sum + nums[i], i + 1, current, res);

        // remove the current number from the current state
        current.remove(current.size() - 1);
    }
}

Variation 1: Numbers are not distinct

If we ran the same solution, but with the numbers not being distinct, we would get duplicate results.
For e.g. [1, 2, 2, 3, 4] will return [[1, 2, 2], [1,4], [2, 3], [2, 3]]

Solution 1: Set to Store Result

The simplest way to solve this problem is to use a Set to keep track of the final result and convert the set to a list at the end.
Although this will lead to a correct solution, this does lead to some unnecessary work being done. Duplicate results are still being calculated even if not included in the result.

public List<List<Integer>> combinationSum(int[] nums, int target) {
    // will store the temporary result
    Set<List<Integer>> res = new HashSet<>(); 

    List<Integer> current = new ArrayList<>();
    backtrack(nums, target, 0, 0, current, res);

    // convert the set to a list
    return new ArrayList<>(res);
}

Solution 2: Avoid Duplicate Moves

A better way is to exclude duplicate moves while forming the next state.

Suppose our current state is [1]
When we loop through the remaining numbers, we can get the below possible states:
[1, 2], [1, 2], [1, 3], [1, 4]

To avoid the duplicate move, all we need to do is to check if a number is being processed twice.

We will put the processed numbers in a Set and if a number is already in the set, we can skip it.

void backtrack(int[] nums, int target, int sum, int index, List<Integer> current, Set<List<Integer>> res) {
    // checking for solution - omitted

    Set<Integer> set = new HashSet<>();
    for (int i = index; i < nums.length; i++) {
        // if the current number is already in the set, skip it
        if (set.contains(nums[i])) {
            continue;
        }

        //processing - call and backtrack - omitted

        // add the current number to the set
        set.add(nums[i]);
    }
}

We can further remove the set if the order of the result is not important.

The steps for this are:

Sort the initial array so that all duplicates come together.
Instead of using a set, compare numbers to the previous number and skip if it's the same.

The below code can replace the Set logic once the array nums is sorted.

void backtrack(int[] nums, int target, int sum, int index, List<Integer> current, List<List<Integer>> res) {
    // checking for solution - omitted
    for (int i = index; i < nums.length; i++) {
        // if the current number is already in the set, skip it
        if (i > index && nums[i] == nums[i - 1]) {
            continue;
        }
        //processing - call and backtrack - omitted
    }
}

Variation 2: Numbers Can Be Used any Number of Times

If we could use each number any number of times, the result changes.
For e.g. For a target sum of 5, [1,2,3,4] will return [1,1,1,1,1], [1,1,1,2], [1,1,3], [1,2,2], [1,4], [2,3]

This leads to a very small change in our recursive call.
Since the same number can be used again in the solution, we will not increment the index while calling the recursive function.

void backtrack(int[] nums, int target, int sum, int index, List<Integer> current, List<List<Integer>> res) {
    // checking for solution - omitted

    for (int i = index; i < nums.length; i++) {
        current.add(nums[i]);

        // sum is updated but index is not incremented
        backtrack(nums, target, sum + nums[i], i, current, res);

        current.remove(current.size() - 1);
    }
}

Problem 2: Permutations

Let's solve the below problem:

Given a collection of distinct integers, return all possible permutations of them.
Input: [1, 2, 3]
Output:
[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

This becomes simple once our intuition is clear. To form a permutation, there are 2 important principles:

Include all the elements - This forms the stopping condition.
No element can be included more than once. This means that at any state, our possible moves include only the elements we have not included before.

We will use a similar approach we used for the combination problem and will incorporate the above two points.

The Stopping Condition

The stopping condition is that we have included all the elements.

void backtrack(int[] nums,  Set<Integer> current, List<List<Integer>> res) {
    if(current.size() == nums.length) {
        res.add(new ArrayList<>(current));
        return;
    }

    // otherwise process
}

The Possible Moves

The possible moves are the elements that we have not included in the current state before.

We can break this into two steps:

Store the numbers that have been used in the current state. In simple words, maintain a Set for the current state.
Check for all numbers after each move. We do not need to maintain the index variable as before since we want to check the possibility of all numbers after the current number.

void backtrack(int[] nums,  Set<Integer> current, List<List<Integer>> res) {
    // stopping condition - omitted

    // starting from the first element always
    for(int i = 0; i < nums.length; i++) {

        // if the current number is already in the set, skip it
        if (current.contains(nums[i])) {
            continue;
        }
        current.add(nums[i]);
        backtrack(nums, current, res);
        current.remove(current.size() - 1);        
    }
}

Please note that the Set needs to be a LinkedHashSet. This is because we need to maintain the order of the elements. If it's not, everything falls apart (At least in Java). If you do not have a Set alternative in your language that provides ordered iteration, simply use a list. The contains operation does not make a difference to the order of time complexity (discussed later).

Variation: Numbers Are Not Distinct

If some numbers are not distinct, the above solution cannot find possible permutations.

This is because once a number has been used, its contains check will return true and we cannot use it again.

The current set will never have the length of the original array, and we will be stuck in the backtrack function FOREVER.

Solution: Set of Indices

The solution is simple. Instead of maintaining a set of values, we can maintain a set of indices. Indices are always unique.

To maintain a set of indices that have been included in the current state, we can use a boolean array.

The boolean array updates in the same way as the current set/list.

void backtrack(int[] nums,  Set<Integer> current, List<List<Integer>> res, boolean[] used) {
        // stopping condition - omitted

        for(int i = 0; i < nums.length; i++) {
            // if the current number is already in the set, skip it
            if (used[i]) {
                continue;
            }
            // add to boolean array as well as current set
            used[i] = true;
            current.add(nums[i]);

            backtrack(nums, current, res, used);

            // remove from boolean array as well as current set
            current.remove(current.size() - 1);
            used[i] = false;
        }
    }

Time Complexity

The theoretical Time complexity of each of these backtracking algorithms is O(N!) where N is the number of elements in the input array.

This can be calculated by the following intuition:

At every step, we have N choices to choose from.
After making all choices, we have to make N-1 choices for each of them.
And so on.

Number of steps = Nx(N-1)x(N-2)x...x1 = N!

This does not mean all backtracking algorithms are O(N!). It all depends on the number of choices we have at each step.

Thanks for reading. The problems and variations in this post cover the most popular variations of the backtracking technique.

If you found this article helpful, please don't forget to share it with people in need - in whatever way possible.

If you want to connect with me, you can find me on Twitter or LinkedIn.

10 SEO tips to increase the reach of your blogs.

Abhinav Pandey — Tue, 05 Apr 2022 07:11:43 +0000

Whether you're a blogger, startup, or a business, blogging is a long-term strategy to build a strong presence in front of humans as well as search engines.
With these small, easy-to-implement SEO tips, you can increase your blog's reach and traffic.

1. Seed Keywords

Ranking well for a large number of keywords is a difficult goal and may not be the best strategy.
We should rather focus on a small set of keywords that form a theme for your blogs. These words should be:

relevant to your niche or product,
frequently searched for by your target audience,
but has less competition in the market.

An example of this is:

Java is a vague keyword which is used by a lot of people. I will have a hard time beating other sites to rank for the best Java website.
I can rather try with something more specific and smaller. E.g., Spring Cloud. If all my blogs are about Spring Cloud, my blog can build authority and rank for Spring Cloud.

2. Long-tail keywords

Another strategy is to use long-tail keywords - e.g. "implement service discovery in Java". These are something people will put in a search query and at the same time are less competitive to rank for.
Individually, long-tail keywords will not bring a lot of traffic but the traffic will add up when you start ranking for a lot of them.
If blogs combine long-tail keywords with seed keywords, the effect multiplies. The next two tips talk more about this.

3. URL and Title

The URL and Title of the page contain the keywords.
A good strategy is to use the long-tail keywords in the URL.
The title can be similar and can additionally contain your seed keywords and/or your brand name.
Another thing to keep in mind is that the URL and Title should not be too long.
On a search results page, only 60 characters of the title are shown and there is no reason why the title should be longer than that.

E.g.,

the URL can be https://www.example.com/blog/implement-service-discovery-spring-cloud.html
the title can be Implement Service Discovery with Spring Cloud | Abhinav's Blog

4. H1 Heading

The heading is similar to the title. However, if your title is shorter on purpose, you can elaborate on it with the heading.
Headings are more relevant to human readers and should always make sense.
Another trick you can include is to use alternate versions of your long-tail keywords in the heading or secondary keywords.
For E.g. if my article uses Netflix's Eureka, I could also include "Netflix Eureka" in the heading.
So my heading becomes - How to Implement Service Discovery with Netflix Eureka and Spring Cloud

Note: Some SEO tools also recommend that other heading levels should contain keywords. This is optional in my opinion and should only be done if it doesn't affect the readability of the sub-headings.

5. Meta Description

A meta description is a short description of the page that is shown in search results. This needs to focus more on human readers than on search engines.

It will add very little to SEO but helps a lot with the click-through rate.
The meta-description should be short, clear, and should fit in the space.
The number of characters in the meta description should be around 150 characters. (This is not something you can control and may change in the future)

6. Images, Videos, and Audio

For search engines, images are a black box.
However, as we know, now we can even search for images. So how does that work?

Images are understood by search engines using the following ways:

The most basic connection they can make is between the image and the page it is on.
Better information about the image is provided by the alt text. But be careful with the alt text. Its purpose is to provide a correct description of the image for humans. It is not just an SEO strategy. Anyways, always include alt text in your images.
The image URL or src attribute can also be used to provide information about the image. This is one of the most overlooked points when it comes to image SEO.
The content surrounding the image like a leading or trailing text can also be used to provide information about the image.
An advanced strategy is to use an enhanced markup for images. Refer to Schema.org for more information.

7. Page speed

There are a few things technical things to take care of that support a better page ranking. Some of these will not be completely in your hands if you write on someone else's website but they are good to know.

Slow pages are not ranked high by search engines and are not liked by users.
Another important factor is your blog being mobile-friendly. Page rankings are maintained separately for mobile and desktop so that the user can get the best experience. This means that if your website is not mobile-friendly, there is a chance your blog will be ranked lower on mobile than on desktop.
Do not use images hosted on external websites. Dependency on external images is not good because they could be deleted at any time or may load slower if not CDN-cached by the owner.
It's best to download the images and upload them again on your blog. Needless to say, the images should not be protected by copyright.
Use optimized images. Do not use high-resolution images which will take a lot of time to load.

8. Cross-posting

Cross-posting or not cross-posting is a separate discussion. But if you do cross-post, keep a few things in mind.

The original post should appear on your personal/company blog.
All other posts should have canonical links to the original post.
Do not bother posting on other websites which do not allow canonical links.

9. Internal Linking

Link building is an important part of SEO.

Internal links are links to pages on your website. They are important to tell search engines how pages on your website are related to each other.
This means a new blog can be used to bring traffic to older blogs. However, this only works if the users also find this linking useful.

Let's look at a few small ways to improve internal linking.

Links to an old blog should be relevant to your current blog. A user should find it useful to click the link.
Anchor text describes the link for the user as well as the search engine. Link texts like "Read More" or "Continue Reading" are not good. Rather, use a version of the page title. This is true for any kind of link on a blog.
The linked page should be of good quality too. If the user closes the page right after clicking the link, search engines will not consider the linking relevant.

10. Inbound Linking

Inbound links are links from other websites to your blogs. They are important to tell search engines how pages on your website are related to other websites. They act as a way to review the quality of your website.

This is not an easy part but there are some important things to understand:

Inbound links from only the relevant sites count. So there is no need to go to the whole internet and try to place a link to your blog on every social media page.
Find communities that are relevant to your blog and place links to your blog on them. For e.g., Hacker News, Reddit (relevant subreddits), etc.
Encourage people to share your blog on social media. Social share links will be helpful to people who are interested in your blog. It brings traffic and is likely to reach a relevant audience. A sentence asking people to share your blog on social media goes a long way.

Thank you for reading. Hopefully, these tips can form a checklist for us when publishing blogs. If you liked the article, please do not forget to comment, react and/or share the blog with others. If you want to connect with me, you can find me on Twitter.

12 Common uses of Java Streams

Abhinav Pandey — Wed, 09 Mar 2022 07:29:38 +0000

Java Streams API was introduced in Java 8. Its aim is to provide a less verbose and concise way to carry out common operations on collections of objects.

Although it can be hard to get used to, the Java Streams API is very powerful and can be used to implement complex algorithms.

In this article, we will talk about some common use cases of the Java Streams API.

For those of us not proficient with the Streams API, the goal should be to keep these use cases in mind and whenever we come across one of them, we should try to implement them using Streams rather than the traditional way.

Let's establish some basics first.

stream() - creates a stream from a collection
collect() - collects the stream into an object. The object can be a collection, primitive, or a custom class.
Collectors - a class which provides (a lot of) static methods for collecting streams. We will use some of these below. Refer to the documentation for full reference.

These are the most popular stream operations and will be used in the rest of this tutorial.

Use cases

Let's look at some use cases of streams:

1. Filtering

Used for removing values from a Collection based on a condition.
filter() method is used to filter the elements of a Collection based on a condition. Only matching elements are retained.

E.g. - Remove all odd numbers from a list.

List<Integer> evenNumbers = originalList.stream()
        .filter(n -> n % 2 == 0)
        .collect(Collectors.toList());

2. Preprocessing

Useful when each value in the collection needs to be changed in place.
map() method is used to apply a function to each element of a Collection and return a new Collection of the computed values.

E.g. Convert each value to its square.

List<Integer> squares = originalList.stream()
        .map(n -> n * n)
        .collect(Collectors.toList());

3. Conversion

Useful when we want to convert a Collection to another Collection.
There are multiple ways to achieve this and let's see them.

In general, as mentioned above, we can use map() and collect() methods to convert a Collection to another Collection.

Example 1. Create a Map from a List.

Convert a list of strings to a map of string and length.

Map<String, Integer> wordLengths = words.stream()
        .collect(Collectors.toMap(
                word -> word,
                word -> word.length()));

Example 2. Convert list to sets.

This is a common use case for removing duplicates.
Further, if we want to put the elements back to a list, we can use the stream() and collect() methods twice.

Convert a list of strings to a list of unique strings.

// if we want to collect to a set
Set<String> uniqueWords = words.stream()
        .collect(Collectors.toSet());

// OR

// if we want to start and end as a list
List<String> uniqueWords = words.stream()
        .collect(Collectors.toSet()).stream().collect(Collectors.toList());

Example 3. Convert a list of Products to a list of their names. (Flattening)

List<String> productNames = products.stream()
        .map(product -> product.getName())
        .collect(Collectors.toList());

4. Reduction

Reduce a Collection to a single value.
reduce() method is used to apply a function to each element of a Collection and return a single value.

Note that since the reduce() method returns a single value, it is not possible to use it to return a Collection.

E.g. Sum all the values in a list.

int sum = numbers.stream()
        .reduce(0, (a, b) -> a + b);

5. Grouping

Group elements of a Collection based on a condition.
Collectors.groupingBy() method is used to group elements of a Collection based on a condition.

E.g. Group all products into lists of Products by their category.

Map<String, List<Product>> productsByCategory = products.stream()
        .collect(Collectors.groupingBy(product -> product.getCategory()));

6. Finding

Finding the first or any element of a Collection which matches a condition.
findFirst() and findAny() methods are used to find the first or any element of a Collection which matches a condition.

This is typically similar to linear search.

E.g. Find the first word in a list which is longer than 5 characters.

Optional<String> firstLongWord = words.stream()
        .filter(word -> word.length() > 5)
        .findFirst();
// Note that findFirst() and findAny() methods return Optional<T> objects.

7. Sorting

Sort elements of a Collection.
sorted() method is used to sort elements of a Collection.

In general, Collections.sort() is enough to sort a Collection. We can use sorted() specially if we want to follow it with another operation.

E.g. Sort a list of numbers in ascending order and then return the first k elements.

List<Integer> topK = numbers.stream()
        .sorted()
        .limit(k)
        .collect(Collectors.toList());

8. Partitioning

Partition elements of a Collection based on a condition.
Collectors.partitioningBy() method is used to partition elements of a Collection based on a condition.

Partitioning is similar to grouping except it returns two Collections - one for elements matching the condition and one for elements not matching the condition.

E.g. Partition students into passing and failing.

 Map<Boolean, List<Student>> passingFailing = students
        .stream()
        .collect(Collectors.partitioningBy(s -> s.getGrade() >= PASS_THRESHOLD));

9. Counting

Count the number of elements matching a condition.
count() method is used to count the number of elements matching a condition.

E.g. Count the number of words in a list which are longer than 5 characters.

long count = words.stream()
        .filter(word -> word.length() > 5)
        .count();

10. Range

Create a range of values.
range() method is used to create a range of values.

There are special classes for creating streams of particular types - IntStream, LongStream, DoubleStream, and Stream.

These classes are useful when dealing with primitive numeric types. Internally, they use Arrays.stream() to create the stream.

E.g. Create an array of numbers from 0 to 10.

int[] numbers = IntStream.range(0, 10).toArray();

11. Matching

Match elements of a Collection against a predicate(condition).
Methods such as anyMatch(), allMatch(), and noneMatch() are used to match elements of a Collection against a predicate and return a boolean value.

E.g. Check for products with a price greater than 10.

// true when all elements match the predicate
boolean allMatch = products.stream()
        .allMatch(product -> product.getPrice() > 10);

// true when any element matches the predicate
boolean anyMatch = products.stream()
        .anyMatch(product -> product.getPrice() > 10);

// true when no elements match the predicate
boolean noneMatch = products.stream()
        .noneMatch(product -> product.getPrice() > 10);

12. Joining

Join elements of a Collection into a String.
Collectors.joining() method is used to join elements of a Collection into a String.

E.g. Join all the words in a list into a single string.

String joinedWords = words.stream()
        .collect(Collectors.joining(" "));

Thats it for the common scenarios. There are other less common scenarios you can explore on your own:

Parallel Streams
Statistics
Custom Collectors.

Advantages of Streams

Less Verbose Code - Reduces the amount of code needed to process a Collection.
Lesser intermediate variables - Intermediate variables can be an opportunity to make mistakes. Having fewer of them can help us avoid unexpected bugs.
Intuitive code - Some developers will disagree that streams are more intuitive than other methods. However, they are much more intuitive than other methods once we get used to them. Reading 5 lines to understand that we are filtering and removing products from a list isn't intuitive compared to reading just a filter() method.

Thanks for reading. I hope you enjoyed this article.
There are many more cases where streams can be used which are not covered in this thread. Feel free to add any common scenario I missed.

If you want to connect with me, you can find me on Twitter.

Retry Pattern in Microservices

Abhinav Pandey — Fri, 25 Feb 2022 07:16:30 +0000

In a microservices architecture, the retry pattern is a common pattern for recovering from transient errors.

In a distributed system, some examples of these errors are:

Network failure

An application lost connectivity for a short period of time.

Component failure

A component is unavailable for a short period of time. This usually happens during maintenance or automatic recovery from a crash.

Component overload

A component is overloaded and cannot accept new requests for a short period of time. This could also be due to a throttling or rate-limiting implementation.

As you can see, the above errors are self-healing. In this case, it makes sense for the client to retry the request (immediately or after a delay) rather than logging the error and aborting the request.

Retry Pattern

Retry patterns can be implemented in a number of ways. However, each implementation needs to take care of the below considerations:

Identifying Transient Errors

The first important step is to identify if the error is transient or not. This will let us decide if the request needs to be repeated or the error should be logged.

For example, a connection timeout indicates a network error and should be retried.
On the other hand, an authentication failure isn't going to go away after a few seconds and should not be retried.

Retry Delay

The second important step is to decide how long to wait before retrying the request.

For real-time tasks like web page request, the delay should be as short as possible, retries should be less, and errors may provide better experience than delayed retries. However, for long-running or background tasks like sending an email notification, the delay should be long enough to allow the system to recover.

Let's discuss more about delay timings.

Backoff Time

Backoff time is the time to wait before retrying the request. The backoff time is calculated based on the number of retries and the delay between retries.
This can be used to avoid flooding the system with retries.

It can be broadly classified into these categories:

Constant/0 backoff time

The backoff time is the same for all retries. This is good for rare network failures or low load services.

Incremental backoff time

The backoff time is calculated based on the number of retries. Some examples of incremental backoff time are linear, exponential, and fibonacci. Exponential is the most common where the time doubles every time the retried request fails.

Random backoff time

The backoff time is calculated randomly between the minimum and maximum backoff time or through a more complex function which is guaranteed to produce random delays. This is useful for avoiding thundering herd problems - in short, if a large number of requests hit at the same time and this is the reason for the failure, it won't help if their retries also hit at the same time. Randomness in retry delays will avoid this.

Implementing a Retry Pattern

A simple retry implementation will consist of the below steps:

Identify transient conditions - E.g. which response codes, errors or network exceptions indicate a transient error.
Decide backoff time and algorithm - as described above.
Decide maximum number of retries.
While retry count is less than the maximum count, retry the request until the request succeeds.
If retries are exhausted, log the error and abort the request.

Existing implementations

Before implementing our own retry pattern, we can leverage existing implementations. Let's see where we can look for existing implementations:

Clients and SDKs. There are many existing solutions for retrying requests. Depending on the service you are calling, the retry functionality may already be implemented. For example, the Apache Kafka client provides retry functionality using the retry configuration option. Similarly, a large number of popular cloud SDKs already provide retry functionality.
Language and tool support. The retry pattern is a common pattern in many languages and tools. For example, the Python requests library provides retry functionality.
Framework-specific libraries. The retry pattern is a common pattern in many libraries. For example, in Spring applications, Spring Retry and Resilience4J are popular retry libraries.

Thanks for reading! This should give you an idea of Retry Patterns. If you want to connect with me, you can find me on Twitter.

Template Method Design Pattern

Abhinav Pandey — Tue, 22 Feb 2022 05:40:08 +0000

Template method pattern is a design pattern that allows you to define a skeleton of an algorithm in an operation, deferring some steps to subclasses.

In simpler terms, this is like making a to-do list which multiple implementations follow in their own way.

Let's start with some terminology:

Template Method - A template method is a method that defines the skeleton of an algorithm in an operation.
Concrete Template - A concrete template is a class that implements the template method.
Client - A client is a class that tells the template method which concrete template to use.
Abstract Steps - An abstract step is a method that is defined in the template method but is left to be implemented by the subclasses.

A real world example

Let's think about an example of this in the real world. We will compare this to a digital payment system.

The payment system has a payment gateway which is a template method.
The customer can use the payment gateway to make a payment.
The payment gateway has a few steps that are defined in the template method - validating the payment, transferring the money and updating the database.
However, the implementation of these steps is decided by the exact payment option that the customer chooses - Credit Card, Net Banking, PayPal, etc.

Let's code this up

The Template Method

Let's create an abstract class called PaymentGateway:

public abstract class PaymentGateway {
    public final void makePayment() {
        validatePayment();
        transferMoney();
        updateDatabase();
    }
    protected abstract void validatePayment();
   protected abstract void transferMoney();
   protected abstract void updateDatabase();
}

Here we have a template method makePayment() which calls the three steps of the payment process. None of the steps are implemented in the abstract class.
This method defines a template that its subclasses must follow to make a payment.

We could also have provided a default implementation of the steps in the abstract class for reusability but this is an implementation decision.

To make it even more strict, we have made the template method final so that it cannot be overridden. It is a good practice to make the template method final, but it is not a requirement.

The Concrete Templates

Let's create concrete templates for the payment gateway. We will create two concrete templates:

CreditCardPaymentGateway - This template will implement the steps of the payment process for credit card payments.
PayPalPaymentGateway - This template will implement the steps of the payment process for PayPal payments.

public class CreditCardPaymentGateway extends PaymentGateway {
    public void validatePayment() {
        // check if the credit card is valid
        // check if the credit card has sufficient balance
        // check if the credit card is expired
    }
    public void transferMoney() {
        // transfer the money from the credit card to the bank account
    }
    public void updateDatabase() {
        // update the database with the transaction details
    }
}

public class PayPalPaymentGateway extends PaymentGateway {
    public void validatePayment() {
        // check if the PayPal account is valid
        // check if the PayPal account has sufficient balance
    }
    public void transferMoney() {
        // transfer the money from the PayPal account to the bank account
    }
    public void updateDatabase() {
        // update the database with the transaction details
    }
}

The Client

To choose the payment gateway, we could use a factory. In our case, the factory will return the appropriate payment gateway based on the customer's payment option.

public class PaymentGatewayFactory {
    public PaymentGateway getPaymentGateway(String paymentOption) {
        if (paymentOption.equals("credit card")) {
            return new CreditCardPaymentGateway();
        } else if (paymentOption.equals("paypal")) {
            return new PayPalPaymentGateway();
        } else {
            throw new IllegalArgumentException("Invalid payment option");
        }
    }
}

The client will use the factory to get the appropriate payment gateway and make the payment.

public class PaymentGatewayClient {
    public static void main(String[] args) {
        PaymentGatewayFactory factory = new PaymentGatewayFactory();
        PaymentGateway gateway = factory.getPaymentGateway("credit card");
        gateway.makePayment();
    }
}

When the makePayment method is called on the payment gateway, the template method defined in the abstract class is called.
However, the concrete methods of CreditCardPaymentGateway are called to execute the internal steps.

Advantages of the Template Method

It provides a flexible way to change the implementation of internal steps without missing any of the steps.
It provides a flexible way to add more implementations in the future.

Template method pattern is used in Java for many out-of-the-box implementations. For example, InputStreamReader is a template method pattern implementation.

Thanks for reading! This should help you understand the concept of the template method pattern. Stay tuned for more design patterns.
If you want to connect with me, you can find me on Twitter @abh1navv