JShell : A Primer

JShell is the REPL (Read-Eval-Print Loop) for java introduced as part of JDK 9. It is an interactive command line interface that enables the users to execute a single statement at a time, JShell evaluates and prints the result of the statement. The statement can be any valid java statement ranging from declaration of a variable to a basic arithmetic operation ….. to defining a class.

JShell is a handy tool for the language learners  and for experienced java programmers as well to try out something quickly. We all know the pain we went through when we started learning Java; to run a simple System.out.println, we had to create a Class with main method, compile it and run it. Even the worse when we want to do it in IDE, have to create a Project, then package and class. It’s a kind of turn off for someone who’s experienced in Scala or Python and trying to learn Java. Now with the JShell, it’s a more seamless learning experience for beginners of the Java, you are not obligated to create a class and a main method and even liberated from the semicolon at the end of every statement.

JShell can be found in bin directory of the JDK installation, can be launched from the command line interface of the operating system. I have used the windows 10. Below screen shot shows the command to launch JShell.

Launch JShell

What can we do with JShell

  1. Perform simple arithmetic operations such as 1+2 or 5%2, Jshell evaluates and prints the resultarithmetic.jpg
  2. Print a string or any value by directly typing System.out.print. We can declare a variable and then we can print it. The below image shows printing of String directly typed in System.out.print and declaring a starting variable and then printing it. Once a variable is declared, JShell prints the variable name and value PrintString.jpg
  3. Execute a loop statement, print values from 0 to 9 using for looploop.jpg
  4. Declare a method and call that method. In the example shown in the image, I have declared a method printString that takes a String argument and prints it, then I called that method with the String value “Calling a method from JShell”; the method is executed and the string value is printed on the console. Method.jpgif we type any semantically wrong code, an error is shown. I have tried inserting an extra double quote inside the println after the variable name and I saw the error as belowFunctionError.jpg
  5. View the history of the statements executed with /list command.list.jpg
  6. View the variables and the methods declared with /v and /m commandsVariablesNMethods.jpg$1 is the variable that is created as a result of the arithmetic operation 1+2. When user performs an operation without assigning the result to a variable, JShell creates a variable automatically, $1 and $2 are such variables and str is the variable for the String literal created.
  7. JShell evaluates the method dependencies,  shows a warning if a method definition is not found. If we declare a method, method1 and if it calls an undefined method, method2, JShell shows warning as shown in the image belowmethod_dep.jpgif we list the methods now with /m command, its lists the methods printString and method1 as well it shows the warning for the missing method2. After creating the method2, /m shows the methods printString, method1 and method2 without warnings. method_dep2.jpg
  8. Update the value of variable by assigning a new value to it. We can not change the type of a variable without declaring it again with the new type. Below image shows an example of updating an int variable and creating a new variable with the same name and different type; the int variable is removed in this caseupdate_var.jpg
  9. Edit the history of the statements with /edit command. When /edit is performed,  JShell Edit Pad (a pop up) comes with the history of the statements executed. We can edit one or more statements or can add/delete a statement. In the example shown below I have added a statement to include a new String variable, blogedit.jpgNow the list of variables shows the newly added String variable, blogedit_result.png
  10. Save all the statements executed to a file using /save file_name command . File extension can be anything. The saved file can be opened using /open filen_name
  11. Create a Class,  instantiate a class, call a method on the instance. Class.jpg

Jshell is a quick means to test code snippets. With the JShell java programmers are no more obliged to declare variables or methods inside a Class. JShell acts like a Unix shell for Java statements. 

Hope this article helped in giving you a good understanding of how to use JShell.

Stop writing obvious code for POJOs, use lombok’s @Data

Lombok helps in getting rid of the obvious code that we write when we define a class, instead it generates the obvious code at the time of compilation. Lets say if you are writing a plain vanilla bean to define a Car that has three attributes make, model and year you will define a class with these three variables and will define a no-argument constructor, setters and getters for all the variables. For any bean or POJO that you define, isn’t this code obvious that you always write? What if an annotation can generate all this code for you and you just define the class and its member variables.

The below screen shot of eclipse shows the java code for the class Car on the left side and the outline on the right side. It can be observed that the class definition doesn’t have the getters/setters, constructor or the other methods but the outline has them. The code is generated by the @Data annotation provided at the class level. The code looks amazingly precise.

Lombok Data
Class definition and methods generated by Lombok

Apart from the getters/setters, equals, hashcode and the constructors, @Data also generates a canEquals method; this checks if the given of the same type, precisely it performs instance of check. toString generates the string representation of the object in the format, classname(var1=valueofvar1 var2=valueofvar2 ... varn=valueofvarn) where var1 … varn are member variables of the class.

If a class has final variables, @Data generates a constructor with all the require arguments. For example, if you have a class like below,
public class CarWithFinalVariable {
private final String make;
private String model;
private int year;

lombok generates a constructor, public CarWithFinalVariable(String make)
When using lombok, I personally advice not to write additional constructors or methods inside a POJO. You may write one or more setter of you have to impose certain restrictions but for constructor it is strict NO NO. One should never write a code like below
public class CarWithFinalDontDoIt {
private final String make;
private String model;
private int year;
public CarWithFinalDontDoIt() {
make = null;

The no argument constructor here kills the purpose of the final variable, and eventually misguides the users of this class.

One of my favorites is toString because I don’t want to put my efforts in writing a method that serves no business purpose at the same time while debugging, when I hover the mouse over a variable I feel convenient to see the state of the object rather than seeing the object id and then go and expand to see the state. It is possible to configure the toString so as exclude the variables that you feel are trivial. Below is the example of excluding the variable make from toString
@ToString(exclude = "make")
public class CarConfigureToString {
private String make;
private String model;
private int year;

further reading
github url

Schema-less, Not model-less

The data model is not just the model of the data base tables, it represents more than that. Data model represents the domain model; the various entities that represents the a business. For  any product to be successful and to serve the intend purpose the data model is important, the data model is the common language among the end users, business teams and the developers. A poor data model leads to a poor understanding and the information gap between various stake holders.

The schema in the relational database terminology refers to the metadata or definition and organization of the various tables. The tables in the data base closely represent the data model. The schema is rigid, extending the data model becomes difficult. Involves transformation when such case arises. The positive side of this aspect is that it forces us to think of the schema, in a sense it mandates to understand the business thereby a data model. The data model helps in designing the Object/Entity model of the product.

The schema-less databases do not mandate a rigid schema and there by do not force us to think of a data model. I have observed a few occasions where teams started using the document databases and storing the data more in random format; mostly not able to relate between their object model and data base. Schema-less databases provide the flexibility for extending the model. The database accepts the any data to store but the application needs a model to operate.

One of the main advantages that comes out of using schema-less databases is that not requiring a Storage Model to Object Model conversion. If the project doesn’t have a well thought model, it may need to combine two or more entities from database to form a single Object. Having well defined model makes it easier to store and retrieval from a schema-less database. For example, a Java object can be converted to JSON and stored in MongoDB and retrieved and converted to Java object. If it has to come out of two documents, we accidentally have invited the relational databases’ complexity to the schema-less data bases as well.

The schema-less databases provide flexibility to add or remove more fields to the data, change the data type of the data, and obviates the need of normalization and relationships but they are not an excuse for not having a domain model.

Schema-less is not model-less.