Madhu's Blog

2026-03-26T08:32:00.005-05:00

My Attempt to learn AI

GPT

Generative Pretrained Transformer
Created by Google in 2017 with the publication of the paper "Attention is all you need"
Its a design on how an AI system processes language
with its introduction computers became good at understanding languages
The strength of Transformers is "Attention", which is the ability to look at all the words in a sentence at once and understand the relationship with each other.
The dog chased its tail becoz it was bored. Here it refers to dog and not tail.
Generative means when we ask a question it constructs the answer and not search the database based on patterns it learned from pre-training.

AI existed long before 2017,

chatbots, spam filters
never felt truly intelligent
Bad at understanding

Core Idea of AI is to predict what comes next, but with the introduction of GPT, the execution became more efficient

LLM (Large Language Model) are good at good at analyzing languages and predicting the response.

It is a very impressive text generator
Large in LLM can be due to the fact that

The model has been trained on a large data set
It has large set of parameters

2024-05-02T07:24:00.005-05:00

Python Basics

How to check the version of Python interpreter

mac terminal

Common JPA explanations

2023-03-22T13:19:00.002-05:00

**This is just for reference only, most of the source of these infor is taken from stackoverflow.

When to use eager loading

In "one side" of one-to-many relations that you sure are used every where with main entity. like User property of an Article. Category property of a Product.
Generally When relations are not too much and eager loading will be good practice to reduce further queries on server.

When to use lazy loading

Almost on every "collection side" of one-to-many relations. like Articles of User or Products of a Category
You exactly know that you will not need a property instantly.

https://stackoverflow.com/questions/31366236/lazy-loading-vs-eager-loading

Could not connect to the database. Exiting now... MongooseServerSelectionError: connection timed out

2022-12-20T02:46:00.004-06:00

Getting the following error in AWS, while trying to run node js docker container

[2022-12-19T19:03:56.378] [ERROR] server:825 Could not connect to the database. Exiting now... MongooseServerSelectionError: connection timed out

at NativeConnection.Connection.openUri (/app/node_modules/mongoose/lib/connection.js:825:32)

at /app/node_modules/mongoose/lib/index.js:417:10

at /app/node_modules/mongoose/lib/helpers/promiseOrCallback.js:41:5

at new Promise (<anonymous>)

at promiseOrCallback (/app/node_modules/mongoose/lib/helpers/promiseOrCallback.js:40:10)

at Mongoose._promiseOrCallback (/app/node_modules/mongoose/lib/index.js:1270:10)

at Mongoose.connect (/app/node_modules/mongoose/lib/index.js:416:20)

at Object.<anonymous> (/app/server.js:30:10)

at Generator.next (<anonymous>) {

reason: TopologyDescription {

type: 'Unknown',

servers: Map(1) { '3.129.14.175:27017' => [ServerDescription] },

stale: false,

compatible: true,

heartbeatFrequencyMS: 10000,

localThresholdMS: 15,

setName: null,

maxElectionId: null,

maxSetVersion: null,

commonWireVersion: 0,

logicalSessionTimeoutMinutes: null

code: undefined

Make sure that the node.js app configuration uses the white listed mongo db internal IP address.

bcrypt error while running zest

2022-12-10T08:22:00.003-06:00

"../bcrypt_lib.node' (mach-o file, but is an incompatible architecture (have (arm64), need (x86_64)))" while running tests

This is probable you are using an old version of node. check by

nvm list

nvm use v16.17.0

To check the current version of node running, in the terminal use the command

node --version

Output in the Terminal :

The following command will list the different node versions already installed in your system.

nvm ls

Output in the Terminal :

To switch to more recent version of the node ie, v16.17.0, use the following command in the terminal

nvm use v16.17.0

Output in the Terminal :

Now confirm the current version of the node by

node --version

Output in Terminal:

Got the error while running a golang for the first time in mac

2022-10-16T18:42:00.002-05:00

go build -i cause open /usr/local/go/pkg/darwin_amd64/runtime/cgo.a: permission denied

Navigate to the folder and type in the following command

sudo chmod -R 777 /usr/local/go, which will prompt to type in the mac password.

2022-08-31T10:11:00.003-05:00

Spring Framework Features

core technologies :- dependency of injection, events, resources, internationalization, validation, data binding, type conversion, the SpEL expression language, and then the AOP. The AOP, the Aspect-Oriented Programming is one of the main technologies. And I think this is the heart of the Spring Framework.

testing: mock object, TestContext framework. If you want to just test your controllers from the Spring MVC, you can do that with the Spring MVC Test. And of course you have a way to test a client's request calls with a WebTestClient.

data access:- transactions, JDBC, DAO support, ORM. Marshalling with XML

Spring MVC and the Spring WebFlux frameworks

integration:- remotely, messaging, all the way to do JMX, email, task, scheduling, and cache, language:- Kotlin, Groovy, and any other dynamic languages.

Data Types in Java

2022-08-03T12:25:00.011-05:00

Primitive data types

These are the basic building block data types in Java

They are boolean, byte, char, short, int, long, float, double

Java Primitive Data types and their limits

If you try to put a value greater than the maximum value for a data type, it will result in an Overflow

If you try to put a value lesser than the minimum value for a data type, it will result in an Underflow

Int

package com.hello.pkg;

public class BasicDataTypes {

    public static void main(String[] args) {
        int intMinValue = Integer.MIN_VALUE;
        int intMaxValue = Integer.MAX_VALUE;
        System.out.println("Min: " + intMinValue + " , Max: " + intMaxValue);
        System.out.println("Overflow: " + (intMaxValue + 1) + " , Underflow: " + (intMinValue -1));
        int literalValue = 2_147_483_647;
        System.out.println("Int as literal Value: " + literalValue);

        byte byteMinValue = Byte.MIN_VALUE;
        byte byteMaxValue = Byte.MAX_VALUE;
        System.out.println("Byte Min: " + byteMinValue + " , Byte Max: " + byteMaxValue);

        int shortMinValue = Short.MIN_VALUE;
        int shortMaxValue = Short.MAX_VALUE;
        System.out.println("Short Min: " + shortMinValue + " , Short Max: " + shortMaxValue);
    }
}

Output

Min: -2147483648 , Max: 2147483647

Overflow: -2147483648 , Underflow: 2147483647

Int as literal Value: 2147483647

Byte Min: -128 , Byte Max: 127

Short Min: -32768 , Short Max: 32767

Java treats Double as the default floating point number

For precise calculations like currency calculations Java recommends using BigDecimal

A float gives you approx. 6-7 decimal digits precision while a double gives you approx. 15-16. Also the range of numbers is larger for double.

A double needs 8 bytes of storage space while a float needs just 4 bytes.

This will give error:

public class MyClass {
    public static void main(String args[]) {
        float a = 0.5;
    }
}

/MyClass.java:3: error: incompatible types: possible lossy conversion from double to float float a = 0.5;

This will work perfectly fine

public class MyClass {
    public static void main(String args[]) {
        double a = 0.5;
    }
}

This will also work perfectly fine

public class MyClass {
    public static void main(String args[]) {
        float a = (float)0.5;
    }
}

Reason : Java by default stores real numbers as double to ensure higher precision.

Hello World Java Program

2022-08-01T15:11:00.003-05:00

This is how we would write a Hello World program in java

package com.hello.pkg;

public class HelloWorld {

    public static void main(String args[]) {
        System.out.println("Hello World");
    }
}

Here is the explanation

public class HelloWorld

(1) public - It is an access modifier

(2) class - This is a Java class

 public static void main(String args[])

(1) public - public access modifier on the method

(2) static - the method can be accessed without creating an object of HellloWorld class

(3) void - there is no return type for main method

(4) main - name of the method, the main method is the entry point for any java application

(5) String[] args means an array of sequence of characters (Strings) that are passed to the "main" function. This happens when a program is executed.

Example when you execute a Java program via the command line:

java HelloWorld test one

Therefore, the array will store: ["test", "one"]

Postman Error: Maximum response size reached

2021-05-26T10:26:00.004-05:00

While I was trying to perform a GET operation in POSTMAN. I got the error

Error: Maximum response size reached

then I read about-

Max response size: Option to limit the size of response (in Megabytes) that is rendered by Postman. If the limit is exceeded, Postman will inform you that the received response is large (default limit: 50 MB) and provide options to increase the size limit or download the response.

and my response was about 62 MB, so need to increase it

Click on Settings and the change the Max response size in MB to 100 to fix my problem.

node:42932) Warning: To load an ES module, set "type": "module" in the package.json or use the .mjs extension.

2020-11-22T15:18:00.006-06:00

This error message is basically saying that in order for us to start using import feature of ESM then we need to specify the following.

As specified in the warning setting "type": "module" in the package.json solves the problem.

Constants in Go

2020-10-25T09:41:00.011-05:00

Constants are declared are as follows

package main

import "fmt"

func main() {
    const soundSpeed = 343
    fmt.Println(soundSpeed)
}

Some key points

A value should be assigned to a constant when it is declared

We cannot declare a constant and initialize it later.

Once a constant is created you cannot re-assign a value to that constant.

You cannot assign a value of a constant as a return value of a function, since the value of a constant is evaluated at compile time and methods are evaluated at runtime.

Implicit declaration syntax

Here the compiler will interpret the type as it runs to it

package main

import "fmt"

func main() {
    const soundSpeed = 343
    fmt.Println(soundSpeed)
    fmt.Println(soundSpeed + 3.65)
}

Output:

The following is an example for explicit declaration

package main

import "fmt"

func main() {
    const soundSpeed int = 343
    fmt.Println(soundSpeed)
    fmt.Println(soundSpeed + 3.65)
}

This will throw .\main.go:8:25: constant 3.65 truncated to integer error

Pointer Type variables in Go

2020-10-22T09:10:00.006-05:00

Pointer Type variables

Pointer variables holds the address of memory that holds the value of the variable

package main

import "fmt"

func main() {
    var name *string
    fmt.Println(name)
}

<nil> is go's terminology for an empty pointer object.

De-Referencing a pointer

As given below fmt.Println(*name) is de-referencing a pointer.

package main

import "fmt"

func main() {
    var name *string = new(string)
    *name = "Madhu"
    fmt.Println(*name)
}

package main

import "fmt"

func main() {
    name := "Madhu"
    deRef := &name
    fmt.Println(deRef, *deRef)
    name = "Tomy"
    fmt.Println(deRef, *deRef)
}

Here the name stores the value "Madhu", the variable deRef stores the address of the variable name or it is a pointer variable.

Now I change the value of name, the value of deRef variable also changes automatically.

Primitive Data Types in Go

2020-10-21T14:56:00.008-05:00

Variable declarations and primitives

(1) Declaration using var keyword

var <variable name > <type>

var <variable name > <type>

package main

import "fmt"

func main() {
    var i int
    i = 24
    fmt.Println(i)
}

This is used if you want to initialize a variable at a different position

Another way is

package main

import "fmt"

func main() {
    var number int = 52
    fmt.Println(number)
}

(2) Implicit initialization

Here go with pick up the data type

package main

import "fmt"

func main() {
    number := 52
    fmt.Println(number)
}

All local variables that are declared should be used otherwise it will throw a compilation error.

Data Types

(1) Value data types - Here the variables refer to the values the variables hold

(2) Pointer Data types - Here the variables refer to the address location where the values are stored.

Complex data type

This is a built in data type in Go.

package main

import "fmt"

func main() {
    a := 10.0
    b := 5.0
    c := complex(a, b)
    fmt.Println(c)
    r, i := real(c), imag(c)
    fmt.Println(r, i)
}

Output :
(10+5i)
10 5

Type

int An integer. Holds whole numbers.

float64 A floating-point number. Holds numbers with a fractional part. (The 64 in the type

name is because 64 bits of data are used to hold the number. This means that

float64 values can be fairly, but not infinitely, precise before being rounded off.)

bool A Boolean value. Can only be true or false.

string A string. A series of data that usually represents text characters

Node.js

2020-10-01T11:10:00.008-05:00

Node.js is an asynchronous event driven javascript run time or server side javascript.

Commonly found in microservices and api space.

Command line tools like gulp

Server less cloud functions.

Node.js is run on javascript v8 engine

Ryan Dahl is the creator of Node.js

Node.js is best for I/O intensive network apps but not for CPU intensive apps.

Node uses an event loop in a single threaded model. It means there is no simultaneous access to shared memory.

The event loop will be notified when a request to open a file has been fulfilled by the OS.

An incoming HTTP request will also fire an event.

Timers can fire an event in the future, which is also handled by event loop.

These events are typically surfaced in your application by registering callback functions.

In node the fair treatment of client is the responsibility of the app.

Go

2020-08-06T13:48:00.005-05:00

1. Developed by Robert Griesemer, Rob Pike, and Ken Thompson at Google.

2. Like C it has good grasp for developing around system programming.

3. Just like C language it does n't need a run time interpreter. So a compiled language

4. Strongly types language

5. Support type inference

In order to make sure that we have a standalone program, that file should start with

package main

Improve your code quality by using SonarLint in IntelliJ IDEA

2020-07-15T09:33:00.001-05:00

Improve your code quality by using SonarLint in IntelliJ IDEA

Required Java version 1.8 +

Intellij IDEA 2019.3.5 Community Edition

You can download it at

https://plugins.jetbrains.com/plugin/7973-sonarlint

In Intellij go to File > Settings > Plugins

Search Market place for Sonar Lint, install it

To run it right click on the file you want to run against

This is how the sonarlint tab with the analysis results would look like

Hope this helps :)

Java code Tips

2020-07-14T13:31:00.015-05:00

(1) In logger statements use Format specifiers instead of string concatenation.

logger.info("Completed populating RAW data from the file " + fileId + " ,Took " + (System.currentTimeMillis() - dataEntryTime) + " ms."));

Because printf-style format strings are interpreted at runtime, rather than validated by the compiler, they can contain errors that result in the wrong strings being created.

logger.info(String.format("Completed populating RAW data from the file %s ,Took %d ms.", fileId, (System.currentTimeMillis() - dataEntryTime)));

Prefer the following log statement

logger.info( "Completed populating RAW data from the file {} ,Took {} ms.
",fileId, (System.currentTimeMillis() - dataEntryTime));

{} allows delaying the toString() call and string construction to after it has been decided if the event needs capturing or not.

(2) Try-with-resources should be used

Java 7 introduced the try-with-resources statement, which guarantees that the resource in question will be closed. Since the new syntax is closer to bullet-proof, it should be preferred over the older try/catch/finally version.

This rule checks that close-able resources are opened in a try-with-resources statement.

(3) "java.nio.Files#delete" should be preferred

When java.io.File#delete fails, this boolean method simply returns false with no indication of the cause. On the other hand, when java.nio.file.Files#delete fails, this void method returns one of a series of exception types to better indicate the cause of the failure. And since more information is generally better in a debugging situation, java.nio.file.Files#delete is the preferred option.

if (null != tempFile) {
	tempFile.delete();	
}

instead use the following

try {
	if (null != tempFile) {
		Files.delete(tempFile.toPath());
	}
} catch (Exception ex) {
	logger.error("Error", ex);
}

(4) Null checks

for an object foo, the following is the best way to check for null

if(foo != null && foo.bar()) {
   someStuff();
}

Java 7 introduced the new Objects API

Objects.isNull(obj) //returns true if the object is null

Objects.nonNull(obj) //returns true if object is not-null

if(Objects.nonNull(foo) && foo.something())

Here are some good documentations

https://www.baeldung.com/java-avoid-null-check

https://stackoverflow.com/questions/17302256/best-way-to-check-for-null-values-in-java/40777583#:~:text=In%20Java%208%2C%20the%20best,not%2Dnull%20if(Objects.

(5) Package name naming convention

This is the convention ^[a-z_]+(\.[a-z_][a-z0-9_]*)*$: so no Upper case.

(6) Avoid instantiating objects in a loop

ogger.info("Start Time : {} and End Time : {} for {}", new Date(1565601480000L).toInstant(), new Date(1565601480000L).toInstant(), "check");

Instead use

logger.info("Start Time : {} and End Time : {} for {}", Instant.ofEpochMilli(1565601480000L), Instant.ofEpochMilli(1565601480000L), "check");

(7) Use Varangs when possible

The following method call

combineData(Employee e1, Employee e2, Employee e3);

The method can be written using varangs as shown below.

private void combineData (Employee... emp) {

// Here is how you access the individual objects

Employee e1 = emp[0];

Employee e2 = emp[1];

Employee e3 = emp[2];

(8) Uncheck or raw use of ArrayList

return new ArrayList(new TreeMap<Long, ProcessedDataInfo.ProcessedDataRow>(combinedDataMap).values());

instead use the following

return new ArrayList<>(new TreeMap<Long, ProcessedDataInfo.ProcessedDataRow>(combinedDataMap).values());

(9) Utility classes should not have a public constructor

Utility classes, which are collections of static members, are not meant to be instantiated. Even abstract utility classes, which can be extended, should not have public constructors.

Java adds an implicit public constructor to every class which does not define at least one explicitly. Hence, at least one non-public constructor should be defined.

So the following Utility class

public class Constants {

public static final Long ONE_HOUR = 1000*60*60L;

public static final Long TWENTY_MINUTES = 20*60*1000L;

public static final Long THIRTY_MINUTES = 30*60*1000L;

}

should be like this

private Constants () {

throw new IllegalStateException("Utility class");

}

(10) Source code lines

NCSS (Non commented source code lines) should not exceed 1500 per PMD tool.

(11) Whenever you write a method always consider The Law of Demeter

Its about loose coupling

Each unit should have only limited knowledge about other units: only units "closely" related to the current unit.
Each unit should only talk to its friends; don't talk to strangers.
Only talk to your immediate friends.

Spring Boot Tips

2020-07-12T19:00:00.001-05:00

(1) How to display mongodb query while using spring-data-mongodb

Set the following line entry in the application.properties

logging.level.org.springframework.data.mongodb.core=DEBUG

Make sure that log4j is available in the project

Caused by: java.sql.SQLFeatureNotSupportedException: Method org.postgresql.jdbc.PgConnection.createClob() is not yet implemented.

2020-06-11T14:03:00.001-05:00

Spring Boot: 2.1.3.RELEASE
JDK : 1.8
PostgresSQL: 12.3

I am getting the following exception while starting the application

Caused by: java.sql.SQLFeatureNotSupportedException: Method org.postgresql.jdbc.PgConnection.createClob() is not yet implemented.

This is an issue with hibernate library. This has been fixed in the following version and available in Spring boot v2.2.0.Mx

<dependency> <groupId>org.hibernate</groupId> <artifactId>hibernate-core</artifactId> <version>5.4.2.Final</version> </dependency>

Since I cannot upgrade Spring Boot i need to disable the Large Object creation by the following entry in application.properties

spring.jpa.properties.hibernate.jdbc.lob.non_contextual_creation=true

For more info refer : https://stackoverflow.com/questions/49110818/method-org-postgresql-jdbc-pgconnection-createclob-is-not-yet-implemented

How to restore a backup db in postgresql

2020-06-11T12:00:00.003-05:00

1. Open up pgadmin4

2. Select the database to which the db should be restored.

3. Right click and select the option restore

4. Type in the info and local the backup db archieve

Postgresql

2020-06-11T10:47:00.000-05:00

PostgreSQL Limits

Maximum Database size : unlimited
Maximum Table size : 32 TB
Maximum Row size : 1.6 TB
Maximum Fiels size : 1 GB
Maximum Rows per Table: unlimited
Maximum columns per Table : 250-1600 depending on the column types
Maximum indices per table: unlimited

Varargs feature (Variable Arguments) in Java

2020-05-26T09:43:00.000-05:00

This was introduced in java 1.5

It means variable arguments

Background

Before 1.5, if we need to pass different number of arguments to a method we need to use method overloading or pass it in an Array.

public class TestVarargs

{ 

    static void funtion(int...numbers) 

    { 

        System.out.println("Number of arguments: " + numbers.length); 

        // using for each loop to display contents of a 

        for (int i: numbers) 

            System.out.print(i + " "); 

    } 

    public static void main(String args[]) { 

        funtion(100);         

        funtion(11, 22, 55);  

        funtion();            

    } 

}

Varargs

(1) Allows us to pass arbitery no of arhuments automatically.

(2) There can be only one varargs in a method and it should be the final argument.

(3) Very good with concrete data types but be careful while using with Generics.

(4) The three periods after the final parameter's type indicate that the final argument may be passed as an array or as a sequence of arguments.

Hope this helps :)

IDEA IntelliJ shortcut keys

2020-05-20T17:06:00.001-05:00

1. Toggle case Cntl+Shift+U

2. How to increase the Heap memory in IntelliJ

Step 1: Go to Help -> Edit Custom VM Options

Step2: Change the Heap sizes as given below

2. How to view the memory usage in IntelliJ

File -- Settings -- Appearance

Select the "show memory indicator" option and click on "OK" button.

This is how the memory indicator would look like on the bottom right corner of the IDE.

Spring Boot Dev Tools

2020-05-20T15:21:00.000-05:00

In a typical application development environment, a developer would make some changes, build the project and deploy/start the application for new changes to take effect.

Using spring-boot-devtools, this process is also automated. Whenever files change in the classpath, applications using spring-boot-devtools will cause the application to restart. The benefit of this feature is the time required to verify the changes made is considerably reduced:

The thread that has spawned the application is not a main rather a restartedMain thread. Any changes made in the project be it a java file change will cause an automated restart of the project:

The spring-boot-devtools module can be included in any project to provide additional development-time features. To include devtools support, add the module dependency to your build, as shown in the following listings for Maven and Gradle:

Maven


    
        org.springframework.boot
        spring-boot-devtools
        true

Gradle

dependencies {
    developmentOnly("org.springframework.boot:spring-boot-devtools")
}

Developer tools are automatically disabled when running a fully packaged application. If your application is launched from java -jar or if it is started from a special classloader, then it is considered a “production application”. If that does not apply to you (i.e. if you run your application from a container), consider excluding devtools or set the -Dspring.devtools.restart.enabled=false system property.

Flagging the dependency as optional in Maven or using the developmentOnly configuration in Gradle (as shown above) prevents devtools from being transitively applied to other modules that use your project.