From Python to Java: Using JShell
Tags: programming, python, java, tutorial
Published: 2022-04-15 16:15:02

For most of my career, I've worked primarily as a Python developer. There were occasional trips into the frontend for some JavaScript or a brief detour through a Go application, but the vast majority of my work was solidly Python.

That is, until I joined Square. Square might be better known for its Ruby code, but there is also a sizable chunk of Java within its codebase. So when I came to Square, I knew I'd be putting away my list comprehensions, generators, and `@decorators`, and instead I'd be learning some new programming language patterns and idioms.

But of course, my Python experience would not be for nothing. As it turns out, we can find parallel ideas throughout most programming languages. In this series, I'll be highlighting some of these parallels I've encountered switching from Python to Java in hopes that it might help someone else who also finds themselves crossing this language barrier!

---

## Introduction

One of the first pain points that a Python developer is going to encounter when picking up Java is the lack of an interpreter. When writing in Python, I would frequently want to "test drive" a short snippet of code. In those moments, I'd pop open a terminal, run `python3`, and try out my code. This made it easy to make slight adjustments and see the results instantaneously before settling on a solution. If I needed to call an existing function in my codebase, it was a simple `import myModule` away and suddenly I was interacting with my code in new ways.

Since Java is a compiled language, we can't enjoy this on-the-fly exploratory interaction with our code. We have to wrap our snippets in a big, ugly `public static void main(String[] args)` method within a class and then _wait for it to compile_ just to see that we actually wanted to write it differently. What if I told you there was a better way?

## Enter JShell

No, really. Enter `jshell` in your terminal. Assuming you have JDK 9+ installed, you should be greeted with the following.[^1]

```
|  Welcome to JShell -- Version 17.0.2
|  For an introduction type: /help intro

jshell>
```

JShell was introduced in Java 9 but is still massively underappreciated, so it's understandable if you haven't heard of it until now. JShell is a REPL[^2] for Java code. 

## Starting to Explore

Imagine you've just read about the Streams API[^3] and you want to explore it for yourself before using it in your code. Within JShell, type the following and hit enter.

```java
var names = Stream.of("Alice", "Adam", "Bob", "Charles")
```

Next, let's practice consuming the stream:

```java
names.filter(name -> name.startsWith("A"))
     .map(String::toUpperCase)
     .collect(Collectors.toList())
```

Great! You should see the output immediately just like we'd expect when using the Python interpreter.


## Play it back

Let's try consuming our stream again within the same session:

```java
names.filter(name -> name.startsWith("A"))
     .map(String::toLowerCase)
     .collect(Collectors.toList())
```
`IllegalStateException: stream has already been operated upon or closed`

Looks like streams can only be used once! Rather than re-declaring our initial Stream object, let's take advantage of another JShell feature. Type `/list` to view a numbered list of every statement we've written in this session. Number 1 should be our `names` initialization. Let's re-execute that statement! Type `/1` to rerun the variable initialization. Once the Stream has been reinstated, we can type `/3` to rerun our last snippet!

```java
jshell> /list

   1 : var names = Stream.of("Alice", "Adam", "Bob", "Charles");
   2 : names.filter(name -> name.startsWith("A"))
                   .map(String::toUpperCase)
                   .collect(Collectors.toList())
   3 : names.filter(name -> name.startsWith("A"))
                   .map(String::toLowerCase)
                   .collect(Collectors.toList())

jshell> /1
var names = Stream.of("Alice", "Adam", "Bob", "Charles");
names ==> java.util.stream.ReferencePipeline$Head@2b05039f

jshell> /3
names.filter(name -> name.startsWith("A"))
            .map(String::toLowerCase)
            .collect(Collectors.toList())
$5 ==> [alice, adam]
```

## Interacting with other libraries

Sometimes you need more context. Maybe you want to test out a snippet of code that calls a method of one of your classes or that uses some third-party library. In Python we could simply `import myModule` to pull our code into the REPL session, or we could start the session already in context with the `-m` flag, `python3 -m myModule`. 

With JShell the process isn't much different. The only distinction is that our application (or any other dependencies we're trying to work with) must first be added to our class path before we can import them.

Say we'd like to explore the [Apache Commons Lang](https://commons.apache.org/proper/commons-lang/) library and we've already downloaded its `commons-lang3-3.12.0.jar` somewhere on our computer. In order to import its packages within our JShell session, we have two options:

1. We can start the session with the library already loaded:
`jshell --class-path /path/to/commons-lang3-3.12.0.jar`

2. After starting a new JShell session, we can add it to our environment:
`/env -class-path /path/to/commons-lang3-3.12.0.jar`

Once loaded into our JShell environment, we can import its packages and try it out:

```java
jshell> /env -class-path /path/to/commons-lang3-3.12.0.jar

jshell> import org.apache.commons.lang3.StringUtils

jshell> StringUtils.isBlank("  ")
$2 ==> true
```

Interacting with your own application code follows the same process once you've built your own `.jar` file.

Tip: Loading in an application's `.jar` and using its methods within a JShell session can make debugging issues in other environments like staging or production much easier - so long as you exercise the proper caution!

## Java script?

One last feature I'd like to call out with JShell is the ability to create Java scripts. No, not Javascript. Java scripts. Essentially, JShell can read its commands from a file rather than from the terminal prompt. For example, save the following as `helloWorld.jsh`.

```java
System.out.println("Hello world!")
/exit
```

We can then run it via `jshell helloWorld.jsh`. You probably shouldn't write all of your scripts in Java now, but it's nice to have the option! 

## Further Reading

Want to learn more about JShell?
 - Within JShell, run `/help intro` and `/help`
 - [Introduction to JShell - Oracle.com](https://docs.oracle.com/en/java/javase/17/jshell/introduction-jshell.html#GUID-465BA4F5-E77D-456F-BCB7-D826AC1E18AE)


[^1]: If you get `command not found`, you might need to specify the full path. Give it a shot with `$JAVA_HOME/bin/jshell`. Tip: adding `$JAVA_HOME/bin` to your `$PATH` might be a good idea.

[^2]: REPL stands for _Read, Evaluate, Print, Loop_. Interpreted languages (Python, Ruby, et al) get REPLs for free - it's just the regular interpreter reading from standard input instead of a .py or .rb file. Compiled languages like Java need a little extra help. Thankfully, we have JShell!

[^3]: For a super basic introduction to Streams, check out another entry in this series: [From Python to Java: Comprehensions and Streams](https://dev.to/dylanfw/from-python-to-java-comprehensions-and-streams-3j53).