Hello World in J

Every programming journey starts with Hello World. In J, this is remarkably concise—just a string expression that outputs to the screen.

The Code

Create a file named hello.ijs:

1

'Hello, World!' 1!:2 (2)

That’s it—one line that writes our greeting to standard output.

Understanding the Code

Let’s break down this concise expression:

• 'Hello, World!' - A character string (called a “literal” in J)
• 1!:2 - A “foreign conjunction” for file output (the 1 class handles files, :2 means write)
• (2) - File descriptor 2 represents standard output (screen)

In J, !: is the foreign conjunction that provides access to system functions. The 1!:2 specifically means “write to file,” and file number 2 is standard output.

Alternative Approaches

J offers several ways to output text:

1
2
3
4
5
6
7
8

NB. Using echo (includes escape characters in some versions)
echo 'Hello, World!'

NB. Using smoutput (standard output)
smoutput 'Hello, World!'

NB. Direct file write (most portable)
'Hello, World!' 1!:2 (2)

The NB. is J’s comment marker (“Nota Bene” - Latin for “note well”).

Running with Docker

The easiest way to run J without installing anything locally:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Create the source file
cat > hello.ijs << 'EOF'
'Hello, World!' 1!:2 (2)
EOF

# Pull the J image
docker pull nesachirou/jlang

# Run the program
docker run --rm -v $(pwd):/app -w /app --entrypoint /usr/bin/ijconsole-9.03 nesachirou/jlang hello.ijs

Command Line Options Explained

• --entrypoint /usr/bin/ijconsole-9.03 - Use the J console interpreter
• -v $(pwd):/app - Mount current directory into the container
• -w /app - Set working directory inside container
• hello.ijs - The script file to execute

Running Locally

If you have J installed locally:

1
2
3
4
5

# Run the script
jconsole hello.ijs

# Or use ijconsole (interactive J console)
ijconsole hello.ijs

Installing J

All Platforms:

Download from Jsoftware.com - J is available for Windows, macOS, Linux, and Raspberry Pi.

Linux (from source):

1
2
3

git clone https://github.com/jsoftware/jsource.git
cd jsource
# Follow build instructions in README

Expected Output

Hello, World!

Interactive J

J is particularly powerful in interactive mode. Start a J session:

1

docker run --rm -it --entrypoint /usr/bin/ijconsole-9.03 nesachirou/jlang

Then type expressions and see immediate results:

1
2
3
4
5
6
7
8

   'Hello, World!' 1!:2 (2)
Hello, World!
   2 + 2
4
   i. 10
0 1 2 3 4 5 6 7 8 9
   +/ i. 10
45

The three-space indent shows user input in J’s interactive mode.

To exit, type exit '' or press Ctrl+D.

Going Beyond Hello World

J’s power becomes apparent with array operations. Even in a “Hello World” tutorial, we can glimpse this:

1
2

   |. 'Hello, World!'
!dlroW ,olleH

The single character |. reverses the entire string—no loops, no indexing.

1
2

   # 'Hello, World!'
13

The # verb counts the elements (characters in a string).

1
2
3
4

   3 4 $ 'Hello,World!'
Hell
o,Wo
rld!

The $ (reshape) verb rearranges our string into a 3×4 matrix.

A Note on J Syntax

J’s ASCII-based syntax uses punctuation creatively:

Notice that J uses % for division (not /) and _ for negative numbers (not -).

Key Concepts

1. ASCII-only - J uses standard keyboard characters, unlike APL
2. Foreign conjunctions - m!:n provides system-level operations
3. Right-to-left evaluation - No operator precedence except right-to-left
4. Arrays are fundamental - A string is a character array
5. Verbs work on arrays - No explicit iteration needed

Historical Note

J was created by Kenneth Iverson and Roger Hui in 1989-1990 as a modernization of APL. The switch from APL’s special characters to ASCII was revolutionary—suddenly APL’s powerful array programming was accessible on any computer with any keyboard.

The name “J” follows naturally from APL’s influence: APL stands for “A Programming Language,” and J is simply the next letter after I (Iverson).

Next Steps

Continue to Variables and Data Types to learn about J’s array-oriented data model.