Perl on your Mac

Or provide the full path if you’re elsewhere:

The script will prompt “What is your name?”; type a name and press Enter. The program will greet you with “Hi …, nice to meet you!”. That’s all it takes to create a working Perl script on macOS.

For users on older Classic Mac OS, the workflow is similar but the interpreter lives in a different location. Open the MacPerl application, paste the same code into the editor, then press Command + Shift + R to run. The result is identical, and the same shebang line points to the interpreter bundled with MacPerl.

Now that you’ve run a script, it’s time to explore the building blocks of Perl code. The next section dives into scalars, operators, input, output, and how to keep your code readable and maintainable.

Core Concepts: Scalars, Operators, Input, Output, and Commenting

Perl’s syntax is flexible, but its core primitives stay consistent across versions. Understanding scalars, operators, and the standard input/output model is essential for writing clean, effective scripts.

### Scalars: The Single‑Value Data Type

Scalars are variables that hold a single value: a number, a string, or a reference to any other data structure. In Perl a scalar variable begins with a dollar sign $. For example, $name or $age store data that can be retrieved or modified later in the script.

When naming a scalar, you can use letters, digits, and underscores, but the first character must be a letter. The names are case‑sensitive, so $Age and $age are distinct variables. Here’s a quick illustration:

Scalar operators perform arithmetic or concatenation. The plus + adds numbers or concatenates strings depending on context. For arithmetic, both operands must be numeric. When used with strings, Perl automatically performs string concatenation. The minus , times *, and divide / operators work similarly.

Perl also supports increment ++ and decrement operators. They are handy for loops or simple counters:

Web counters often use this technique. A script reads a number from a file, adds one, prints the result, and writes the new number back to the file for the next visit.

### Input: Reading from STDIN

Perl programs commonly receive input from the standard input stream (STDIN). The expression <STDIN> reads a single line, including the trailing newline character. To remove that newline, the chomp function is called. Chomp is safe to use even if the string doesn’t end with a newline; it simply does nothing in that case.

When you ask a user a question with print, you typically follow up with the STDIN read. The pattern looks like this:

Notice the my keyword, which creates a lexical variable that’s local to the block. Using my is considered good practice because it limits variable scope and reduces accidental clashes.

### Output: Using the Print Function

The print function writes data to the standard output stream, which in the terminal appears on the screen. Anything passed to print is converted to a string automatically. If you pass a scalar, its value is printed. If you pass a string literal, it must be surrounded by quotes. Double quotes allow interpolation of variables; single quotes treat the text literally.

Perl automatically appends a newline character to each print call if you don’t supply one, but it’s common to include it explicitly for clarity.

### Comments: Writing Readable Code

Anything following a # is ignored by the interpreter. Comments are your tool for documenting intent, noting why a line is present, or marking TODOs. Although there’s no block comment syntax like //, you can place a comment at the end of each line or on its own line. Keep comments concise but meaningful.

Here’s a fully commented example that ties together the concepts discussed so far:

This script uses a shebang, a comment header, variable declarations, input handling, arithmetic, and output - all in a single, readable block. By following this structure, you’ll write code that’s easy for others (and future you) to understand.

### File Permissions and Running Scripts in X (classic Mac)

On macOS, the chmod command is used to make scripts executable. The example above used chmod 755 test.pl, which is sufficient for most scripts. If you’re on a classic Mac, the same principle applies; just remember that the path to the interpreter in the shebang may differ. The file permission system remains the same because macOS inherits Unix file permission semantics.

To test your script without typing the full path, you can place it in a directory that’s on your $PATH environment variable. Adding ~/bin to your $PATH is a common convention. After moving the script there and ensuring it’s executable, you can run it from anywhere with simply test.pl

By mastering scalars, operators, STDIN, print, and commenting, you’ll have the foundation to tackle more advanced Perl topics - arrays, hashes, regular expressions, and modules. Those subjects build directly on these basics, so feel free to experiment by extending the sample script: ask for a second input, perform a calculation, or output a formatted table.