Forem: Kaleem

Style guide to write git history

Kaleem — Tue, 24 Sep 2024 13:44:52 +0000

A simple style guide to write maintainable git history.

Commits guide

Feat

Use the feat prefix for feature-related changes.

feat: add support for purchase order

Chore

Use the chore prefix for non-feature-related changes.

chore: rename product rental file

Refactor

Use the refactor prefix for refactoring changes.

refactor: file improvements for product rent section

Deploy

Use the deploy prefix for deployment-related changes.

deploy: trigger deployment

Docs

Use the docs prefix for documentation-related changes.

docs: update starting guide

Fix

Use the fix prefix for bug fixes or error corrections.

fix: resolve issue with user a glitching on login

Branches guide

For large features, divide your branch into smaller modules and use suffixes to continue changes.

feat/product-purchase-1

feat/product-purchase-2

feat/product-purchase-3

feat/product-purchase-4

If product purchase is a big module then you can use suffix numbers.

You will make changes in product-purchase-1, merge it in the major branch, and then start with product-purchase-2 from the major branch.

General guide

Create PRs for your changes; do not push directly to the major branch.
Be consistent with your approach of naming branches and commits.
Use present tense for commit messages: feat: add products for rental section instead of feat: added products for rental section.
In your PR, each commit should relate to an specific change, rather than combining multiple changes into one large commit.
For branches, use "/" slash notation e.g feat/product-purchase-1 for commits use ":" colon notation e.g chore: rename product rental file.
Utilize squash merges whenever appropriate (combines all commits into a single commit upon merging).

How to easily migrate Heroku Postgres database between apps.

Kaleem — Sat, 21 Oct 2023 19:36:55 +0000

There are two ways to copy data between databases: restore backup or copy command.

We will be performing a database migration from the myapp-prod app to the myapp-test app that is copying the schema (structure) and data from the source to target.

Restore backup

Copies specified backup version of the database.

heroku pg:backups:capture --app myapp-prod

Creates a backup in the app myapp-prod. The Heroku console will tell you backup ID version b001 in this case.

heroku pg:backups:restore myapp-prod::b001 DATABASE_URL --app myapp-test

Second command: Copy from myapp-prod app backup id b001 (latest backup) to default DATABASE_URL of the app myapp-test.

Direct copy

Copies the latest state of the database.

heroku pg:copy myapp-prod::DATABASE_URL DATABASE_URL --app myapp-test

Copy from myapp-prod app latest default database DATABASE_URL copy to app myapp-test default database DATABASE_URL.

Here DATABASE_URL is the name of the default database of your Heroku apps.

Thanks :)

Reference
https://devcenter.heroku.com/articles/heroku-postgres-backups#restore-a-backup

Easy way to Import and Export Heroku Postgres Databases

Kaleem — Fri, 03 Feb 2023 18:12:21 +0000

This article will show how to export (download) the Heroku Postgres database from one Heroku app and import it (from a local machine) to another app.

Export

To export the data from your Heroku Postgres database, create a backup and download it:

Make sure you have
Heroku Cli
globally installed.

You can export your database by specifying your Heroku app name, here Heroku app name Is example-app

 heroku pg:backups:capture --app example-app 
 heroku pg:backups:download --app example-app

It will first capture and download the database in a dump file called latest.dump.

Now let us see how we can import latest.dump into another app Heroku app called example-app2

Import

To import the latest.dump, we need to upload the latest.dump somewhere, so it is accessible via HTTP.

we cannot directly specify the path from our local machine to Heroku.

Heroku website suggests using Amazon S3 to generate a signed URL, but we will use dropbox here since Amazon S3 is not freely available (it requires you to put your card details)

heroku pg:backups:restore <HTTP_DUMP_FILE_URL> DATABASE_URL --app example2-app

This command imports the dump file which is found in HTTP_DUMP_FILE_URL into example2-app.

Generate Http URL for Dump file

Step 1) Upload the dump file to dropbox
Step 2) Now Generate the URL for dump file
Step 3) Clean up the URL, remove the URL param so the file ends with latest.dump
- If generated file is https://dl.dropboxusercontent.com/s/asdasdasd/latest.dump?dl=0 then remove ?dl=0 so it becomes https://dl.dropboxusercontent.com/s/asdasdasd/latest.dump

The import command will look like this:

heroku pg:backups:restore 'https://dl.dropboxusercontent.com/s/asdasdasd/latest.dump' DATABASE_URL --app example2-app

This imports a latest.dump found in the link into example2-app; make sure to replace my URL with your URL and put the URL between single quotes.

You will see the following warnings, type your app name to continue.

 ›   Warning: heroku update available from 7.60.1 to 7.67.1.
 ▸    WARNING: Destructive Action
 ▸    This command will affect the app `example2-app`
 ▸    To proceed, type `example2-app` or re-run this command with --confirm example2-app

As it finishes, it should give a success message.

Restoring... done

Now you can delete the dump file from dropbox. Well, thats it!

Thanks for reading. I hope you found this article help.

References

https://stackoverflow.com/questions/46178874/heroku-pgbackupsrestore-from-local-database

https://devcenter.heroku.com/articles/heroku-postgres-import-export#capture-and-download-backup-with-pgbackups

https://zapier.com/blog/generate-direct-dropbox-link/

https://www.youtube.com/watch?v=xo0z4LQEhyI

Performance Benchmarking: String and String Builder

Kaleem — Fri, 12 Aug 2022 23:37:00 +0000

In this article, we will do a performance benchmarking of String and StringBuilder classes in Java and discuss how to modify strings efficiently.

Strings in Java are immutable; modifying the String creates a new String object in the heap memory with the latest content, and the original String is never changed.

Immutability

  String str = "You cannot modify "
  str = str + "me"

When we append the value "me" to the str variable, a new String object gets created with the new value You cannot modify me and gets assigned to str. The original string You cannot modify does not change.

Performance

Frequently modifying strings such as using the + operator has significant performance issues, every time the + append is used, a new String object gets created and reassigned.

To modify the strings efficiently, we should consider the StringBuilder, which changes the string and does not create any extra object in the heap memory.

String Modification

Use the StringBuilder class to modify the string; this does not create a new String object but changes the existing one.

  StringBuilder str = new StringBuilder("You can modify.");
  str.append("me");

Performance Benchmarking

Consider the concatenation operation performance benchmark with the String and StringBuilder; consider the following.

Consider 10 data points
- inputSample = [100k, 200k, 300k, 400k, 500k, 600k, 700k, 800k, 900k, 1m].
- Start with an empty string and concatenate the string "a" n time, where n = inputSample[i] i.e n = 700k.
- We want to know how long it takes to concatenate a string "a" n time for the inputSample using String and StringBuilder.

String Class

public class StringBenchmark {
    public static void main(String[] args) {
        String appendCharacter = "a";

        int inputSample[] = new int[]{
                100000, 200000, 300000, 400000,
                500000, 600000, 700000, 800000,
                900000, 1000000};

        for (int n : inputSample) {
            double startTime = System.nanoTime();
            testStringAppend(n, "", appendCharacter);
            double endTime = System.nanoTime();
            double duration = (endTime - startTime) / 1000000000;
            String seconds = String.format("%.2f", duration);
            System.out.println("n = " + n + ": seconds: " + seconds);
        }
    }

    static void testStringAppend(int n, String str, String appendCharacter) {
        for (int i = 1; i <= n; i++) {
            str += appendCharacter;
        }
    }
}

String Class Results

n = 100000: seconds: 0.38
n = 200000: seconds: 0.99
n = 300000: seconds: 2.14
n = 400000: seconds: 3.74
n = 500000: seconds: 5.79
n = 600000: seconds: 8.28
n = 700000: seconds: 11.16
n = 800000: seconds: 14.65
n = 900000: seconds: 18.29
n = 1000000: seconds: 22.43

StringBuilder Class

public class StringBuilderBenchmark {
    public static void main(String[] args) {
        String appendCharacter = "a";

        int inputSample[] = new int[]{
                100000, 200000, 300000, 400000,
                500000, 600000, 700000, 800000,
                900000, 1000000};

        for(int n: inputSample){
            double startTime = System.nanoTime();
            testStringAppend(n, new StringBuilder(""), appendCharacter);
            double endTime = System.nanoTime();
            double duration = (endTime - startTime)/1000000000;
            String seconds = String.format("%.7f", duration);
            System.out.println("n = "+n+": seconds: "+seconds);
        }
    }
    static void testStringAppend(int n, StringBuilder str, String appendCharacter){
        for(int i = 1; i <= n; i++){
            str.append(appendCharacter);
        }
    }
}

n = 100000: seconds: 0.0027
n = 200000: seconds: 0.0013
n = 300000: seconds: 0.0015
n = 400000: seconds: 0.0015
n = 500000: seconds: 0.0018
n = 600000: seconds: 0.0022
n = 700000: seconds: 0.0026
n = 800000: seconds: 0.0029
n = 900000: seconds: 0.0032
n = 1000000: seconds: 0.0036

Execution Time: Append

Input (n)	String (S)	String Builder (S)
100k	0.38	0.0027
200k	0.99	0.0013
300k	2.14	0.0015
400k	3.74	0.0015
500k	5.79	0.0018
600k	8.28	0.0022
700k	11.16	0.0026
800k	14.65	0.0029
900k	18.29	0.0032
1m	22.43	0.0036

Conclusion

StringBuilder executes significantly faster than the String class when performing the concatenation or modification operations.
Modifying a String creates a new String in the heap memory. To change the content of the String, we should consider the StringBuilder class.
Any attempt to modify the String class creates a new object in the heap memory, which has significant performance drawbacks.
StringBuilder is ideal for modifying string content; it does so without creating any extra objects in the memory.

5 Reasons why Java developers love Angular!

Kaleem — Thu, 21 Jul 2022 21:12:37 +0000

Here are five reasons why Java developers love Angular. The list is not exhausted but merely an observation from my own experience.

Note this article is not against other front-end frameworks like Vue, React, or Svelte; however a reflection on my encounters using Angular with Java.

1) Dependency Injection

If you have been around the Java ecosystem (Spring Boot, JAX-RS) you must have at least heard of Inversion of control or DI dependency injection.

`In software engineering, dependency injection is a technique whereby one object (or static method) supplies the dependencies of another object. A dependency is an object that can be used (a service)`.

What the hell that mean? Consider a Hero component in angular hero.component.ts the component needs data to display, consider using an API to fetch the data. Can’t we directly call the API from the component? We could but should we?

We use an abstraction layer like a service heroes.service.ts to provide us the data the service could call actual API or Mock some data. The hero component is responsible display the result rather than fetch it. The service provides data to the component. Thus the service is a Dependencyon the component to use the service component needs to Injectit.

But why do we need to Inject service? Can’t we create an object of the service to use it? Since the framework is responsible to Inject the service it is easy to unittest the component by injecting a mock service. Mock service returns desired data from the service and test component in isolation rather than relying on service to test the component.

`Mocking is primarily used in unit testing. An object under test may have dependencies on other (complex) objects. To isolate the behavior of the object you want to replace the other objects with mocks that simulate the behavior of the real objects. This is useful if the real objects are impractical to incorporate into the unit test.

In short, mocking is creating objects that simulate the behavior of real objects.`

Most of these Angular concepts are out there in Java be it Dependency injection, Unit testing with JUnit and Mockito, MVC.

2) MVC Architecture

Yes, you heard it right! Both Angular & Java have MVC Model View Controller design pattern. If you have any familiarity and awareness with MVC from either Java or C# you will quickly appreciate & recognize the patterns and fall in love with them in the Angular.

To quickly compare patterns Both Angular and Java have Classes and Interfaces to represent the Model, Controller is like a component in the Angular and An API endpoint in Java. Both of them use services and Dependency injection to fetch data.

3) Typescript

Did you know when Angular 2 was to be released the Google had planned to create a separate language for Angular? But They collaborated with Microsoft to integrate Typescript with Angular!

For a competent Java developer, TypeScript syntax is relatively straightforward. Like Java, TypeScript syntax has mechanisms to define enums, iterative loops, methods, classes, interfaces, and constructors. None of these topics are foreign to anyone who has knowledge of the javac utility. But while the key concepts are all the same, the TypeScript syntax is decidedly different. (This can make transitioning from Java to TypeScript a frustrating experience, as tasks once simple in Java can trigger esoteric errors when you compile the corresponding TypeScript).

4) Similar Syntax and Feel

Both TypeScript and Java embrace the concept of a class in order to implement object-oriented concepts. Similarities between the two include the fact that classes can have methods, constructors, and variables, although each of these items is declared in a slightly different way. The following example shows the difference between declaring a simple Java class and a simple TypeScript class

What is take away? Classes, Interface in Java, Angular (Typescript) looks very identical and very similar. Having a background experience in one of the languages will immensely help you understand another one.

5) Type Support and Checking

With Angular, you have no choice but to use Typescript features out of the box! So you don’t have to worry about passing the wrong argument type to the function pass a stringto a number expecting function typescript will tell you right away! Type checking is underestimated with Java since you cannot even imagine passing a string to a number expecting argument in Java. That is not the case with Javascript. Typescript fills the gap by extending javascript and is the superset of Javascript and adds type support similar to that of Java. Having Type support is very powerful and meaningful it saves a lot of time when debugging.

That is it for now. Of course, The reasons state are merely a reflection of my experiences and why I believe one of the reasons Java developers tend to like Angular and stay with it.

[1]: A quick intro to Dependency Injection: what it is, and when to use it

https://www.freecodecamp.org/news/a-quick-intro-to-dependency-injection-what-it-is-and-when-to-use-it-7578c84fa88f/

[2]: What Java developers need to know about TypeScript syntax

https://www.theserverside.com/tutorial/What-Java-developers-need-to-know-about-TypeScript-syntax#:~:text=Java%20has%20methods%2C%20while%20TypeScript,t%20have%20typed%20method%20parameters.

[3]: What is Mocking?

https://stackoverflow.com/questions/2665812/what-is-mocking

When to use HashMap instead of Loop Part 2

Kaleem — Mon, 27 Jun 2022 09:11:10 +0000

In the previous Article When to use HashMap instead of Loop, I discussed how HashMap could be effective instead of a loop or filter

In this part 2, we discuss a practical use case where HashMap applies.

A Practical Use Case

Given users and tasks, each user has exactly one task. The goal is to group users by tasks.
Imagine there are n users and t tasks, and you need to group users based on the tasks. As an output, every task will have a list of users who are assigned the task.

Input

users: [ {id: 101, name: "Josh", taskId: 10}]
tasks: [ {id: 10, title: "Clean House"} ]

Output: { 10 => [ { id: 101, name: 'Josh', taskId: 10 } ] }

Using Arrays

const users = [
    {id: 101, name: "Josh", taskId: 10},
    {id: 102, name: "Mosh", taskId: 10},
    {id: 103, name: "Eli", taskId: 11},
    {id: 104, name: "Jad", taskId: 12},
    {id: 105, name: "Susan", taskId: 12}
];

const tasks = [
    {id: 10, title: "Clean House"},
    {id: 11, title: "Deploy App"},
    {id: 12, title: "Learn Coding"}
]

let usersByTask = new Map();

for(let i = 0; i < users.length; i++){
    let user = users[i];
    for(let j = 0; j < tasks.length; j++){
        let task = tasks[j];
        if(task.id === user.taskId){
            if(usersByTask.has(task.id)){
                usersByTask.get(task.id).push(user);
            }
            else{
                usersByTask.set(task.id, [user]);
            }
            break;
        }
    }
}
console.log(usersByTask)

In the above solution, we explore all the tasks for each user to see if the task belongs to the user. Time complexity is O(n*t) where n and t are numbers of users and tasks, respectively.

Identifying the bottleneck

Why should HashMap be considered?

If you look closely, we are unnecessarily searching for tasks; note we must access all the users, so the first loop cannot be optimized (since we need to check for all the users)

Is there a better way to find which task a user belongs to without visiting all the tasks?

Yes, there is! Represent the tasks as a HashMap instead of an Array. Task id will be the key, and task object will be the value.This means that given a user u, we can find the task that belongs to u without visiting all the tasks.

A Better solution

const users = [
    {id: 101, name: "Josh", taskId: 10},
    {id: 102, name: "Mosh", taskId: 10},
    {id: 103, name: "Eli", taskId: 11},
    {id: 104, name: "Jad", taskId: 12},
    {id: 105, name: "Susan", taskId: 12}
];

const tasks = new Map();
tasks.set(10, {id: 10, title: "Clean House"});
tasks.set(11, {id: 11, title: "Deploy App"});
tasks.set(12, {id: 12, title: "Learn Coding"});

let usersByTask = new Map();
for(let i = 0; i < users.length; i++){
    let user = users[i];
    let taskId = user.taskId;
    if(usersByTask.has(taskId)){
        usersByTask.get(taskId).push(user);
    }
    else{
        usersByTask.set(taskId, [user]);
    }
}
console.log(usersByTask)

Once we identified the bottleneck, the bottleneck was repeatedly searching tasks.

We resolved the bottleneck by storing tasks into a HashMap instead of the Array.

If you are a beginner at HashMap, I encourage you to read and understand the code and be patient.

Conclusion: HashMap is very handy. Once you identify the bottleneck when searching in a list or Array next step is to convert the Array into HashMap for quick access.

Check the first part if you have not.
When to use HashMap instead of Loop

That's it. If you found this helpful, feel free to reach out on Twitter @kaleemniz

When to use HashMap instead of Loop

Kaleem — Tue, 21 Jun 2022 22:37:17 +0000

Many programmers use a loop or filter where HashMap data structure could be considered.

Finding user by id using Loops

let userIdToBeSearched = 103;
const users = [
    {id: 101, name: "Josh"},
    {id: 102, name: "Mosh"},
    {id: 103, name: "Eli"},
    {id: 104, name: "Jad"},
    {id: 105, name: "Susan"}
];

let user = null;
for (let i = 0; i < users.length; i++) {
    if (users[i].id === userIdToBeSearched) {
        user = users[i];
        break;
    }
}

if (user) {
    console.log("User Found: ", user);
} else {
    console.log("user does not exit with id: ", userIdToBeSearched);
}

The above solution has a time complexity of O(n), where n represents the number of users. If there are 1 thousand users, in the worst case, we will search every user to find a match.

Considering user id will be unique for each user, this is a good indication to use a HashMap instead of a loop since all keys in the Map are Unique.

Finding user by id using Map

let userIdToBeSearched = 103;
const users = new Map();
users.set(101, {id: 101, name: "Josh"});
users.set(102, {id: 102, name: "Mosh"});
users.set(103, {id: 103, name: "Eli"});
users.set(104, {id: 104, name: "Jad"});
users.set(105, {id: 105, name: "Susan"});

if(users.has(userIdToBeSearched)){
  console.log("User Found: ", users.get(userIdToBeSearched));
}
else {
  console.log("user does not exit with id: ", userIdToBeSearched);
}

When using a Map, it takes constant time O(1) to find the user! All great, but note constructing the HashMap from the array still requires O(n) time.

In conclusion, use Map when frequently searching based on the unique field such as id. Please note Map cannot be used in case of searching based on the non-unique field such as name

Thank you for reading! Check the part 2 where we discuss A Practical Use Case of HashMaps. When to use HashMap instead of Loop Part 2