The Editor is Not the Language

5 min read

Textbook: BJP (Reges and Stepp), p. 9

Imagine two programmers. The first types javac Hello.java and java Hello into a plain black terminal window, and their program runs. The second programmer opens a polished window with syntax highlighting, clicks a single green “Run” button, and their program runs.

What is the actual difference between these two workflows?

Concept Check: The Magic Button

What does the green “Run” button in an editor actually do behind the scenes?

Thought Process

Think about how a factory automates tasks. Does a robot building a car use completely different physics than a human mechanic? Or does the robot simply perform the exact same mechanical motions faster and invisibly?

Show Answer

The Run button is just automation. When you click it, the editor secretly opens a terminal and types the exact same javac and java commands for you. It hides the two steps, but the underlying compile-then-run pipeline is identical.

Abstraction: The Build System

The second programmer is using an Integrated Development Environment (IDE). An IDE is simply a text editor that bundles the compiler and the runtime tools into one package.

Because the IDE hides the terminal commands, a common pitfall is believing that the editor is the language. Students often think a program written in one editor will not run in another. This is false. Both editors call the exact same underlying Java tools. A program that compiles in one compiles in the other.

In CSCD 210, you used VS Code with Java 25 and Gradle 9.2.0 to run tests. VS Code is a lightweight, general-purpose text editor that uses plugins to understand Java.

In CSCD 211, you will use IntelliJ IDEA Ultimate. The underlying build system is identical: you will still use Java 25 and the latest version of Gradle. The difference is that in 211, you will write your own unit tests instead of just running ours.

Why IntelliJ? Professional Power Tools

If the build system is identical, why force a switch to a heavier IDE?

The difference is how the editor understands your code. VS Code treats your code largely as text files. IntelliJ builds a massive internal database of your entire project, tracking exactly how every class, method, and variable relates to the others. Because it actually understands the structure of Java, it offers two massive time-savers that professionals rely on:

Boilerplate Generation: Instead of manually typing out constructors, getters, setters, and equals methods, you can press Cmd+N (Mac) or Alt+Insert (Windows/Linux) to instantly generate perfect code.
Smart Refactoring: If you want to rename a variable, do not use text find-and-replace. If you press Shift+F6, IntelliJ safely renames the exact variable across your entire project without accidentally breaking other code that happens to share the same name.

The Advanced Programming Exam (APE)

Learning a professional tool like IntelliJ takes time, but there is a massive payoff waiting for you.

The Advanced Programming Exam (APE) is a high-stakes, four-hour coding exam that serves as a gateway to the major. You must take the APE exclusively in IntelliJ.

Struggling through the learning curve of this professional tool all quarter guarantees that you will build interface fluency now. When you sit down for the APE, you will not waste a single minute of your four hours fighting the UI; you will spend all of it writing code.

The Gym Analogy: AI Code Completion

Both VS Code and IntelliJ ship with artificial intelligence tools that attempt to autocomplete your code as you type.

You must turn IntelliJ’s “Full Line Code Completion” off while you are learning.

If the AI writes the syntax for you, you never build the muscle memory required to write it yourself. It is exactly like going to the gym and having a robot lift the weights for you. When you sit down for the APE (where AI tools are strictly banned), you will fail because you never built the mental recall.

You will learn practical agent skills later in 211 to write tests and documentation in a Test-Driven Development (TDD) manner, but the core logic must come from your own brain. Type every bracket, semicolon, and keyword by hand.

The IntelliJ Survival Guide

To get you moving immediately, here is a highly condensed survival guide. For full visual walkthroughs, always refer to the official JetBrains Getting Started guide.

1. Creating and Opening Projects

IntelliJ is project-based, not file-based.

From scratch: Click New Project, select Java 25, and choose Gradle as the build system.
Cloning a lab: Go to File > New > Project from Version Control, paste your GitHub repository URL, and IntelliJ will automatically configure the Gradle project for you.

Official deep dive: Creating your first Java application

2. Editing, Compiling, and Running

Where code lives: Your Java files must live inside src/main/java. Your test files must live inside src/test/java.
Search Everywhere: Press Shift twice quickly to open the “Search Everywhere” box. This is the single most useful shortcut in IntelliJ for finding files or actions.
Running: Click the green play arrow in the gutter next to your main method, or open the Gradle Tool Window on the right side and double-click Tasks > build > build.

Official deep dive: Run applications

3. The Professional Git Workflow

CSCD 211 requires a professional engineering workflow. You will not push directly to the main branch.

Branch: For each new lab, click the Git branch name in the bottom right corner and select New Branch. Name it exactly after the lab (e.g., lab0, lab1).
Commit: Open the Commit tool window (Cmd+K or Ctrl+K), select your changed files, write a clear message, and click Commit and Push.
Merge: Once the lab is complete, you will merge your branch into main for credit.

Official deep dive: Investigate changes in the Git repository