Editors, terminals and running code

Writing a program is only half the job. The other half is a loop you will repeat thousands of times: edit a file, run it, read what happened, edit again. This lesson sets up that loop.

The terminal and the shell

A terminal is a window where you type commands as text. The shell is the program inside it that reads each line, finds the program you named and runs it. Common shells are bash and zsh (Linux and macOS) and PowerShell (Windows). The commands below work in the first two; PowerShell has equivalents, noted in the table.

Every shell session has a working directory: the folder it is currently “in”. Relative paths and most programs are interpreted from there.

A session might look like this. Lines starting with $ are what you type; the rest is output.

$ pwd
/home/sam
$ mkdir hello
$ cd hello
$ pwd
/home/sam/hello
$ ls
$

ls prints nothing because the new folder is empty.

Paths

A path says where a file lives. An absolute path starts from the root of the file system (/home/sam/hello/notes.txt, or C:\Users\sam\hello\notes.txt on Windows). A relative path starts from the working directory: notes.txt means “in this folder”, ../notes.txt means “in the parent folder”. A single dot, ., means the current folder itself.

Most “file not found” errors have the same cause: the file exists, but not relative to where you are standing. Check pwd and ls first.

Editors and IDEs

You write source code in a text editor: a program that edits plain text without hidden formatting. A word processor is the wrong tool, because it stores fonts and styles that a compiler cannot read.

An IDE (integrated development environment) is an editor with more built in: running and debugging at the click of a button, project management, refactoring tools, and live error hints. The line between the two is fuzzy; many popular editors become IDE-like with extensions.

For this course, pick whichever editor you will actually open each day. What matters: it shows line numbers, uses a monospaced font, and saves files as plain text in UTF-8.

Running a file

Running a program from a file is nearly always the same shape: the name of the program that runs it, then the file.

$ python3 hello.py
Hello, world!

$ node hello.js
Hello, world!

$ javac Hello.java
$ java Hello
Hello, world!

$ gcc hello.c -o hello
$ ./hello
Hello, world!

Python and JavaScript are run directly by an interpreter. Java and C have an extra step. Java’s compiler javac produces bytecode in a file named Hello.class, and java Hello runs it on the virtual machine (note that you give the class name, not the file name). C’s compiler produces a machine-code executable named hello, which you then run. The ./ means “the file in the current folder”; without it, the shell searches only a fixed list of system folders and will not find your program.

Recent Java versions can also skip the separate step for a single file: java Hello.java compiles it in memory and runs it.

On Windows, the Python launcher is often py or python rather than python3. Use whichever your installation answers to.

Output, errors and exit codes

Every program starts with three channels already open:

Normal results go to stdout. Diagnostics, warnings and errors go to stderr. Both appear in your terminal, so they look the same, but they are separate streams. That is useful because you can redirect one and keep the other: > sends stdout to a file.

Each language has a call for each stream. This program writes one line to each:

import sys

print("result: 42")
print("warning: using default settings", file=sys.stderr)

console.log("result: 42");
console.error("warning: using default settings");

public class Streams {
    public static void main(String[] args) {
        System.out.println("result: 42");
        System.err.println("warning: using default settings");
    }
}

#include <stdio.h>

int main(void) {
    printf("result: 42\n");
    fprintf(stderr, "warning: using default settings\n");
    return 0;
}

Run it with stdout redirected to a file (shown here for Python; swap in the run command from the tabs above). All four behave the same way.

$ python3 streams.py > out.txt
warning: using default settings
$ cat out.txt
result: 42

The warning still reached the screen because only stdout was redirected. This is why well-behaved programs keep their real output clean: another program or a file can then consume it without warnings mixed in.

Exit codes

When a program ends it hands back a small integer, the exit code. By convention 0 means success and anything else means failure. Shells let you read the code of the last command (echo $? in bash and zsh, $LASTEXITCODE in PowerShell). Scripts, build tools and CI systems rely on this number, not on what the program printed, to decide whether a step worked.

A program that finishes normally returns 0 without being asked. To report failure, set a different code on purpose:

$ python3 streams.py
result: 42
warning: using default settings
$ echo $?
0

Changing and rerunning

The working loop is: edit, save, run, read, repeat. Save before you run; an unsaved editor buffer is the most common reason that a change appears to do nothing. Try it: create a hello-world file in your language (hello.py, hello.js, Hello.java or hello.c), run it, change the text, save, and run it again. The output should change each time. For Java and C, compile again after every edit, or the old program runs.

Common pitfalls

• Running from the wrong folder. If node hello.js (or python3 hello.py, or ./hello) says the file does not exist, run pwd and ls.
• Forgetting to save, or to recompile. The terminal runs the file on disk, not what is on your screen. With Java and C it also runs the last compiled version, not your latest edit.
• Editing the wrong copy. Two files with similar names in different folders is an easy way to lose an hour.
• Treating stderr as noise. Warnings go to stderr so they do not pollute results. They still matter.
• Pasting commands with the leading $. The dollar sign is the prompt, not part of the command.

print("Sam")
print("Sam")

console.log("Sam");
console.log("Sam");

public class NameTwice {
    public static void main(String[] args) {
        System.out.println("Sam");
        System.out.println("Sam");
    }
}

#include <stdio.h>

int main(void) {
    printf("Sam\n");
    printf("Sam\n");
    return 0;
}

Sam
Sam

Summary

• The terminal runs commands from a working directory; relative paths depend on where you stand.
• Programs have separate stdout and stderr streams, and finish with an exit code where 0 means success.
• Your daily rhythm is edit, save, run, read, repeat.

Next: Values and types.