Setting Up a Mainframe Environment: x3270 and TSO

Coming from a modern development background, I'm used to SSH and character-oriented terminals. You type a character, it goes to the server, and the server echoes it back immediately.

I recently started working with IBM Z (Mainframe) systems, and the first hurdle wasn't the code – it was the terminal.

While you can SSH into the Unix Subsystem (USS) of a mainframe just like a Linux machine, accessing the classic operating system (TSO/ISPF) requires a different beast entirely: a 3270 Emulator.

It feels archaic at first, but once you understand the engineering constraints of the 1970s, it functions as a highly efficient, stateless system.

The Protocol: Block Mode vs. Character Mode

Modern terminals operate in Character Mode. Every keystroke travels the network.

The Mainframe 3270 protocol uses Block Mode. When you connect, the mainframe sends your client a "screen map." You fill out the fields locally on your machine. You can type, backspace, and tab between fields, and the mainframe has no idea you're doing it.

Only when you hit the Action key (usually Right-CTRL or Enter) does your client bundle the entire screen of data and ship it to the mainframe in one packet.

Why? Bandwidth efficiency. This protocol was designed for slow, expensive phone lines. It is effectively the original "Stateless Frontend." It functions exactly like an HTML form: the server does nothing until you click "Submit."

Installation/Setup

MacOS

Homebrew

If you are comfortable with the command line, you can use homebrew to install the x3270 suite. This is my preferred method as it keeps the workflow inside my existing terminal.

brew install x3270

Once installed, you can launch the console emulator with the c3270 command:

c3270 111.222.333.444:123

App Store (GUI)

If you prefer using a mouse-friendly GUI, you can install the Mocha TN3270 Emulator from the app store. The Lite version is free and offers basic functionality. While the fully featured version is paid.

After downloading and opening the Lite version you should see this screen:

Click the highlighted button to configure your connection. This will bring you to the configuration screen:

Input the correct IP address and port given to you. You can change the terminal size and other advanced options, but the defaults are usually sufficient. Once configured, close the configuration window and click Connect. You should see the logon screen:

Windows

While I primarily run macOS, the process on Windows is straightforward thanks to package managers.

Chocolatey

If you have Chocolatey installed, you can install the widely-used wc3270 emulator with a single command:

choco install wc3270

This will create a desktop shortcut for the program which you can use to launch the emulator.

Manual Installation

Alternatively, you can navigate to the x3270 download page to download the installer executable directly.

Connecting

After configuring your connection and successfully connecting you should see the initial greeting screen:

From here, type logon followed by the user ID that was given to you. For example if your user ID is 'z10234':

logon z10234

After typing in the command and hitting enter, you will be brought to the password prompt:

Input your password at the default cursor position and hit Enter.

The system will go through its initialization procedure (you may see several messages flash by). Eventually, you will end up at the confirmation screen:

From here, hit the Enter key again.

If you've followed along, you should now see the ISP Primary Option Menu!

Fun Fact: The 80-Column Limit

You may notice that the terminal screen is limited to 80 columns wide. The reason for this predates modern computing!

Back in 1928, IBM created the 80-column Punch Card. Before screens existed, all programs and data had to be punched onto these physical cards. This is why older languages like COBOL limit you to 80 characters per line.

When the original 3270 terminals were built, they were designed to display exactly one punch card's worth of data per line. Even today, modern style guides like Python's PEP 8 suggest an 80-column limit. We are effectively still formatting our code based on a paper constraint from a century ago.

The Trade Off

Despite the age of the protocol, the user experience creates an interesting distinction. Because of the "Block Mode" architecture, typing and navigating is instant because it happens locally on your machine. You don't wait for the server to echo characters back like you do with SSH. However, when you do submit the screen, you are still at the mercy of the network.

Next Steps

Now that the connection is established, the next problem is storage. The Mainframe doesn't use "Folders" like we're used to on Mac or Windows. In the next post, I'll break down Dataset Allocation and why I had to relearn how physical storage works.