DEV Community: TEJAS-PORWAL

Java Unleashed: Tips for Success and Traps to Avoid

TEJAS-PORWAL — Mon, 06 May 2024 18:47:05 +0000

Welcome back, dear Readers!😀. Welcome to the world of Java, where innovation meets reliability, and every line of code holds the potential to shape the digital landscape. Whether you're a seasoned developer navigating the intricacies of Java's ecosystem or an eager learner taking your first steps into the realm of object-oriented programming, this blog is your guide to mastering Java's nuances, pitfalls, and possibilities. Join us on a journey through the Java Unleashed: Tips for Success and Traps to Avoid, where we'll explore the secrets to writing elegant, efficient code and sidestep the common pitfalls that lurk beneath the surface.
So Let's get started and see them One by One.

Don't Concatenate many Strings
In Java, you can easily merge a few strings into one by using the concatenation operator or the plus sign.

It's easy, quick, and can be freely used when you only have a few strings to concatenate.

However, you may run into serious performance problems when you start concatenating too many strings. Let's see a example to demostrate that

One way to solve this issue is to use StringBuilder or StringBuffer from where we can leverage an inbuilt method 'append' to perform this operation. Here I'm using StringBuffer which is also a threadsafe option.

Output

Note: the time spent may vary here depending on your system performance.

Pick the right datatype for ID
Stop picking int or Integer to store Id.

first of all there is a conceptual problem as _Integers _are numeric datatype they should be used to represent numbers and perform operation on them in a mathematical sense. Now if you think about identifiers do they make sense as mathematical numbers? No right.
Also an Identifier may contains leading zeroes which may be useful to represent something meaningful and using int or Integer will not help to retain those leading zeroes as they will be trimmed.

So what's the solution to this problem well you can always go with String as first choice to represent Id. And also to provide the solution to this java provides an UUID(universally unique identifier) class (java.util.UUID) which helps to generate a 36 characters long unique number.

Keep your API clean
Make sure your methods and classes aren’t too long. While there’s no strict rule regarding the exact number of lines or words for a class, it’s advisable to maintain a focused and cohesive structure. When it comes to methods, it’s generally suggested to aim for around 10 to 20 lines of code per method. If a method gets longer, it might be better to split it into smaller, more manageable parts.

Make use of Otional Class in java
Every Java Programmer is familiar with NullPointerException. It can crash your code. And it is very hard to avoid it without using too many null checks. So, to overcome this, Java 8 has introduced a new class Optional in java.util package. It can help in writing a neat code without using too many null checks. By using Optional, we can specify alternate values to return or alternate code to run. This makes the code more readable because the facts which were hidden are now visible to the developer.

Use @ Override and @ deprecated
In Java, annotations are the metadata that we used to provide information to the compiler. Here, the @ _Override _annotation specifies the compiler that the method after this annotation overrides the method of the superclass.

It is not mandatory to use @ Override. However, when we use this, the method should follow all the rules of overriding. Otherwise, the compiler will generate an error.
Rules ->

Both the superclass and the subclass must have the same method name, the same return type and the same parameter list.

We cannot override the method declared as final and static.

We should always override abstract methods of the superclass.

Similarly, if we don't feel the need to use an existing API we should always use @ deprecated which warns other that this API is deprecate and should not be used further for any purpose.

Program to _Interface _where appropriate
Always if a matching interface type id available, declare things like parameters, return values, variables and fields using that interface type. Let's see a small example to demonstrate that.

Make use of Generics in java
Generics is one of the most useful feature that java offers. So exactly is Generics in java well the answer to that is simple and easy to understand. Generics are parameterized types. The idea is to allow type (Integer, String, … etc., and user-defined types) to be a parameter to methods, classes, and interfaces. Using Generics, it is possible to create classes that work with different data types. Let's visualize that with an example here

Generics also offers few Type parameter which can be picked up based on your requirements

T - Type
E - Element
K - Key
N - Number
V - Value

Here are some benefits to keep in mind if you intend to use them

Type Safety
Code Reusability
Elimination of Type Casting
Improved Readability and Maintainability
Enhanced Performance
Stronger Abstraction

BONUS TIP
what are view on the below given statement are these One and the same or Not?🤔

NOT A GOOD PRACTICE

A BETTER WAY

well both the statement has the same meaning but in
the first statement we directly compares the result of whatFruit.getFruitType() with the enum constant FRUITS.APPLE using the equals() method. This approach can potentially lead to a NullPointerException if whatFruit.getFruitType() returns null because calling equals() on null would throw an exception.

And in the second approach we see that it reverses the comparison, checking if the enum constant FRUITS.BANANA is equal to the result of whatFruit.getFruitType(). This approach is safer because it avoids potential NullPointerException. Even if whatFruit.getFruitType() returns null, the comparison will not throw an exception because FRUITS.BANANA is not null.And also make it thread-safe.

To Summarize adhering to best practices in Java is essential for writing clean, maintainable, and efficient code. By following the principles outlined in this article, you can enhance the readability, reliability, and scalability of your Java applications. I hope you can incorporate these best practices into your Java development workflow, you can elevate the quality of your code and become a more proficient Java developer.

That's it for this blog see you all next time with something new.

Java Unleashed: Tips for Success and Traps to Avoid

TEJAS-PORWAL — Mon, 06 May 2024 18:47:05 +0000

Don't Concatenate many Strings
In Java, you can easily merge a few strings into one by using the concatenation operator or the plus sign.

It's easy, quick, and can be freely used when you only have a few strings to concatenate.

However, you may run into serious performance problems when you start concatenating too many strings. Let's see a example to demostrate that

Output

Note: the time spent may vary here depending on your system performance.

Pick the right datatype for ID
Stop picking int or Integer to store Id.

first of all there is a conceptual problem as Integers are numeric datatype they should be used to represent numbers and perform operation on them in a mathematical sense. Now if you think about identifiers do they make sense as mathematical numbers? No right.
Also an Identifier may contains leading zeroes which may be useful to represent something meaningful and using int or Integer will not help to retain those leading zeroes as they will be trimmed.

Use @ Override and @ deprecated
In Java, annotations are the metadata that we used to provide information to the compiler. Here, the @ Override annotation specifies the compiler that the method after this annotation overrides the method of the superclass.

It is not mandatory to use @ Override. However, when we use this, the method should follow all the rules of overriding. Otherwise, the compiler will generate an error.
Rules ->

Both the superclass and the subclass must have the same method name, the same return type and the same parameter list.

We cannot override the method declared as final and static.

We should always override abstract methods of the superclass.

Similarly, if we don't feel the need to use an existing API we should always use @ deprecated which warns other that this API is deprecate and should not be used further for any purpose.

Program to Interface where appropriate
Always if a matching interface type id available, declare things like parameters, return values, variables and fields using that interface type. Let's see a small example to demonstrate that.

Make use of Generics in java
Generics is one of the most useful feature that java offers. So what exactly is Generics in java well the answer to that is simple and easy to understand. Generics are parameterized types. The idea is to allow type (Integer, String, … etc., and user-defined types) to be a parameter to methods, classes, and interfaces. Using Generics, it is possible to create classes that work with different data types. Let's visualize that with an example here

Generics also offers few Type parameter which can be picked up based on your requirements

T - Type
E - Element
K - Key
N - Number
V - Value

Here are some benefits to keep in mind if you intend to use them

Type Safety
Code Reusability
Elimination of Type Casting
Improved Readability and Maintainability
Enhanced Performance
Stronger Abstraction

BONUS TIP
what are view on the below given statement are these One and the same or Not?🤔

NOT A GOOD PRACTICE

A BETTER WAY

Here is the link to my github Repo to check out detailed example on each key points here and some extra info. Do check this out

https://github.com/TEJAS-PORWAL/Java_goodPractice

That's it for this blog see you all next time with something new.

Code Chronicles: My Journey as a Developer - Reflections on the Past Few Months

TEJAS-PORWAL — Thu, 11 Apr 2024 18:50:03 +0000

Welcome back, dear readers! It's been quite a journey over the past couple of months for me. As we settle into a new chapter, it's time to reflect on the lessons learned, the challenges faced, and the growth experienced. Let me share my learning experience of my corporate journey till now.

Learned a lot about system design and it's importance in product-based company. Hence selecting a appropiate design pattern helps you to keep your work top-notch and avoid any negative feedback over your code-review. Design patterns are powerful tools for building flexible, maintainable, and scalable software systems. Whether we are designing a simple application or a complex enterprise system, the knowledge of design patterns will undoubtedly be invaluable in our journey as a software developer.

Till now got a chance to cover all the Creational-Design pattern,
also from Structural-Design pattern only used Facade pattern.
And few of them from the Behavioural-Design pattern. Will try to unveil in-depth about all the Design-pattern in next blog.

Also working in java gave me a chance to explore the features of java which definitely did took, some time for me to get hands-on in the early stage but once I got the hang of it are now definitely coming handy and make my code more readable and easily understandable.

Lambdas and Functional Interfaces

Streams API

Optional Class

Using Generic Classes

Using Tuples

Illustration of code before I use above java features

public static void main(String[] args) {
        List<String> nameList = Arrays.asList("Tejas", "Sammer", "Aditya", "Saurabh");
        List<String> convertedNameList = new ArrayList<>();
        for(String name : nameList){
            if(name.startsWith("S")){
                convertedNameList.add(name.toLowerCase());
            }
        }
        System.out.println(convertedNameList);
    }

A Better and Efficient way of writing above code

List<String> nameList = Arrays.asList("Tejas", "Sammer", "Aditya", "Saurabh");
Optional<String> convertedNameOpt =  nameList.stream().filter(name -> name.startsWith("S")).map(String::toLowerCase).reduce((s1, s2) -> s1 + ", " + s2);
        System.out.println(convertedNameOpt);

As a developer working in product-based company Code-review becomes a usual part of your day-to-day life. And writing cleaner code becomes your by default responsibilty. There few techniques which I picked up over the past few months:

Gaurd-Clause Technique
Select appropiate data-structure depending upon the requirement
Avoid unecessary deep-nesting loops
Use multi-line descriptive comments to make you API decriptive and easily understandable.
Make sure your code is idented and readable.
Always declare a understandable variable-name and avoid abbreviation.
Maintain Modularity in your code.
Make you code Compact and avoid using uncessary variable declaration.

Well I was using git before entering the corporate world but not at the full-potential

Understanding the git-workflow is very important and chosing the correct one is your responsibilty.
Making use of rebasing instead of merging
Importance of correct base-of
How to avoid and resolve merge-conflict in files.
Using a feature-branch for develpoment

Lastly as working for Infor, I developed the understanding for the Supply-Chain Management system(Shipment-Planning, Shipment-Orders, Transport-Planning, Transport-Order, Shipment-Visibility and more) which is definitely something new and very-interesting to learn.

Thanks for reading this blog and Let's meet again in next blog with something new and interesting.

My Understanding of the DEV-Tools!

TEJAS-PORWAL — Thu, 03 Aug 2023 18:20:02 +0000

What are browser developer tools🤔?

**
Basically dev-tool is nothing but the in-Built tools provided by the browser for the wide range of action on the web-page, from inspecting currently-loaded HTML, CSS and JavaScript to showing which assets the page has requested and how long it takes to load a page and optimize the pages cache and memory😯.

So, how to pull-up the dev-tools?
Well, it's simple you need to click =>
windows: Ctrl + Shift + I || F12
mac: Option + Shift + ⌘ + I || F12

_DOM-Manipulation:_

well DOM-manipulation becomes very easy and siplified with the use of dev-tool and you can easily modify and update the code live on the web-page for the better options.

Delete Node (sometimes Delete Element). Deletes the current element.
Edit as HTML (sometimes Add attribute/Edit text). Lets you change the HTML and see the results on the fly. Very useful for debugging and testing.
:hover/:active/:focus. Forces element states to be toggled on, so you can see what their styling would look like.
Copy/Copy as HTML. Copy the currently selected HTML.

Well DOM-manipulation is not the only feature you get from the dev-tools, you can also make alteration in your CSS code. Which comes very handy for testing the design and UI.

devTool also provide you a easy and compatible view of your page on different device such as mobile devices, tablets or a wide-screen device, with the help of these design feature you can make alternation and manage your responsive design easily.

_JavaScript Console:_

console.log('hello') is one of the most famous and executed statement in the javascript console which can be viewed in the console option from the dev-tools window.
The console window allows you to access all the javascipt object and function for the test purpose and see for yourself what it return on the page. This comes in-handy at various times and help you to fix a logic for the javascript debugger and check for the breakpoints.

Secrect-Tips:

"You can use 'save all resouces' extension available on chrome to download the code of a webpage and use it to learn and view the code and understand the factoring of the code."

That's all for this Blog. I'll leave the responsibility of exploring the other features of the dev-tool on you.

KEEP EXPLORING AND KEEP TRYING🙌... untill next time😁.