DEV Community: Dhiren Serai

You don't know this yet - Fun Java concepts Part 2

Dhiren Serai — Thu, 02 Feb 2023 01:01:54 +0000

Fun concepts according to my definition are concepts which are somewhat there in the language and is not an advanced concept but is helpful to know. I didn't knew what else to call them, these are interesting but not really advanced concepts.

Literals in Java

Confusion with Zero's ?
I have this problem, when I work with bigger numbers having lots of zero's, I get confused as to how many zero's are there in the variable.

class Literals{

public static void main(String args[]){


int number = 10_000_000;

System.out.println(number);
}

}


~/open_source/java_scripts$ java Literals 
10000000

Notice how the number having lots of zero's is now separated with underscores making it easier for us to count how many zero's are there in the integer and also increases readability.

Upcasting and Downcasting of Datatypes

Type casting is when you assign a value of one primitive data type to another type.
Now like me you may wonder what are primitive data types?

In computer science, primitive data types are a set of basic data types from which all other data types are constructed.
Something which is the base data type of the language and is implemented in the language. When the datatype is derived then it's not primitive but rather "composite".

Most common example in Java would be char being a primitive data type and String which is derived from char is a composite data type.

Coming back to type casting :
In Java we have two types of type casting :

Upcasting : When the reference variable of super class refers to the object of subclass, it is known as widening or upcasting in java.

In other words, when the subclass object type is converted into superclass type, it is called widening or upcasting.

Widening Casting (automatically) - converting a smaller type to a larger type size
byte -> short -> char -> int -> long -> float -> double

Downcasting : When subclass reference refers to super class object, it is called narrowing or downcasting in java. In other words, when sub class type is converted into super class type, it is called downcasting.

Narrowing Casting - converting a larger type to a smaller size type
double -> float -> long -> int -> char -> short -> byte

Casting is done by programmers a lot of times in code inorder to convert between data types, what can be missed is the order of upcasting and downcasting.

Above order shows that if we try to convert a double to integer it will lead to an error, something like :

possible lossy conversion from double to int

Casting is a familiar concept but sometimes it's very tricky to have the order of data types in mind while casting otherwise it will lead to application errors.

Part 1 : https://dev.to/dhirensr/you-dont-know-this-yet-advanced-java-concepts-part-1-19n8

This brings us to end of the Java blog series part 2 and I hope you enjoyed reading this post.
I will continue this series of Java on different topics and concepts which I have found interesting while programming in Java.
I also share content on Twitter : DhirenSerai.
Also do let me know if you think I should document anything else that would be interesting to you.

You don't know this yet - Advanced Java concepts Part 1

Dhiren Serai — Sun, 29 Jan 2023 19:25:28 +0000

Hello everyone,
I'm Dhiren Serai, currently working for AWS S3 and I use Java extensively on a daily basis. I'm starting to write some blog posts series about Java as I have realized some new things about Java which is worth documenting and didn't come obviously to me until I read them. Hence this is the motivation for me to start writing this blog post series called "You don't know this yet".

Java is divided into two parts i.e. Core Java (J2SE) and Advanced Java (JEE). The core Java part covers the fundamentals (data types, functions, operators, loops, thread, exception handling, etc.) of the Java programming language.

Today we will start discussing about Arrays. Even though you will be surprised that Array isn't really an advanced concept and is taught in one of the first few lessons of any programming language course. This is true, but I'm not going to tell about how arrays work here but some interesting things I have noticed with Arrays in Java.

Arrays - Definition

An array is a fixed size, homogeneous data structure. The limitation of arrays is that they're fixed in size. It means that we must specify the number of elements while declaring the array.

Most of the people including me, think what if we don't know how many elements will be inserted into the array and we exceed the number that was declared in the program?

Hence, was born dynamic arrays in Java. The dynamic array is a variable size list data structure. It grows automatically when we try to insert an element if there is no more space left for the new element.

Then I tried this program, thinking that when I would declare an array of 100 elements, only to get reminded that index in Computer Science starts from 0 to 99 and not 1 to 100.

class MyArray{

public static void main(String args[]){


int[] a = new int[100]; // Allocate array in the heap, a points to the array
a[0] = 13;
a[1] = 26;
System.out.println(a.length); // read-only access .length -- 100
a[100] = 13;

}

}

Output :

100
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: Index 100 out of bounds for length 100
    at MyArray.main(MyArray.java:10)

Deep Copy vs Shallow Copy in Java

The shallow copy of an object will have exact copy of all the fields of original object. If the original object from which shallow copy is made is changed, that will lead to change to shallow copy object. This property is what makes it "shallow", because the copy is still not independent of the original object.
Shallow copy is not 100% disjoint from original object. Shallow copy is not 100% independent of original object.

Deep copy of an object will have exact copy of all the fields of original object just like shallow copy.
Any changes made to cloned object will not be reflected in original object or vice versa.

How to check for Shallow vs Deep Copy in Java?

A simple program to check which functions can be used to check for shallow vs deep copy in Java:

import java.util.Objects ;
import java.util.Arrays;

class MyArray{

public static void main(String args[]){

String[] firstArray  = {"a", "b", "c"};
String[] secondArray = {"a", "b", "c"};

System.out.println("Are they equal 1    ? " + firstArray.equals(secondArray) );
System.out.println("Are they equal 2    ? " + Objects.equals(firstArray, secondArray) );

System.out.println("Are they deepEqual 1? " + Arrays.deepEquals(firstArray, secondArray) );
System.out.println("Are they deepEqual 2? " + Objects.deepEquals(firstArray, secondArray) );

}

}

Output :

dhirensr@dhirensr-XPS-9315:~/open_source/java_scripts$ java MyArray 
Are they equal 1    ? false
Are they equal 2    ? false
Are they deepEqual 1? true
Are they deepEqual 2? true

This brings us to end of the Java Array blog. I hope you have enjoyed this post on Java Array. With this, we come to an end to this blog. I will continue this series of Java on different topics and concepts which I have found interesting while programming in Java.
I also share content on Twitter.
Also do let me know if you think I should document anything else that would be interesting to you.

Application Level Caching Overview and uses

Dhiren Serai — Fri, 09 Sep 2022 00:41:53 +0000

Latency and cost of Internet based services are a major concern for maintainers and to continue user's demands and to improve the availablility and scalability of the application encourages the usage of application level caching.

Dynamically generated web content is a major part of the web requests where the content changes based on the user request and due to this, the rate at which dynamic documents are delivered is often slower than static documents. Therefore, dynamic content place a load on the server which can lead to performance bottlenecks.

One of the techniques used to meet user's demands and reduce overhead on the servers is caching. Caching can reduce the user perceived latency and Internet traffic, and improve the scalability and availability of servers.

Application-level caching is placed on the server-side and typically uses a key-value in-memory store system to cache frequently accessed or expensive to compute data that remain not cached in other caching levels, lowering the load on database or services that are difficult to scale up.

Even though the concept is quite popular nowadays in applications, there are still designs which the developers integrating in system design need to take care of.

The design should pose four main questions :

How to cache the data?
What data should be cached?
When should be the data be cached?
Where the cached data should be put ?
For how long should be data be cached and then cache should get updated?

There are lots of resources online on how to use caching optimally and also there are tools available.

For Caching, Memcached and Redis are popular solutions and are a critical web infrastructure component.

Caching Example on server side:

Caching on webserver can be implemented at many places depending on the architecture of the system.Depending on where caching is implemented, different types of content can be cached like the final HTML page , intermediate HTML or XML
fragments,database queries, or database tables.

The figure llustrates an example where an application level cache is used to lower the application workload. The application gets an HTTP request from the user and then goes to the webserver, then webserver tries to search the data in the cache, depending on how the cache is implemented. If the data is found in the cache it would result in a cache hit, otherwise it would be cache miss. In case of cache miss, webserver would query the data to the database itself, which could take a bit longer for the first time. But once it obtains the data from database, it would put it in cache again to serve the request from the user again in the future. Based on the caching strategy, the developers of the webserver would need to decide on how long would the data be cached.

Memcached and Redis are popular solutions and are a critical web infrastructure component.

If you liked reading the content, please do share it with other people who you think might be interested.
Also I do regularly post content on Twitter, do follow me @DhirenSerai for more.

Top Linux Commands that will help you for text processing.

Dhiren Serai — Mon, 29 Aug 2022 22:25:00 +0000

Have you ever felt the need to process text in logs to search something in a massive amount of logs ? Have you ever tried to search in the logs which were compressed? Did you try to search by uncompressing it first? Were the log files having patterns from which you had to extract some text?

This blog post covers some helpful commands and their usage in Linux for text processing.

Viewing all the text files together in the directory.

If the text files or log files of a Software component is splitted across different files as it's common for log files to be split on an hourly basis in a large system where the logs are then rotated on an hourly/minutely basis. While searching logs, you want to view them all aggregated together and then search instead of going through each file.


cat * | less
or 
cat logs_files* | less

cat with a wildcard pattern would help with that.

But cat command will not work if the files are compressed ?

zcat

use the below command to view the text files all appended together , and this will work even if the text files are compressed, it decompresses it in memory and shows the output text.


zcat * | less
or 
to view all the log files starting with logs_pattern
zcat logs_pattern* | less

Grep

The grep command is one of the most useful commands in a Linux terminal environment. The name grep stands for "global regular expression print". This means that you can use grep to check whether the input it receives matches a specified pattern
so if you want to search a specific pattern or text in a file then you could use grep to find it.

grep "pattern" file
#if you want to make it search accross all files
cat * | grep "pattern" file
or 
zcat * | grep "pattern" file

grep tool is not only used for matching patterns in files but can also be used to filter out certain patterns

grep -v pattern myfile

tells grep to print only those lines which do not match the pattern.

Now that we are done with finding the text were looking for in the text files or logs , and now we want to extract some information from them?

sed and awk

While it's difficult to cover all the different types of usage in a single blog post as each of the command would require 1 blog post, I would still try to give an overview as to how these commands will be helpful.

sed is a useful text processing feature of GNU/Linux. The full form of sed is Stream Editor

Unix provides sed and awk as two text processing utilities that work on a line-by-line basis.

The sed program (stream editor) works well with character-based processing, and the awk program (Aho, Weinberger, Kernighan) works well with delimited field processing.

awk '{print $3}' filename

This command will display only the third column from filename

sed -n '/hello/p' file1

This command will display all the lines which contains hello

sed 's/hello/HELLO/' file1

This command will substitute hello with HELLO everywhere in the file. the 's' in the command is for substitution.

tr - translate

this command is used to translate the characters in a file in some other forms like squeezing the repetitive characters and replacing it with the single occurrence of that character or deleting a character.

tr -d ',' < file1

This command will delete all the occurrence of comma(",") from the file file1.

tr -d "hello" < file1

This command will delete all the occurrence of any of the characters h or e or l or o from the file fle1.

The JQ command can be used in many different ways; It can be used directly on a JSON file and can also be combined with several other commands to interpret JSON data.

jq command is very powerful when working with JSON data which could be obtained from a REST API or from logs of a server.

Let's say example JSON is this:

{"users":{"name": "Dhiren","id": "001"}}

to extracts the inner map of users, we would use:

jq '.users' users.json

To extract the name we would use the following :

jq '.users.name' users.json

That's all for today! I'm a LINUX enthusiast and would cover more blogs related to Linux, Cloud Computing and Software development in general. I post daily on my twitter account.

Let's connect!

✨ Twitter

✨ Github