Coding and best practices

 Write code or write code in right way...

Writing a coding solution to a problem can be done in many ways. If the solution can be obtained with less number of code lines, then it is easy to understand and maintain.

But what if code is large with having millions of lines. Moreover maintenance and readability becomes difficult as the code base grows... Right? 

In this blog I want to share my views and experiences on writing code efficiently and effectively with less maintenance efforts.

Aspects to consider while coding:

• Naming convention
• Cyclomatic Complexity
• SOLID principles
• DRY Principle
• Managing dead code
• Comments

Naming conventions:

Every programming language mandates few norms in order to name variables, classes and functions etc. For ex: Java uses class names first letter to be a alphabet and rest to be lower case letters. 

But if we dig little bit more, naming conventions are not limited to only upper case or lower case letters and using alphanumeric letters etc.

Naming a variable must be enough concise as naming your first child's name...

Few bad names for variables and constants:

          int final static TWO = 2;  [wrong]

          int final static MAX_LENGHT = 2; [Correct] 

  

Cyclomatic Complexity:

Cyclomatic complexity is a measure or metric to estimate complexity level of a snippet or block of code. 

Cyclomatic complexity and best practices:

• Never put more than three conditional checks (&& operator and || operator etc.) in one if condition
• Never exceed more than thirty lines in one function or method.
• Never exceed more than 1000 lines in one class or one file.

SOLID principles:

Usually developing a large and scalable application, requires better design. Adhering to SOLID principles yields better scalable and easily maintainable applications.

There are five SOLID principles. They are:

1. Single Responsibility Principle
2. Open/Closed Principle
3. Liskov's Substitution Principle
4. Interface Segregation Principle
5. Dependency Inversion Principle

DRY Principle:  

DRY stands for Do Not Repeat Yourself. Sometimes, There could be a need to use same or similar set of lines of code to be used multiple times in the same application. For ex. String utilities, DB connections or updating records in database etc.

Writing frequently used code snippets multiple times is not a good practice. Instead move this code to a function or method and use this method in places where ever required.

Simple use cases are:

• DB Connections
• File IO Operations
• String Utilities etc. 

Managing Dead Code:

Sometimes there are some lines or instructions in code base, which are completely not executed in all cases at all. This is considered as dead code. 

Dead code reduces the quality with respect to the readability.  

Comments:

Comments increases the readability of the program for programmers. Comments are written at class level, method level and variable level [Constants, instance variables and class variables] differently. 

The reason for this difference is, the pattern of comments is identified by API document generator tools and generates API documents.

Conclusion:

What all I tried to share through this post is, writing code for a specific problem can be done in different ways. But making sure that the program is more readable, maintenance free and easily scalable is also very important. 

The above few solutions or hacks will definitely help in developing better applications. 

Hope you enjoyed reading the post. Comments are welcomed. Thank you!! 

Happy coding!...

Exception handling and java keywords

Exception:

Exception in a programming language and in English language is pretty similar. Exception means being different from or not following the rules. And in programming language like Java, exception is  an event which occurs during the execution of a program that disturbs the complete flow of application or program.

When something beyond expected happens while executing a program is considered as an error. handling these errors or abnormality is called as Exception handling.

Exception Handling:

Exception handling in java is managed with the help of java keywords and java API support.. 

            1. Java Keywords

            2. Java API support

Java Keywords: 

There are 5 keywords in Java.

          1. Try

          2. catch

          3. finally

          4. throw

   and 5. throws

These five keywords used all together or combination of few keywords are used on need basis.

1. Try:

The code or set of instructions which are prone to errors or exceptions are enclosed in try block.

For example dividing a five or some number with zero [5/0]. The result of 5/0 is undefined and in Java,  this scenario is considered as exception.

2. Catch:

Usually try block is followed by a catch block. If some exception is occurred in try block, the execution control is moved to catch block instead of  continuing the execution of  try block's code. 

The purpose of catch block is, handling the exceptions that are raised in try.

There is a possibility of handling multiple scenarios in multiple catches. 

NOTE: Multiple catches can be written for single try.

Java code example:

           try{

                   ---                     // code

                } catch(OtherException e) {

                   ---                    // code

               }catch(AnotherException e) {

                }      

3. Finally:

Usually if there is an exception in try block, the rest of the lines in try are not executed and control moves on to catch block. And if there is no exception at all in try block control never moves to catch block. Then catch block is considered to be dead code. 

Then where must we write mandatory code? 

So, finally block is written after try and catch which gets executed always. 

Java code example:

            try{

                  ---

                } catch (Exception e) {

                  ---

                } finally{

                  ---              // mandatory code for execution

                } 

NOTE: Always put mandatory code in finally block. For example: closing IO resources connections like network and database connections etc

4. Throws and Throw:

Throws and throw keywords works along with Java API support. I will explain the Java API support for Exception handling in next subsequent articles. 

For now, we can understand that for every exception scenario there is one Java class(Java API). Example: Number divided by zero. [5/0]. The result is ArithmeticException

Java code example:

     try{

               int result = 5/0;

                ---        // other code

         }catch(ArithmeticException e) {

                ---        // exception of try block is handled here   

         }  

  Why there is no "throws" keyword here....?

The alternative solution for above snippet with throws and throw for checking election voting age eligibility exception is:

void votingAgeNumber() throws ArithmeticException{

                int age = 12; 

                if(age <=18) {

                           throw new ArithmeticException("Age is not sufficient to vote");

                 }

                 ---       // other code              

           }

NOTE: Sometimes "throws" keyword works as an alternative solution for try and catch blocks. The throws keyword is used instead of try and catch.

Example:

Solution with throws:

void divideNumber() throws ArithmeticException{

         int result = 5/0;

 } 

 And snippet with try and catch:        

void divideNumber(){

   try{

      int result = 5/0;

    }catch(ArithmeticException e){

     ----      // handle exception

    }

} // method end                      

         

The above both solutions are same, but with different keywords.


 Some key points:

1. There can be one try with multiple catch blocks.

2. Try block can be followed by either catch or finally block.

3. Or both can be followed

4. Throws is like warning that exception can be thrown and throw keyword is real accident took place.

I wrote here  https://www.allabtjava.com/2021/01/java-api-support-for-exception-handling.html on checked exceptions and runtime or unchecked exceptions.

Happy coding... :)