
Algorithm Complexity is the favorite interview topic of FAANG companies and vital for choosing tons of available solutions for a single problem. If you go by textbook definitions and concepts, it will leave you scratching your head in most cases. This blog post will put the Algorithm Complexity in its simplest form, required to meet the purpose of real-life coding challenges and interviews.


**Disclaimer:**
* The concepts explained here might not help you crack competitive examinations like GATE as they focus on mathematical definition rather than practical usage. But this will simplify things to make those concepts understand easily.
* The pre-requisite to this blog is an understanding of various sorting algorithms, arrays, data structures (stack, queue, binary tree), and recursion.

## Why Algorithm Complexity?
To understand the need for Algorithm Complexity, let’s go for purchasing a Car. To simplify things, let’s assume we’ve already fixed a budget and filtered two cars. Both the vehicles share the same feature set and price; which one you’ll pick? In most cases, you’ll go for the most fuel-efficient car, which is one of the performance criteria. Similarly, Algorithm Complexity represents an algorithm’s performance criteria and helps us pick from various available solutions.

## What is Algorithm Complexity?
Algorithm Complexity essentially represents the rate of increase in time (taken by the algorithm) as the input size increases. For example, how much time a web page takes to load when 5 users are using it versus 5 Million at the same time? And yes, this is relatable to functions we all learned in school, also known as Asymptotic Functions (see [this article](http://www.nlreg.com/asymptot.htm) for a refresher). Therefore, Algorithm Complexity is represented in Asymptotic Annotations; Big Omega, Big O, and Big Theta.

**Note:** There are 2 complexities for an algorithm, one is Time, and another is Space. We’re not going to talk about Space complexity as it’s no longer an issue with a wide availability of high memory hardware (hosts) cheaply. It used to be a constraint when memories were still in MBs, and we were still using floppies.

##Big Omega, Big O, and Big Theta
**Big O (or simply ‘O’)** describes an upper bound on time. Meaning, the algorithm will not take more than Big O time in any case. It can take less time than Big O (on specific input values) but not more than Big O in any case. For example, searching number 5 in the array {1, 2, 3, 4, 5} will take 5 iterations, while searching number 1 will take 1 iteration. Since Big O describes the upper bound, the time complexity for searching a number in an array of size N is O(N).

**Big Omega (or simply ‘Ω’)** describes a lower bound on time. Meaning, the algorithm will not take less than Big Ω time in any case. It can take more time than Big Ω (on specific input values) but not less than Big Ω. In the array example above, the Big Ω complexity is Ω(1) as searching for the number won’t take less than 1 iterations.

**Big Theta (or simply ‘Θ’)** describes tight bound on time. Meaning, the algorithm will take exactly Big Θ time, not less or more (+/- a constant time). For example, a web page will be displayed within 5 milliseconds if the number of users is between 50–60. In this case, the complexity will be Θ(55) with +/- 5 users.

Moving forward, the algorithm complexity will be represented only in Big O as the industry doesn’t care about Big Omega or Big Theta. But why? from the practical point of view, both Big Omega and Big Theta don’t provide any value. For example, the website will display the web page in 1 millisecond at best, or the website will display the web page in 5 milliseconds if the number of users is between 50–60. Both of these are exceptional cases, and what we care about is knowing practical scenarios (such as time taken as the traffic increases).

## Drop the Constant and Non-Dominant terms
Let’s take the below code as an example and determine its complexity.

<Code language="java">
{`
1. public void calculateSumAndProduct(int nums[]) {
2.    long sum = 0;
3.    long product = 1;
4.    for (int num : nums) {
5.        sum += num;
6.        product *= num;
7.    }
8. 
9.    System.out.println(sum);
10.   System.out.println(product);
11. }
`}
</Code>

Every time the function *calculateSumAndProduct* executes, lines #2, #3, #9, and #10 will run exactly one time, while lines #5 and #6 will run N times (size of the array “nums”). Based on it, the complexity will be O(2N + 4). But as we discussed earlier, the goal of complexity is to determine the rate of increase; we’re not gaining much from being accurate, as seen from the rate of increase graphs below for O(N) and O(2N + 4). And hence, in Big O, constant terms are dropped, making the complexity of the above code O(N).

![alter-text](/images/post/n_versus_2n.png)
*Runtime Comparison of O(N) and O(2N+1)*

Similarly, the complexity of the non-dominant term is dropped. For example, O(N² + N) will become O(N²).

![alter-text](/images/post/n^2.png)
*Runtime Comparison of O(N²) and O(N²+N)*

While we drop Constant and Non-Dominant Terms, remember, the complexity cannot be reduced further if statements are getting executed a different number of times. For example, the below code’s complexity will be O(N + M) as we cannot be sure what will be the value of N and M (size of num1 and num2 respectively). It’s as good as comparing mangoes with oranges.

<Code language="java">
{`
1.  public void calculateSumAndProduct(int nums1[], int nums2[]) {
2.     int sum = 0;
3.     int product = 1;
4.     for (int num : nums1) {
5.         sum += num;
6.         product *= num;
7.     }
8.  
9.     for (int num : nums2) {
10.        sum += num;
11.        product *= num;
12.    }
13. 
14.    System.out.println(sum);
15.    System.out.println(product);
16. }
`}
</Code>

## Best, Worst, and Expected Case Complexity
The Big O runtimes are categorized as Best, Worst, and Expected case. Let’s understand this with an example of searching a number in an array.

1. Best Case: When the number we are searching for is found at the first index of the array, the runtime becomes O(1).
2. Worst Case: When the number we are searching is at the last index of the array, the runtime becomes O(N).
3. Expected (Average) Case: In real life, we never get too lucky or unlucky in most cases, and hence Expected Case is the most practical one. The runtime for searching a number in an array is O(N/2) = O(N).

In most cases, the worst and expected case complexities are the same (as seen in the above example as well).

## Runtimes
### Constant Runtime
An algorithm is said to be constant time if it has a fixed set of instructions irrespective of the input. For example, see the code block below

<Code language="java">
{`
1. public int sum(int a, int b) {
2.    int c = a + b;
3.    return c;
4. }
`}
</Code>

The complexity of the code is O(2) as there are two instructions. Since we drop the constant terms, such complexity is represented as O(1), which is also the best possible runtime complexity for an algorithm. More such examples are accessing the array elements, find if a number is even or odd, find a value on a Map, etc.

### O(N) Runtime
When an algorithm has an N number of instructions, usually in a loop, for example, the below code will execute exactly N instructions depending on the array’s size.

<Code language="java">
{`
1. public void print(int nums[]) {
2.    for (int num : nums) {
3.        System.out.println(num);
4.    }
5. }
`}
</Code>

### O(N²) or O(N^N)
When an algorithm has a piece of code with nested blocks, usually nesting of loops, for example, the below code, will execute O(N²) times.

<Code language="java">
{`
1. public void print(int nums[][]) {
2.    for (int i=0; i<nums.length; i++) {
3.        for (int j=0; j<nums[i].length; j++) {
4.            System.out.println(nums[i][j]);
5.        }
6.    }
7. }

`}
</Code>

And similarly, if there are 3 nested loops, the complexity is O(N³) and so on…

### O(log N) and O(N log N)
The Divide and Conquer algorithms usually have logarithmic runtimes. For example, searching a number in a sorted array using the Binary Search algorithm has O(log N) runtime. The array’s size is divided in half until the number is found, or the input cannot be divided further.

![alter-text](/images/post/binary_search.png)
*Binary Search INPUT on every iteration*

Suppose we need to search N numbers from the given sorted array using Binary Search. In that case, the complexity will be O(N log N) as we’ll be dividing the input in half for every number N. Typically, Divide and Conquer sorting algorithms, such as Quick Sort, Merge Sort, etc., are O(N log N) runtime algorithms, which is also the best runtime for a sorting algorithm.

### O(2^N)
These are also known as recursive (see Appendix 1 for more details) runtimes where the code is executed 2^N times for every input N. For example, finding Nth Fibonacci number.

<Code language="java">
{`
1. public int fibonacci(int N) {
2.    if (N <= 1) {
3.        return 1;
4.    }
5.    return fibonacci(N-1) + fibonacci(N-2);
6. }
`}
</Code>
The program will be executed as follows.

![alter-text](/images/post/fibonacci.png)
*Fibonacci function calls after every execution*

The complexity of the code is O(2^(N-1)) = O(2^N). These complexities can be generalized as O(branches^depth)

## Cheatsheet for Runtimes Comparison
![alter-text](/images/post/comparison.png)
*Comparison of all runtimes*

O(1) < O(log N) < O(N) < O(N log N) < O(N²) < O(2^N)

## Appendix 1: Recursion
A function that calls itself is known as a recursive function. The problems that are too complex for an iterative approach are broken down into smaller ones through recursion — for example, iterating through a Binary Tree. It requires maintaining previous states via Stack/Queue in an iterative approach, while the recursive approach leverages the platform’s stack approach and keeps the code clean.

Note: Recursion is a complex topic in itself, and it’s not possible to cover it in a paragraph. I’ll be covering this topic in detail in another blog.

Algorithm Complexity Simplified


In the recent past, India has witnessed specific trends that attract many people — for instance, pursuing a career in cricket, learning guitar, pursuing engineering, online learning, establishing start-ups, and many more. We are recently witnessing a learning coding trend, which promises your kid to be a multimillionaire entrepreneur. But how much of this is true? Being a professional software engineer, I decided to share my opinion on the topic, which might help non-IT parents in India, who has FOMO for their kids.

*Disclaimer: All statements and advice in this blog are personal and based on my experiences; if you disagree, feel free to report or ignore :)*

Kids these days gets fascinated by smartphones and their app. While on the other hand, parents get fascinated by the advertisement, which promises a multimillionaire entrepreneur dream. This excitement from kids and parents worries me a little; let me tell you why. According to an article published in EconomicTimes, “15 lakh engineers graduate in India every year out of which only 2.5 lakh students land relevant jobs in technical domains. Out of those, roughly 2.2 lakh openings are in software, within which a vast majority (1.8 lakh jobs) are in IT services, garnering around only Rs 3–5 lakh per annum (LPA) in remuneration.”

Moreover, only a few individuals can make their name as an entrepreneur out of thousands if not lakhs of students. What does this mean? Can your kid not be one of them? Well, indeed, he/she can, and maybe they will someday, but that doesn’t mean they need to start coding at the age of six. All they need is INTEREST and a right mix of talent, passion, hard work, and a little guidance but coding at six or early age is not the first right step (and I can assure you as a professional software engineer). Also, coding alone won’t make a difference. Trust me, coding is not a big deal, and any average (in study) individual can learn and code. A lot more is needed to be a successful entrepreneur — for example, idea, funds, marketing skills & strategy, and many more.

To directly talk about coding, let me tell you that it demands a good understanding of fundamental mathematics concepts such as linear algebra, binary number system, factorials, prime numbers, even/odd numbers, etc. These are not something that a six-year-old will understand. Even if they do, coding requires a strong foundation like any other thing on this planet, a pre-requisite to which are understanding RAM, CPU, HardDisks, etc. They teach your kids drag-and-drop features that do all the magic behind the scene, just like online website builders such as Wix, WordPress, etc.

Then what is the right age for learning to code? Well, there is no correct answer at the moment, but not until your kid has understood fundamental math concepts (linear algebra, binary number system, etc.). We’re already living in a world where kids spend more time on TV, smartphones, computers/laptops when they should be indulging in physical activities. While we wait for our government to incorporate coding in the school curriculum, we should not get distracted by those advertisements and consult professionals before investing our kid’s valuable childhood in such activities.


Freepik

Coding at the age of 6?


In this tutorial, we're diving deep into the implementation of the Code Generator Processor, a crucial component of our annotation-based code generation system. If you're new here, I recommend checking out our previous tutorials to grasp the foundational concepts that led us to this point.

<Notice type="note" title="All Parts">
  * [Annotation-Based Code Generator in Java - Overview [1/4]](/posts/java-annotation-based-code-generator-part-1)
  * [Annotation-Based Code Generator in Java - Java Annotations [2/4]](/posts/java-annotations-code-generator-part-2)
  * [Creating a Code Generator Processor - Code Generator [3/4]](/posts/creating-a-code-generator-processor-code-generator-part-3)
  * [Packaging and Implementing Your Java Code Generator - Code Generator [4/4]](/posts/packaging-and-implementing-code-generator-part-4)
</Notice>

### Understanding the Data Access Layer (DAO)
Before we plunge into the nitty-gritty of our processor, let's quickly recap the concept of Data Access Objects (DAO). These classes interact directly with databases, providing methods for CRUD operations: Create, Read, Update, and Delete. For instance, take a look at this sample DAO class:

<Code language="java">
{`
package org.example;

import org.example.StudentRequestException;
import org.example.StudentServiceException;

import java.io.EOFException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

public class StudentDaoImpl implements StudentDao {
   private final String dbFile = "student.db";

   @Override
   public void add(Student student) throws StudentRequestException, StudentServiceException {
       StudentGeneratedDto studentGeneratedDto = convertStudentToStudentGeneratedDto(student);
       List<Student> students = getAll();
       students.add(student);
       try (FileOutputStream fileOut = new FileOutputStream(dbFile);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOut)) {
           for (Student random : students) {
               objectOut.writeObject(convertStudentToStudentGeneratedDto(random));
           }
       } catch(IOException e) {
           throw new StudentServiceException("Internal service error, please try again!" + e);
       }
   }

   @Override
   public List<Student> getAll() throws StudentRequestException, StudentServiceException {
       List<Student> students = new ArrayList<>();
       if (!this.dbExist()) {
           return students;
       }
       try (FileInputStream fileIn = new FileInputStream(dbFile);
            ObjectInputStream objectIn = new ObjectInputStream(fileIn)) {
           while(true) {
               try {
                   StudentGeneratedDto studentGeneratedDto = (StudentGeneratedDto) objectIn.readObject();
                   students.add(convertStudentGeneratedDtoToStudent(studentGeneratedDto));
               } catch (EOFException eof) {
                   break;
               }
           }
       } catch(IOException | ClassNotFoundException e) {
           throw new StudentServiceException("Internal service error occurred: " + e);
       }
       return students;
   }

   @Override
   public void delete(Student student) throws StudentRequestException, StudentServiceException {
       if (!this.dbExist()) {
           throw new StudentRequestException("Unable to find the student");
       }
       boolean isDeleted = false;
       List<Student> students = this.getAll();
       try (FileOutputStream fileOut = new FileOutputStream(dbFile);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOut)) {
           for (Student random : students) {
               if(!(random.getRollNumber() == student.getRollNumber())) {
                   objectOut.writeObject(convertStudentToStudentGeneratedDto(random));
               } else {
                   isDeleted = true;
               }
           }
       } catch (IOException e) {
           throw new StudentServiceException("Internal service error occurred: " + e);
       }

       if (!isDeleted) {
           throw new StudentRequestException("Data not found: ");
       }
   }

   @Override
   public void update(Student student) throws StudentRequestException, StudentServiceException {
       if (!this.dbExist()) {
           throw new StudentRequestException("Unable to find the student");
       }
       boolean isUpdated = false;
       List<Student> students = this.getAll();
       try (FileOutputStream fileOut = new FileOutputStream(dbFile);
            ObjectOutputStream objectOut = new ObjectOutputStream(fileOut)) {
           for (Student random : students) {
               if(random.getRollNumber() == student.getRollNumber()) {
                   objectOut.writeObject(convertStudentToStudentGeneratedDto(student));
                   isUpdated=true;
               } else {
                   objectOut.writeObject(convertStudentToStudentGeneratedDto(random));
               }
           }
       } catch (IOException e) {
           throw new StudentServiceException("Internal service error occurred: " + e);
       }

       if (!isUpdated) {
           throw new StudentRequestException("Data not found: ");
       }
   }

   private boolean dbExist() {
       File file = new File(dbFile);
       return file.exists();
   }

   private Student convertStudentGeneratedDtoToStudent(StudentGeneratedDto studentGeneratedDto) {
       Student student = new Student();
       student.setName(studentGeneratedDto.getName());
       student.setRollNumber(studentGeneratedDto.getRollNumber());
       return student;
   }

   private StudentGeneratedDto convertStudentToStudentGeneratedDto(Student student) {
       StudentGeneratedDto studentGeneratedDto = new StudentGeneratedDto();
       studentGeneratedDto.setName(student.getName());
       studentGeneratedDto.setRollNumber(student.getRollNumber());
       return studentGeneratedDto;
   }

}
`}
</Code>

### Processor Implementation - Setup
Firstly, we'll identify the model classes that use the @FileDBGenerated annotation. To do so, we'll make use of the roundEnv variable provided by the Java compiler. Additionally, we'll ensure that the @FileDBGenerated annotation is applied at the class level and not on a field or any other resource.

<Code language="java">
{`
{
    Set<? extends Element> fileDbGeneratedAnnotatedClasses = roundEnv.getElementsAnnotatedWith(FileDBGenerated.class);
    for (Element element : fileDbGeneratedAnnotatedClasses) {
        if (element.getKind() == ElementKind.CLASS) {
        
        }
    }
}
`}
</Code>

Once we identify the class using the @FileDBGenerated annotation and confirm that it's at the class level, we'll proceed to extract the fields annotated with the @Persisted and @UniqueKey annotations. In this context, we'll assume that any field annotated with @UniqueKey is also annotated with @Persisted. Subsequently, we will store these identified fields in a list for use in a later stage.

<Code language="java">
{`
{
    TypeElement classElement = (TypeElement) element;
    
    List<VariableElement> fields = new ArrayList<>();
    List<VariableElement> uniqueKeyFields = new ArrayList<>();
    for (Element enclosedElement : classElement.getEnclosedElements()) {
        if (enclosedElement.getKind() == ElementKind.FIELD
                && enclosedElement.getAnnotation(UniqueKey.class) != null) {
            VariableElement fieldElement = (VariableElement) enclosedElement;
            uniqueKeyFields.add(fieldElement);
        } else if (enclosedElement.getKind() == ElementKind.FIELD
                && enclosedElement.getAnnotation(Persisted.class) != null) {
            VariableElement fieldElement = (VariableElement) enclosedElement;
            fields.add(fieldElement);
        }
    }
}
`}
</Code>

Next, we will proceed to extract the name of the model class along with its package name. The model class's name will be utilized for naming our generated classes, while the package name will help identify the location where these generated classes will be stored. To illustrate, if the model class name is "Student," our generated classes will be prefixed with "Student."

<Code language="java">
{`
TypeElement enclosingClass = (TypeElement) fields.stream().findAny().get().getEnclosingElement();
this.packageName = processingEnv.getElementUtils().getPackageOf(enclosingClass).toString();
this.className = enclosingClass.getSimpleName().toString();
`}
</Code>

And that concludes the setup. We now possess all the necessary information required to generate our classes. Here is the final code presented together.

<Code language="java">
{`
@SupportedAnnotationTypes("com.gogettergeeks.annotation.FileDBGenerated")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class FileDBProcessor extends AbstractProcessor {
    private String packageName;
    private String className;

    @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        boolean isClaimed = false;
        Set<? extends Element> fileDbGeneratedAnnotatedClasses = roundEnv.getElementsAnnotatedWith(FileDBGenerated.class);
        for (Element element : fileDbGeneratedAnnotatedClasses) {
            if (element.getKind() == ElementKind.CLASS) {
                TypeElement classElement = (TypeElement) element;

                List<VariableElement> fields = new ArrayList<>();
                List<VariableElement> uniqueKeyFields = new ArrayList<>();
                for (Element enclosedElement : classElement.getEnclosedElements()) {
                    if (enclosedElement.getKind() == ElementKind.FIELD
                            && enclosedElement.getAnnotation(UniqueKey.class) != null) {
                        VariableElement fieldElement = (VariableElement) enclosedElement;
                        uniqueKeyFields.add(fieldElement);
                    } else if (enclosedElement.getKind() == ElementKind.FIELD
                            && enclosedElement.getAnnotation(Persisted.class) != null) {
                        VariableElement fieldElement = (VariableElement) enclosedElement;
                        fields.add(fieldElement);
                    }
                }

                if (!fields.isEmpty()) {
                    TypeElement enclosingClass = (TypeElement) fields.stream().findAny().get().getEnclosingElement();
                    this.packageName = processingEnv.getElementUtils().getPackageOf(enclosingClass).toString();
                    this.className = enclosingClass.getSimpleName().toString();
                }
            }
        }

        return isClaimed;
    }
}
`}
</Code>

### Implementing the Processor - Generate DAO
To maintain the tutorial's conciseness, I will demonstrate how to generate the DAO class. For the remaining classes, you can refer to the complete processor code available [here](https://github.com/adityasolge93/G3CodeGenerator/blob/main/src/main/java/com/gogettergeeks/processor/FileDBProcessor.java).

To ensure organized logic, we'll create private methods within the processor class. Alternatively, you can opt to place these private methods in separate utility classes.

The conceptual approach for generating the class is straightforward: we retain the concrete implementation as reference and carefully examine the code line by line. Within each line, we identify the dynamic components and generalize them. To illustrate, let's commence with the initial line of the concrete implementation, which defines the package.

<Code language="java">
{`
1.  package org.example;

3.  import java.io.EOFException;
4.  import java.io.File;
5.  import java.io.FileInputStream;
6.  import java.io.FileOutputStream;
7.  import java.io.IOException;
8.  import java.io.ObjectInputStream;
9. import java.io.ObjectOutputStream;

10. import java.util.ArrayList;
11. import java.util.List;
12. import java.util.UUID;
`}
</Code>

To generate the first line, we recognize that the package will remain constant, while "org.example" will be based on the package name of the model class. Consequently, the generic implementation will resemble the following:

<Code language="java">
{`
private void generateDao(List<VariableElement> fields, List<VariableElement> uniqueKeyFields) {
    StringBuilder body = new StringBuilder();
    body.append("package ").append(this.packageName).append(";\n\n");
}
`}
</Code>

If you observe closely, we will be consolidating all the generic code within the StringBuilder. Once we complete the entire logic, we will conveniently write this string to a file (which we will cover later).

Subsequently, lines #3 through #12 will remain consistent across all implementations. Consequently, we will maintain them without any alterations.

<Code language="java">
{`
private void generateDao(List<VariableElement> fields, List<VariableElement> uniqueKeyFields) {
    StringBuilder body = new StringBuilder();
    body.append("package ").append(this.packageName).append(";\n\n");
    body.append("\nimport java.io.EOFException;\n");
    body.append("import java.io.File;\n");
    body.append("import java.io.FileInputStream;\n");
    body.append("import java.io.FileOutputStream;\n");
    body.append("import java.io.IOException;\n");
    body.append("import java.io.ObjectInputStream;\n");
    body.append("import java.io.ObjectOutputStream;\n\n");
    body.append("import java.util.ArrayList;\n");
    body.append("import java.util.List;\n");
    body.append("import java.util.UUID;\n\n");
}
`}
</Code>

Next, I will illustrate how to generate the `throws Exception1, Exception2` statements. Please refer to the following concrete implementation.

<Code language="java">
{`
public void add(Student student) throws StudentRequestException, StudentServiceException {
`}
</Code>

As we require these throw statements in multiple locations within the DAO and also in the interface, we will create an exception list at the class level.

<Code language="java">
{`
private static final List<String> EXCEPTION_CLASS_NAMES = new ArrayList<>() {{
    add("RequestException");
    add("ServiceException");
}};
`}
</Code>

Next, we'll create the logic to generate the throw statements.

<Code language="java">
{`
StringBuilder throwsExceptionString = new StringBuilder();
for (int i=0; i < EXCEPTION_CLASS_NAMES.size(); i++) {
    throwsExceptionString.append(this.className).append(EXCEPTION_CLASS_NAMES.get(i));
    if (i != EXCEPTION_CLASS_NAMES.size()-1) {
        throwsExceptionString.append(", ");
    }
}
`}
</Code>

Lastly, generate the complete line of the method declaration.

<Code language="java">
{`
body.append("   public void add(").append(this.className).append(" ")
        .append(this.className.toLowerCase()).append(") throws ")
        .append(throwsExceptionString).append(" {\n");
`}
</Code>

For the rest of the implementation, you can refer to the complete source code available [here](https://github.com/adityasolge93/G3CodeGenerator/blob/main/src/main/java/com/gogettergeeks/processor/FileDBProcessor.java).

#### Writing the generated String to the correct file and location
There is a variable named processingEnv provided by the AbstractProcessor class. You can leverage it to obtain a reference variable of the Writer class for writing your string to the Java file.

<Code language="java">
{`
try {
    Writer writer = processingEnv.getFiler()
            .createSourceFile(this.packageName + "." + this.className + "DaoImpl")
            .openWriter();
    writer.write(body.toString());
    writer.close();
} catch (IOException ioException) {
    ioException.printStackTrace();
}
`}
</Code>

### Wrapping Up!
Congratulations, you've delved into the heart of creating a Code Generator Processor! In this tutorial, we explored generating a DAO class as an example, crafting dynamic parts of the code while using the StringBuilder to assemble the class structure. Our processor journey is nearly complete, and in the next post, we'll learn how to package your code for distribution using Maven. Additionally, we'll uncover the process of using the generated files to perform CRUD operations. Stay tuned for the final chapter of this tutorial series, and keep your coding spirit high!


Image by xb100 on Freepik

Creating a Code Generator Processor - Code Generator [3/4]


In this article, you’ll learn to host a static website on AWS S3 using the GoDaddy domain. Additionally, this article will cover supporting HTTPS on the website and removing the file extension from the website’s path.

*Note: While all the resources to host static websites on S3 are available on the internet, this article aims to put everything together and provide solutions to common problems in a single place.*

## Hosting Static Website
*< Reference: https://docs.aws.amazon.com/AmazonS3/latest/userguide/EnableWebsiteHosting.html >*

* Sign in to the AWS console `https://console.aws.amazon.com/`. Register using the same link if you don’t have an AWS account.
* Search “S3” in the search bar and open the S3 console.
* Click the “Create Bucket” button located in the top right.
* Under “General Configuration”
* Enter “Bucket Name,” ideally the name of the domain. For example, if you want to create `www.example.com`, name the bucket an “example.”
* Select “AWS Region,” which is most close to the location of your website’s user.
* Under “Block Public Access settings for this bucket,” uncheck the “Block all public access” checkbox to allow users to access the bucket files.
* Leave everything else with the default values and click “Create Bucket” at the bottom of the page.
* Upload the files of your static website using either AWS CLI or the “Upload” option under the “Objects” tab of the newly created bucket.
* Under the “Properties” tab of the newly created bucket, scroll to the bottom, and under the “Static website hosting” section, Enable static website hosting using the “Edit” button. Provide all the required information, including the default file to open when your website is visited under the “index” text field.
* Under the “Properties” tab, you’ll find the URL to visit your website at the bottom of the page under the “Static website hosting” section. It will look something like `http://<bucket-name>.s3-website.<aws-region-of-the-bucket>.amazonaws.com/`

## Enabling Custom Domain & HTTPS
**Why HTTPS?** With HTTPS, data is encrypted in transit in both directions: going to and coming from the origin server. The protocol keeps communications secure, so malicious parties can’t observe what data is being sent. Additionally, your website user will see an insecure connection warning with HTTPS.

![alter-text](/images/post/security-error.png)
*Insecure message on the browser*

HTTPS connections are enabled through SSL (Secure Sockets Layer) certificates. An SSL certificate is a digital certificate that authenticates a website’s identity and enables an encrypted connection.

## Creating SSL certificate in AWS
* Open AWS Certificate Manager (ACM) console by searching “Certificate” in the search bar.
* Click on the “Request” button and ensure the “Request a public certificate” radio-buttion is selected before clicking on the “Next” button.
* Under “Domain names,” enter two values for the “Fully qualified domain name” field
  * `www.<your-domain-name>.com`
  * `<your-domain-name>.com`
* Under the “Validation Method” section, select “DNS Validation” unless you can access email to perform validation using email.
* Open the newly created certificate and copy the “CName name” and “CName value” values for both domain names.
* Now head to your domain provider’s website and sign in to your account. In this article, steps are shared for domains registered through GoDaddy.
* Open the settings of the domain you would like to use. `https://dcc.godaddy.com/control/<domain-name>/settings`
* Under the “Additional Settings” section, open the “Manage DNS” link.
* Under the “DNS Records” section, click the “Add” button and enter the following. Repeat this step twice for both the values provided by ACM.
  * “Type” -> “CNAME”
  * “Name” -> The “CName name” copied from the ACM certification screen.
  * “Value” -> The “CName value” copied from the ACM certification screen.
  * “TTL” -> “Default”
* It usually takes 5–10 mins for verified status to get reflected on ACM Certificate. This is an excellent time to take a break :)

## Creating CloudFront distribution
* Open the CloudFront console by searching “CloudFront” in the search bar of the AWS console.
* Click on the “Create Distribution” button. (Note: Make sure the certificate is created in the us-east-1 region, irrespective of your bucket region)
* Enter the S3-provided website URL under “Origin domain.” Note: Don’t select the auto-complete provided S3 link.
* Select “Redirect HTTP to HTTPS” as the “Viewer protocol policy” under the “Default cache behavior” section.
* Under the “Settings” section, select the created SSL certificate in the “Custom SSL certificate — optional” field.
* Under the “Settings” section, enter two values for the “Alternate domain name (CNAME) — optional” field
  * `www.<your-domain-name>.com`
  * `<your-domain-name>.com`
Leave everything else with the default values and click “Create distribution” at the bottom of the page.

It takes 5–10 minutes before your custom domain URL is live :)

## Removing file extension from the website’s URL
Now that your website is live and secured with HTTPS, it is important not to display file extensions in the URL of your website. While this is not a deal-breaker, it doesn’t look professional! To fix it

1. Locate your HTML (assuming you are using HTML files for the static website) files under the S3 bucket, and under the “Actions” drop-down, select “Edit Meta-data.”
2. Ensure the content type is “text/html”; if it is not, change it to “text/html.”
3. Now go back and select the HTML file again and rename the file using the “Actions” -> “Rename object” button. Remove the .html extension from the file name and click “Save.”

**Note:** All the anchor (link) tags in your HTML file must remove “.html” from the “href.”

## References
* https://docs.aws.amazon.com/AmazonS3/latest/userguide/EnableWebsiteHosting.html
* https://medium.com/tensult/aws-hosting-static-website-on-s3-using-a-custom-domain-cd2782758b2c
* https://stackoverflow.com/questions/23463679/s3-static-pages-without-html-extension


Image by rawpixel.com on Freepik

Hosting Static Website using AWS S3 and GoDaddy


In this blog post, I’ve shared some tips to ace the software engineer interview based on my personal experience of being a candidate and an interviewer.

*Disclaimer: This post doesn’t guarantee a selection in an interview and instead should be used to prepare yourself for the interview better.*

I’ve divided this blog into two categories, one is Behavioral Questions and another is Technical Questions.

## Behavioral Questions
The preparation for Behavioral questions is the most ignored by the interview candidates, and in most cases, it becomes a show stopper for them. The following are some tips to prepare for this section of the interview.

* **Experience Summary:** Prepare a summary focusing on your work experience or academic project experience (in the case of a fresh graduate). Focus on your contributions instead of the overall project. Specify the most challenging part and your mindset while tackling the challenge. Remember, the interview is about yourself and your contributions, not the company you are coming from.
* **Situational Questions:** The interviewer is looking for your attitude in a specific situation. Every company is looking for employees who can operate independently and take themselves out of challenging situations. The following are some situational questions. (1) A task taking more time than expected, (2) Responding to unreasonable requests from your client/customer/stakeholder, (3) Addressing unexpected system behavior, (4) Deciding priority on multiple tasks, and (5)Meeting deadlines in an unrealistic timeline.

The following are some general tips for the behavioral section.

* Unless explicitly asked, try to cover things not part of your resume. It is because, in most cases, the interviewer would have gone through your resume before the interview.
* For every project experience, think about what you will do differently if allowed to start from scratch. It reflects that you learn from your experiences.
* A couple of don’ts in your responses are (1) Working additional hours to cover for misestimation instead of being strategic in handling the situation by cutting down the scope or prioritizing essential features first, (2) Accepting requirements blindly before heading into the implementation or design of the project.

## Coding Questions
This is the section for which every individual invests most time in preparation. Unfortunately, there is no correct answer to ace the coding question, but below is what I used and revised over time based on my own interview experiences.

* Understand why Algorithm Complexity is needed and how it is calculated. It is the key to a coding interview as it will be asked 100% and will be used to evaluate your solution. You can refer to [my blog post](https://adityasolge.medium.com/algorithm-complexity-simplified-acf9eac5284a) on Algorithm Complexity for getting started.
* Thoroughly understand and learn the data structures including Queue, Stack, Sorting Algorithms, Trees, Graphs, Linked List, Doubly Linked List, and Map. In addition, you must know their runtime complexities with reasoning.
* Pick one online coding platform (some examples are [HackerRank](https://www.hackerrank.com/), [LeetCode](https://leetcode.com/), and [CodeChef](https://www.codechef.com/ide)) and start solving problems. Do not focus on submitting the working solution; instead, begin with a naive solution (brute-force in some cases) and work incrementally towards an optimized solution. Irrespective of your submission, look for the approved solution and learn from it. It will build your ability to solve problems and give you different perspectives. Over time, you’ll have different weapons to mix and match in different scenarios.

The following are some resources and additional tips.
* Do read [Cracking the Coding Interview](https://www.amazon.in/Cracking-the-Coding-Interview/dp/0984782869/ref=sr_1_1?keywords=cracking+the+coding+interview&amp%3Bqid=1684080542&amp%3Bsprefix=cracking+the+coding+interview%252Caps%252C716&amp%3Bsr=8-1&_encoding=UTF8&tag=asolge-21&linkCode=ur2&linkId=cbde629cd91fc80e7554b7aabc3b4881&camp=3638&creative=24630). It is the Bible for coding interviews.
* Publish all your projects to the public GitHub repository and add them to your resume. Working projects stand you out from the crowd.
* While practicing coding questions is essential, do spend time working on projects. Don’t undertake generic projects like book library, student management system, etc. Don’t do projects for resumes; instead, be innovative and solve real-world problems. You don’t need to write thousands of lines of code to make an impactful project. You are an engineer, be smart!
* Once you practice enough, you should identify the best runtime possible for the given problem by just looking at it. For example, the best runtime for sorting algorithms is O(N log N). In an interview, even if you cannot think about the best runtime solution, start with a naïve approach and be loud in your thinking. Being loud will make the interview interactive; you’ll be able to think of new solutions quickly.

## Resume
I’m not an expert on Resume writing, but below are some tips.

* Do not include generic lines like “I’m a self-motivated individual.” Such lines don’t add value, and there is no data point or examples which demonstrate that you are self-motivated.
* While explaining the project, highlight your contributions and make it data-driven. Whenever applicable, specify the impact/result of the project. For example, don’t add sentences like “Contributed to XYZ project as a lead engineer,” but instead use a sentence like “I lead the team of N engineers in reducing the latency of the website by 100%. In addition to improved customer, it resulted in 10X traffic on the website, bumping the revenue by X%”.
* Try to limit your resume to 1-page. In most cases, important stuff can be easily fit into 1-page (unless you have multiple experiences).
* Do not add your photo. It is not relevant in your resume as what matters is your work experience and not how you look.
* Do add links to GitHub, LinkedIn profile, etc.

## Mock Interviews
Nowadays, there is a good amount of online platform which provide mock interviews for free. I highly recommend those to fresh graduates or someone who is not feeling confident while going into an interview. No practice will teach you things that an actual interview will. In mock interviews, you can make mistakes and learn from them, but in the real world, a small mistake means a lost opportunity, and most companies do not allow you to re-interview immediately. Some online interview platforms are [Pramp](https://www.pramp.com/#/), [TechMockInterview](https://www.techmockinterview.com/), and [Interviewing.io](https://interviewing.io/).

**Closing Note:** I’ve deliberately kept the blog post short. If you feel you need more details around a particular point, feel free to comment below, and I’ll be more than happy to address them.

Image by ijeab on Freepik

How to prepare for a Software Developer Interview?


In the world of Java development, automation and efficiency are crucial aspects. Annotation-based code generation is a technique that empowers developers to automate the creation of repetitive and boilerplate code. In this tutorial, we will dive into creating our own annotation-based code generator in Java, similar to popular libraries like Lombok, Google Guice, and Spring/Spring Boot. If you're more of a visual learner, you can also find a detailed video tutorial on this topic in [this YouTube playlist](https://chat.openai.com/INSERT_YOUTUBE_PLAYLIST_LINK).

<Notice type="note" title="All Parts">
  * [Annotation-Based Code Generator in Java - Overview [1/4]](/posts/java-annotation-based-code-generator-part-1)
  * [Annotation-Based Code Generator in Java - Java Annotations [2/4]](/posts/java-annotations-code-generator-part-2)
  * [Creating a Code Generator Processor - Code Generator [3/4]](/posts/creating-a-code-generator-processor-code-generator-part-3)
  * [Packaging and Implementing Your Java Code Generator - Code Generator [4/4]](/posts/packaging-and-implementing-code-generator-part-4)
</Notice>

### What to Expect in the Tutorial?
This tutorial is structured into three distinct parts, each building on the previous one:

#### 1. What are Java Annotations and How to create Custom Annotations?
Before we delve into building our code generator, it's essential to understand what Java annotations are and how they work. We'll also create custom annotations that will serve as the foundation for our code generation process.

#### 2. Processor for Code Generator
We will develop a processor responsible for generating code based on these annotations. I’ll walk you through mental model and generation of challenging pieces of the processor.

#### 3. Packaging Code Generator, and Using Code Generator
The final part of the tutorial focuses on how to package the code generator and, most importantly, how to utilize it effectively.

### What We Will Implement
In this project, we are going to create an annotation-based code generator that can automatically generate file-based data access layer (DAO) classes for any model or DTO class. These generated classes will enable CRUD operations (Create, Read, Update, Delete) to persist and retrieve data from a local file.

#### The Annotations
Three annotations will play a pivotal role in our project:

1. @FileDBGenerated: Annotate the model class you want to generate the data layer for.
2. @Persisted: Annotate fields within your model class that should be persisted in the file-based database.
3. @UniqueKey: Apply this annotation to the primary key or unique key field that uniquely identifies records.

For instance, here's how the annotations could be used in a Student model class:

<Code language="java">
{`
import com.gogettergeeks.annotation.FileDBGenerated;
import com.gogettergeeks.annotation.Persisted;
import com.gogettergeeks.annotation.UniqueKey;

@FileDBGenerated
public class Student {
    @Persisted
    private String name;

    @Persisted
    @UniqueKey
    private int rollNumber;

    private double percentage;

    // Getters and setters...
}
`}
</Code>

Upon building the project, the code generator will automatically create the following classes:

* StudentDao: An interface defining CRUD operations.
* StudentDaoImpl: An implementation of the interface methods.
* StudentDtoGenerated: An internal DTO containing fields marked with @Persisted or @Unique annotations.
* StudentRequestException: An exception representing issues with user requests, not suitable for retries.
* StudentServiceException: An exception representing internal processing issues within the DAO layer.

### Next Steps
If the prospect of creating a high-impact project with minimal effort excites you, then you're in for a treat. This tutorial equips you with the knowledge and tools to embark on this journey. So, are you ready to dive into the world of annotation-based code generation and create something extraordinary? If the answer is yes, don't wait any longer—start following the tutorial right now!

### Resources
* Source Code: https://github.com/adityasolge93/G3CodeGenerator
* Video Tutorial: https://chat.openai.com/INSERT_YOUTUBE_PLAYLIST_LINK


Annotation-Based Code Generator in Java - Overview [1/4]


In this tutorial, we'll be delving into the world of Java annotations. I'll explain what annotations are, their significance, and guide you through creating your very own custom annotations. So, let's get started!

<Notice type="note" title="All Parts">
  * [Annotation-Based Code Generator in Java - Overview [1/4]](/posts/java-annotation-based-code-generator-part-1)
  * [Annotation-Based Code Generator in Java - Java Annotations [2/4]](/posts/java-annotations-code-generator-part-2)
  * [Creating a Code Generator Processor - Code Generator [3/4]](/posts/creating-a-code-generator-processor-code-generator-part-3)
  * [Packaging and Implementing Your Java Code Generator - Code Generator [4/4]](/posts/packaging-and-implementing-code-generator-part-4)
</Notice>

### Introduction to Java Annotations
Annotations in Java serve as a means of conveying additional information about your code. They enhance readability, assist in documentation, and even influence the behavior of the code. To grasp this concept better, consider a scenario involving two classes: Student and CollegeStudent. 

<Code language="java">
{`
class Student {
    public void print() {
        System.out.println("Student");
    }
}

class CollegeStudent extends Student {
    public void pritn() {
        System.out.println("CollegeStudent");
    }
}

class Main {
    public static void main(String[] args) throws Exception {
        CollegeStudent student = new CollegeStudent();
        student.print();
    }
}
`}
</Code>

The CollegeStudent class extends the Student class and attempts to override a method (print). Unfortunately, a typo results in the incorrect method being invoked. The output of the following program is:

<Code language="java">
{`
Student
`}
</Code>

While, the user intended to invoke print method of CollegeStudent. To prevent such errors, Java offers a built-in annotation, @Override. This annotation guarantees that a method genuinely intends to override another, minimizing human mistakes.

<Code language="java">
{`
class Student {
    public void print() {
        System.out.println("Student");
    }
}

class CollegeStudent extends Student {
    @Override
    public void pritn() {
        System.out.println("CollegeStudent");
    }
}

class Main {
    public static void main(String[] args) throws Exception {
        CollegeStudent student = new CollegeStudent();
        student.print();
    }
}
`}
</Code>

The output of the modified version is

<Code language="java">
{`
error: method does not override or implement a method from a supertype
    @Override
    ^
1 error
`}
</Code>

### Built-in Annotations and Their Roles
Java provides an array of built-in annotations for various purposes. Examples include:

* @Deprecated: Flags methods or classes designated for future removal.
* @Test: Identifies methods as test methods for testing frameworks.

While there are numerous built-in annotations, our primary focus lies in crafting custom annotations with meaningful roles. If you are interested in knowing in detail about essential built-in annotations, please comment down below.

### Crafting Your Custom Annotations
To create custom annotations, use the @interface keyword, similar to how you define classes or interfaces. You can also embed methods within annotations, which then serve as parameters for annotation users. For instance:

<Code language="java">
{`
public @interface Test {
   String name() default " ";
}
`}
</Code>

In this example, the user can specify a test's name, which aids in identifying test outcomes. You can choose not to define any methods, resulting in a Marker annotation, much like @Override.

Methods within annotations are analogous to variables in Java—they require a data type, can have default values, don't accept parameters, and cannot throw exceptions.

#### Controlling Annotation Usage with @Target and @Retention
To dictate where users can apply your annotation (class, method, field, etc.), employ @Target, which operates with the ElementType enum. The ElementType enum can have the following values

| ElementType | Where can be Applied? |
| -------- | ------- |
| TYPE | Class, interface (including annotation interface), enum, or record declaration |
| FIELD | Field declaration (includes enum constants) |
| METHOD | Method declaration |
| PARAMETER | Formal parameter declaration |
| CONTRUCTOR | Constructor declaration |
| LOCAL_VARIABLE | Local variable declaration |
| ANNOTATION_TYPE | Annotation interface declaration (Formerly known as an annotation type.) |
| PACKAGE | Package declaration |
| TYPE_PARAMETER | Type parameter declaration |
| TYPE_USE | Use of a type |
| MODULE | Module declaration. |
| RECORD_COMPONENT | Record component |

*Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/annotation/ElementType.html*

For controlling when annotations evaluate, Java offers @Retention with RetentionPolicy options like SOURCE, CLASS, and RUNTIME. The RetentionPolicy can have the following values

| RetentionPolicy | Description |
| -------- | ------- |
| CLASS | Annotations are to be recorded in the class file by the compiler but need not be retained by the VM at run time. |
| RUNTIME | Annotations will be evaluated at the run-time. |
| SOURCE | Such annotations are evaluated during compile-time/build. |

*Reference: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/lang/annotation/RetentionPolicy.html*

Based on this knowledge, our three annotation classes will be 

<Code language="java">
{`
package com.gogettergeeks.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.TYPE)
public @interface FileDBGenerated {

}
`}
</Code>

<Code language="java">
{`
package com.gogettergeeks.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
public @interface Persisted {
}
`}
</Code>

<Code language="java">
{`
package com.gogettergeeks.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

@Retention(RetentionPolicy.SOURCE)
@Target(ElementType.FIELD)
public @interface UniqueKey {
}
`}
</Code>

#### Implementing the Custom Annotation Processor
Since our project require evaluation during build process, we’re going to delve into SOURCE RetentionPolicy. To create a processor, create a class that extends javax.annotation.processing.AbstractProcessor. Specify the annotations your processor evaluates and the compatible Java version using `@SupportedAnnotationTypes` and `@SupportedSourceVersion` annotations. You also need to override the abstract method process, which will be invoked by compiler during build process. For example, see our FileDBGeneratedProcessor below

<Code language="java">
{`
@SupportedAnnotationTypes("com.gogettergeeks.annotation.FileDBGenerated")
@SupportedSourceVersion(SourceVersion.RELEASE_17)
public class FileDBProcessor extends AbstractProcessor {
   @Override
    public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
        // Logic to generate annotation
    }
}
`}
</Code>

Once you are done with the implementation, you need to register your processor with Java, and it'll execute during build due to the source retention policy. Compile using the `-p` flag, e.g., `javac -p <processor-path> <main-class>.java`. We'll see each of these concepts in more details in the next post of this tutorial.

### Wrapping Up
Congratulations on conquering the realm of Java annotations and custom annotation creation! Annotations elevate your code's organization, efficiency, and purpose. If you enjoyed this tutorial, don't hesitate to give it a thumbs up and share it with fellow developers. 


Annotation-Based Code Generator in Java - Java Annotations [2/4]


Have you ever wondered what happens when you create an object of a class in Java? Does the object reside in the variable you create? Who deletes the object when its usage is done? In this blog, I’m going to address these questions.

Let’s consider the example below.

<Code language="java">
{`
1.  class Student {
2.      private int rollNumber;
3.      private String name;

4.      public void setRollNumber(int rollNumber) {
5.          this.rollNumber = rollNumber;
6.      }

7.      public int getRollNumber() {
8.          return this.rollNumber;
9.      }

10.     public void setName(String name) {
11.         this.name = name;
12.     }

13.     public String getName() {
14.         return this.name;
15.     }
16. }

17. class Main {
18.     public static void main(String[] args) {
19.         Student s1 = new Student();
20.         s1.setRollNumber(10);
21.         s1.setName("John");
22.         System.out.println(s1.getRollNumber());
23.         System.out.println(s1.getName());
24.         System.out.println("------------");

25.         Student s2 = s1;
26.         s2.setName("Sam");
27.         System.out.println(s1.getRollNumber());
28.         System.out.println(s1.getName());
29.         System.out.println(s2.getRollNumber());
30.         System.out.println(s2.getName());
31.     }
32. }
`}
</Code>

We created a Student class that contains two variables: roll number and name. Each of these variables has its corresponding setter and getter methods to modify their values and access their current values. In the Main class, we have the main method, which firstly creates a Student object “s1” and then calls the setter method to set the value of the roll number to 10 and the name to “John”. Next, it prints the values of s1’s roll number and name. On line 25, we create s2 and assign the value of s1 to s2. Next, we modify the value of the name on s2 to “Sam”. We then print the values of s1’s and s2’s roll number and name.

According to you, what should be the output of the program? If you think it’s

<Code language="java">
{`
10
John
------------
10
Sam
10
Sam
`}
</Code>

Then, it is correct, and you probably understand how Java manages objects.

Let’s examine the object creation and deletion process in detail now! The execution of a program in Java begins with loading the main function onto the stack. It then executes each instruction one after the other. In our case, execution begins from line #19.

<Code language="java">
{`
Student s1 = new Student();
`}
</Code>

Here, using the new keyword allocates memory for the Student type on the Heap. The memory block includes space for int (rollNumber) and String (name). Below is the visual representation, assuming the memory address of the allocated block is 1000.

![alter-text](/images/post/journey-image-1.png)
*Visual depiction of Object allocation in Memory*

s1 is a reference variable capable of storing only a memory address and utilizes the dot (.) operator to access the roll number and name of the memory block at address 1000. Lines #20 and #21 set the value of the roll number and name at the memory block pointed to by s1. After the execution of these lines, the visual representation looks like the following:

![alter-text](/images/post/journey-image-2.png)
*Visual depiction of Object in Memory after execution of line #21*

On lines #22 and #23, we are requesting to print the values of the roll number and name stored in the memory block referenced by s1, i.e., the memory block with address 1000. Below is the program output after the execution of lines #22, #23, and #24.

<Code language="java">
{`
10
John
------------
`}
</Code>

On line #25, we create another reference variable, s2, and assign its value to be that of s1, i.e., assigning the value 1000 to s2.

![alter-text](/images/post/journey-image-3.png)
*Visual depiction of Object in Memory after execution of line #25*

Notice that both s1 and s2 are now referencing the same memory block! Therefore, changes made via any of these reference variables will affect the same memory block. On line #26, s2 modifies the value of the name stored at the memory block, 1000. Hence, the value changes from “John” to “Sam” at memory location 1000.

![alter-text](/images/post/journey-image-4.png)
*Visual depiction of Object in Memory after execution of line #26*

On lines #27 and #28, we are requesting to print the values of the roll number and name stored at the memory location referenced by s1, i.e., 1000.

<Code language="java">
{`
10
John
------------
10
Sam
`}
</Code>

Finally, on lines #29 and #30, we are requesting to print the values of the roll number and name stored at the memory location referenced by s2, i.e., 1000.

<Code language="java">
{`
10
John
------------
10
Sam
10
Sam
`}
</Code>

After line #30, since there are no more instructions left to execute, the main method will be removed from the stack, and the execution of the program stops. As no part of the program is actively referencing memory block 1000, it will be marked for deletion by the Garbage Collector (a part of JRE). The memory block will be released for use by other processes.

![alter-text](/images/post/journey-image-5.png)
*Memory released for further usage*

That’s it! If you find this blog useful, consider liking it. If you have any questions, please comment below, and follow me for more such blogs.

*If you prefer watching videos, check out my YouTube channel at https://www.youtube.com/@gogettergeeks. For more information about me and my initiative, visit my website at https://www.gogettergeeks.com/.*

Image by 4045 on Freepik

Discover what happens behind the scenes when creating and manipulating objects in Java. Get answers to common questions about object residence, variable references, and the Garbage Collector's role.

Journey of Java Object


In this tutorial, we're going to wrap up our journey of creating an annotation-based code generator in Java. If you're just joining us, I recommend catching up on the previous parts of this series to get a comprehensive understanding of the concepts covered.

<Notice type="note" title="All Parts">
  * [Annotation-Based Code Generator in Java - Overview [1/4]](/posts/java-annotation-based-code-generator-part-1)
  * [Annotation-Based Code Generator in Java - Java Annotations [2/4]](/posts/java-annotations-code-generator-part-2)
  * [Creating a Code Generator Processor - Code Generator [3/4]](/posts/creating-a-code-generator-processor-code-generator-part-3)
  * [Packaging and Implementing Your Java Code Generator - Code Generator [4/4]](/posts/packaging-and-implementing-code-generator-part-4)
</Notice>

### Packaging Your Code Generator
Packaging your custom annotation and processor using Maven is a critical step in getting your innovative tool ready for distribution. Let's break down the process:

1. Begin by creating a META-INF/services folder within the resources folder of your Maven project. If you don't have a resources folder, go ahead and create one within the src/main directory.
2. Inside the META-INF/services folder, create a file named javax.annotation.processing.Processor.
3. Now, execute the mvn package command to build your project.
4. Open the javax.annotation.processing.Processor file you created and enter the fully qualified class name of your processor, such as com.gogettergeeks.processor.FileDBProcessor.
5. To finalize the packaging, run the mvn install command, which will place the generated JAR in your local Maven repository.

### Implementing and Using Your Code Generator
Now comes the exciting part—using the code generator you've created. Follow these steps to leverage the power of your annotation-based code generator:

Start by creating a new Maven project (assuming you're using Maven) and craft a model class. For example, let's create a Student class:

<Code language="java">
{`
import com.gogettergeeks.annotation.FileDBGenerated;
import com.gogettergeeks.annotation.Persisted;
import com.gogettergeeks.annotation.UniqueKey;

@FileDBGenerated
public class Student {
    @Persisted
    private String name;

    @Persisted
    @UniqueKey
    private int rollNumber;

    private double percentage;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getRollNumber() {
        return rollNumber;
    }

    public void setRollNumber(int rollNumber) {
        this.rollNumber = rollNumber;
    }
}
`}
</Code>

After creating your model class, execute the mvn package command to build the project. You'll notice that a target folder is generated, containing the five Java files that your code generator produces.

With the generated classes at your disposal, you're all set to start using them. In your main method, include the following code

<Code language="java">
{`
public class Main 
{
    public static void main( String[] args ) throws Exception
    {
        System.out.println("====================== START ===========================");
        StudentDao dao = new StudentDaoImpl();
        List<Student> students = dao.getAll();
        for (Student s : students) {
            System.out.println("Name: " + s.getName() + " | RollNumber: " + s.getRollNumber());
        }
        
        System.out.println("==================== ADD =======================");
        Student s1 = new Student();
        s1.setName("John");
        s1.setRollNumber(1);

        Student s2 = new Student();
        s2.setName("Tom");
        s2.setRollNumber(2);

        Student s3 = new Student();
        s3.setName("Pop");
        s3.setRollNumber(3);

        Student s4 = new Student();
        s4.setName("Baburao");
        s4.setRollNumber(4);

        dao.add(s1);
        dao.add(s2);
        dao.add(s3);
        dao.add(s4);

        students = dao.getAll();

        for (Student s : students) {
            System.out.println("Name: " + s.getName() + " | RollNumber: " + s.getRollNumber());
        }
        
        System.out.println("=================== UPDATE =============================");
        s1.setName("Sam");
        dao.update(s1);

        students = dao.getAll();
        for (Student s : students) {
            System.out.println("Name: " + s.getName() + " | RollNumber: " + s.getRollNumber());
        }
        
        System.out.println("==================== DELETE ==========================");
        dao.delete(s1);

        students = dao.getAll();
        for (Student s : students) {
            System.out.println("Name: " + s.getName() + " | RollNumber: " + s.getRollNumber());
        }
        System.out.println("==================== END ==========================");
    }
}
`}
</Code>

In this example, we're showcasing several operations including fetching, adding, updating, and deleting students using the generated classes.

<Code language="java">
{`
========================================================
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
==================== ADD =======================
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
Name: John | RollNumber: 1
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
=================== UPDATE =============================
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
Name: Sam | RollNumber: 1
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
==================== DELETE ==========================
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
Name: Tom | RollNumber: 2
Name: Pop | RollNumber: 3
Name: Baburao | RollNumber: 4
==================== END ==========================
`}
</Code>

### Conclusion
Congratulations, you've successfully reached the end of this tutorial series! You've learned how to create a sophisticated annotation-based code generator in Java, package it using Maven, and effectively utilize the generated code to perform various operations. You've gained valuable insights into custom annotations, processors, and their implementation.

If you've found this tutorial enlightening and valuable, please don't hesitate to hit the thumbs up button and share it with fellow developers. Stay tuned for more exciting tutorials to enhance your programming skills. Until next time, happy coding!



Image by jcomp on Freepik

Packaging and Implementing Your Java Code Generator - Code Generator [4/4]


***Disclaimer:** I’ve not taken formal training, nor have I read any official books or documentation around TDD. This blog contains information based on my practice and learning from colleagues.*

## What is Test-Driven Development
Test-Driven Development (TDD) is a practice in where you write a test before the implementation of the functionality. For each functionality or behavior, you do following in order
1. Write method stub (so that your code compile)
2. Write unit test
3. Run the test and see it fail
4. Implement the functionality
5. Rerun the test and see it pass
6. Repeat!

## Why TDD
### Testable Code
You focus on getting the functionality up and running when you write the code first. When you come back for writing the unit test, you tend to refactor a lot because you wrote untestable code and ultimately ends up spending additional time. Additionally, non-testable code tends to miss coding best practices. For example, see below implementation of a function “convert,” which converts amount in given currency to target currency making use of ExchangeRate client.

<Code language="java">
{`
public Double convert(String from, String to, Double amount) {
    ExchangeRateClient exchangeRateClient = new ExchangeRateClient();
    Double fromCurrencyUSDRate = exchangeRateClient.getRate(from);
    Double toCurrencyUSDRate = exchangeRateClient.getRate(to);
    return (amount/fromCurrencyUSDRate)*toCurrencyUSDRate;
}
`}
</Code>

When you’ll go and write the unit test for the above method, you’ll notice two major problems with the implementation
1. Instantiating ExchangeRateClient inline makes it impossible to mock it correctly.
2. Instantiating inline will make it hard in the future to move to a different ExchangeRate client.

### Missed Test Cases
Writing tests after the implementation leads to missing test cases, usually because you rely on code coverage. In most cases, the developer relies on test coverage to feel good about the functionality, while, in reality, it’s dangerous as it often leads to missed business-critical features. For example, in the above implementation of convert function, you can write only one test case to achieve 100% code coverage.

<Code language="java">
{`
@Test
public void convert_convertsToCADFromUSD() {
    Double expected = new Double(20);
    CurrencyManager currencyManager = new CurrencyManager();
    Double usdAmount = currencyManager.convert(Currency.CAD, Currency.USD, new Double(10));
    assertThat(usdAmount, is(expected));
}
`}
</Code>

The above tests resulted in 100% code coverage, but if you pass a negative amount, code will behave incorrectly.

### Being Focused and Organized
Following TDD makes your thought process clear and focused. You’re focused on an individual test case, and it’s implementation when working on a single functionality. Also, it reminds you to focus on the functionality/business use-case instead of writing tests for the sake of code coverage.

### Developer Ramp-up Time / Getting Started Guide for the Users
TDD forces you to write unit tests for business/functional use-cases rather than code coverage. It then serves as getting started guide for the consumer of your code or ramp-up guide for the other developers. For example, take a look at the SqlExtractor test cases from the [PocketETL](https://github.com/awslabs/pocket-etl/blob/master/src/test/java/functionalTests/SqlExtractorFunctionalTest.java) library. It’s pretty clear from the initialization code on how to use SQL extractor.

<Code language="java">
{`
private final SqlExtractor<TestDTO2> sqlExtractor = SqlExtractor.
    of(dataSource, "SELECT * FROM test_data", TestDTO2.class);

@Test
public void canReadRecordWithValues() throws Exception {
    connection.createStatement().execute("INSERT INTO test_data VALUES (1, 'test', 123, '2017-01-02 03:04:05', TRUE)");
    sqlExtractor.open(null);
    TestDTO2 expectedDTO = new TestDTO2(1, "test", 123, new DateTime(2017, 1, 2, 3, 4, 5), true);
    TestDTO2 actualDTO = sqlExtractor.next().orElseThrow(RuntimeException::new);
    assertThat(actualDTO, equalTo(expectedDTO));
}
`}
</Code>

While the following test cases show, the code is resilient to SQL injection.

<Code language="java">
{`
@Test
public void sqlBatchedStatementInjectionAttemptFails() throws Exception {
    connection.createStatement().execute("INSERT INTO test_data VALUES (1, null, null, null, null)");
    SqlExtractor<TestDTO2> sqlExtractorForInjection =
            SqlExtractor.of(dataSource, "SELECT * FROM test_data WHERE aNumber = #injectHere", TestDTO2.class)
            .withSqlParameters(ImmutableMap.of("injectHere", "5; DROP TABLE test_data"));
    try {
        sqlExtractorForInjection.open(null);
        fail("Exception should have been thrown");
    } catch (RuntimeException ignored) {
        // no-op
    }
    ResultSet resultSet = connection.createStatement().executeQuery("SELECT COUNT(*) FROM test_data");
    assertThat(resultSet.next(), is(true));
    assertThat(resultSet.getInt(1), equalTo(1));
}
@Test
public void sqlLogicHijackStatementInjectionAttemptFails() throws Exception {
    connection.createStatement().execute("INSERT INTO test_data VALUES (1, null, null, null, null)");
    SqlExtractor<TestDTO2> sqlExtractorForInjection =
            SqlExtractor.of(dataSource, "SELECT * FROM test_data WHERE aString = #injectHere", TestDTO2.class)
                    .withSqlParameters(ImmutableMap.of("injectHere", "foo' OR '1'='1"));
    sqlExtractorForInjection.open(null);
    assertThat(sqlExtractorForInjection.next(), equalTo(Optional.empty()));
}
`}
</Code>

## When to follow TDD
* Long-running project: If you’re a professional working for an IT company, you’re are likely working on a long-term project involving multiple developers contributing together. You must follow TDD to make sure you’re covering all business cases/assumptions. Also, it gives confidence in refactoring the code whenever needed.
* Libraries: If you are working on a library to be consumed by other developers, the right set of tests is vital to convey your intended usage and assumptions to the consumers. Also, it serves as your getting started guide saving multi-week effort on your part.

## When NOT to follow TDD
* One-off or small projects: For example, the project in a school, or personal website with your professional background.
* Working with unfamiliar language: In my experience, it’s hard to follow TDD while working in a different language as it becomes hard to assert certain behaviors, and you tend to go deep into implementation details.

## TDD in Action
Let’s implement the convert function for the CurrencyManager, which converts an amount from one currency to another. Let’s begin by writing the stub class and method before we get started. I’m going to assume that current exchange rates are provided by ABC source. I’m going to assume that ABCExchangeRate class is already implemented, which provides the current exchange rate from ABC source.

<Code language="java">
{`
public class CurrencyManager {
    public Double convert(Currency from, Currency to, Double amount) {
        throw new UnsupportedOperationException("This method has not been implemented yet.");
    }
}
`}
</Code>

Now let’s write a test case. I usually start with a happy case. Remember, we don’t need to worry about the implementation yet. Consider the convert function as a black box and focus on what output it’ll produce for specific input.

<Code language="java">
{`
@Test
public void convert_convertsToCADFromUSD() {
    Double expected = new Double(20);
    CurrencyManager currencyManager = new CurrencyManager();
    Double usdAmount = currencyManager.convert(Currency.CAD, Currency.USD, new Double(10));
    assertThat(usdAmount, is(expected));
}
`}
</Code>

Run the test and see it fail. Now it’s time to write the implementation and focus on getting just this case running. As I start writing the implementation, I realize I need ABCExchangeRate object to get the exchange rate. Since the exchange rate changes frequently and it’s a unit test case, I’ll need to mock it. For which, I need to dependency inject it as making the object in line will make it hard to mock. Let’s make those adjustments.

<Code language="java">
{`
/* Tests */
@Mock
private ABCExchangeRate abcExchangeRate;
@Test
public void convert_convertsToCADFromUSD() {
    when(abcExchangeRate.getRate(anyString()))
            .thenReturn(new Double(1))  // USD to USD Rate
            .thenReturn(new Double(2)); // USD to CAD Rate
    Double expected = new Double(20);
    CurrencyManager currencyManager = new CurrencyManager(abcExchangeRate);
    Double usdAmount = currencyManager.convert(Currency.USD, Currency.CAD, new Double(10));
    assertThat(usdAmount, is(expected));
    InOrder inOrder = Mockito.inOrder(abcExchangeRate);
    inOrder.verify(abcExchangeRate).getRate(Currency.USD);
    inOrder.verify(abcExchangeRate).getRate(Currency.CAD);
}
/* Implementation */
public Double convert(String from, String to, Double amount) {
    Double fromCurrencyUSDRate = abcExchangeRate.getRate(from);
    Double toCurrencyUSDRate = abcExchangeRate.getRate(to);
    return (amount/fromCurrencyUSDRate)*toCurrencyUSDRate;
}
`}
</Code>

Let’s write another unit test for validating input.

<Code language="java">
{`
@Test
public void convert_throwsInvalidParameterException_forNegativeInputAmount() {
    CurrencyManager currencyManager = new CurrencyManager(abcExchangeRate);
    assertThrows(InvalidParameterException.class, () -> {
        currencyManager.convert(Currency.USD, Currency.CAD, new Double(-10));
    });
    verifyZeroInteractions(abcExchangeRate);
}
`}
</Code>

The test failed with an error that the exception was not thrown. Let’s write the implementation now.

<Code language="java">
{`
private static final double MIN_AMOUNT = 0;
public Double convert(String from, String to, Double amount) {
    if (amount < MIN_AMOUNT) {
        throw new InvalidParameterException(String.format("Currency amount cannot be less than %s", MIN_AMOUNT));
    }
    Double fromCurrencyUSDRate = abcExchangeRate.getRate(from);
    Double toCurrencyUSDRate = abcExchangeRate.getRate(to);
    return (amount/fromCurrencyUSDRate)*toCurrencyUSDRate;
}
`}
</Code>

And now the test pass.

## Reverse TDD
Writing implementation before tests are what I term as Reverse TDD. Having gone through the whole blog, you must be wondering why reverse TDD? Well, it’s essential for refactoring or making changes to the well-established implementation and set of unit tests. In long term projects, refactoring and making specific changes in line are bound to happen frequently. For such a scenario, I prefer to do reverse TDD. This way, you identify the impact of changes to existing functionality upfront by looking at the failing tests and determine if unit tests need adjustment or inline implementation is wrong.
Let’s see Reverse TDD in action and make changes in our CurrencyManager. Suppose your business decides the minimum amount supported (maybe because of the currency conversion fee). The new requirement is to make the minimum amount to be 10 instead of 0. Let’s make the code change first and run the tests.

<Code language="java">
{`
private static final double MIN_AMOUNT = 10;
public Double convert(String from, String to, Double amount) {
    if (amount < MIN_AMOUNT) {
        throw new InvalidParameterException(String.format("Currency amount cannot be less than %s", MIN_AMOUNT));
    }
    Double fromCurrencyUSDRate = abcExchangeRate.getRate(from);
    Double toCurrencyUSDRate = abcExchangeRate.getRate(to);
    return (amount/fromCurrencyUSDRate)*toCurrencyUSDRate;
}
`}
</Code>

Now you’ll notice that a happy case unit test will fail.

<Code language="java">
{`
java.security.InvalidParameterException: Currency amount cannot be less than 10.0
    at com.currencyConvertor.CurrencyManager.convert(CurrencyManager.java:16)
`}
</Code>

This way, you realized which functionality is impacted, and you can make a call, whether it’s failing for a valid reason. Let’s correct the happy test case.

<Code language="java">
{`
@Test
public void convert_convertsToCADFromUSD() {
    when(abcExchangeRate.getRate(anyString()))
            .thenReturn(new Double(1))
            .thenReturn(new Double(2));
    Double expected = new Double(10);
    CurrencyManager currencyManager = new CurrencyManager(abcExchangeRate);
    Double usdAmount = currencyManager.convert(Currency.USD, Currency.CAD, new Double(20));
    assertThat(usdAmount, is(expected));
    InOrder inOrder = Mockito.inOrder(abcExchangeRate);
    inOrder.verify(abcExchangeRate).getRate(Currency.USD);
    inOrder.verify(abcExchangeRate).getRate(Currency.CAD);
}
`}
</Code>

Now all test cases will pass. Finally, it’s time to add a new test covering new functionality.

<Code language="java">
{`
@Test
public void convert_throwsInvalidParameterException_forAmountLessThanMinimumAmount() {
    CurrencyManager currencyManager = new CurrencyManager(abcExchangeRate);
    assertThrows(InvalidParameterException.class, () -> {
        currencyManager.convert(Currency.USD, Currency.CAD, new Double(5));
    });
    verifyZeroInteractions(abcExchangeRate);
}
`}
</Code>

## TDD Best Practices
Below are some best practices which are useful in general, or I wish someone told me as the beginner.

* When writing unit tests, treat methods under implementation as a black box. Don’t worry about the implementation detail and focus on the expected output on the given input.
* Force yourself not to write the implementation first.
* Do not treat code coverage as success criteria for writing the tests.

## Conclusion
TDD is a vital development tool that every developer should leverage. TDD helps you think from a customer’s perspective and forces you to work backward from the customer’s requirement. A well-written set of tests gives you confidence in refactoring code and usually results in uneventful code changes. TDD at first might seem time-consuming, but trust me, it’s going to save a lot of time down the line.

## References
* [PocketETL](https://github.com/awslabs/pocket-etl) library for light-weight [ETL](https://en.wikipedia.org/wiki/Extract,_transform,_load).
* [Currency convertor full code.](https://github.com/asolge/CurrencyConvertor)



Showing posts fromtech read

Coding at the age of 6?

How to prepare for a Software Developer Interview?

Journey of Java Object