Coding Tools and IDEs Every CS Student Should Know

You're starting a new school year, and you need to get up to scratch. You're wondering what tools are out there or what you're missing. There are thousands, but if you're new to the subject, it's not spelled out in black and white. Here are eight types of tools I know you will need.

Notebooks: Baby Steps for Programmers

Notebooks provide an interactive environment for writing and executing code. In a notebook, each line of code can be run separately, building upon previous lines. They're often used for quickly prototyping, experimenting with ideas, and viewing results in a clear, nicely formatted way.

Notebooks are a popular choice in data science and are commonly used when working with complex data such as DataFrames (tabular data) or running database queries (for example, with QueryBook).

Jupyter is the king of notebooks, but it's not only limited to Python. There is a long list of Jupyter kernels , which allow it to run many programming languages. With Jupyter, you can run and visualize your code easily.

Code Formatters, for the Lazy Coder

If you find yourself manually formatting your code to make it look nice, you probably want a code formatter. A code formatter reads your code and applies a consistent style across it. It doesn't sound like much, but fewer distractions mean more focus.

Often used formatters are:

• C: clang-format, GNU indent

• C++: clang-format, GNU indent

• Go: gofmt

• Java: Google Java Format

• Python: black, autopep8

• Web (JS, JSON, YAML, Markdown): Biome, Prettier

Linters

A linter is a tool that looks for questionable code. You scan your source code, it consults its internal rules, and it displays warnings whenever you're doing something that you shouldn't. Linters are configurable and sometimes pluggable (meaning it accepts plugins). You can define rules that relate to style or to more serious security issues.

Linters are common and the often used tools are:

• Python: Ruff, flake8, pylint

• JS: ESLint

• Java: Checkstyle, SpotBugs

• C: clang-tidy, cppcheck

• C++: clang-tidy

Containerization: Run Any Service, Any Place, Any Time

Today's development landscape isn't just about packages, and if you rely on any services at all (e.g., databases like Postgres, MySQL, etc.), you probably want to avoid installing and configuring them manually. The most common approach is to use pre-configured containers, which are small, isolated environments into which you can install software (such as services).

Tools like Docker and Podman allow you to download and run preconfigured recipes (aka Dockerfiles). These Dockerfiles describe how to set up the containers and configure the desired services for you. That moves the burden of boring details onto the experts: the Dockerfile maintainers.

Version Control: Savepoints That Save Your Ass

A Version Control System (VCS) is a tool that manages and tracks revisions to your software. When you make changes to your source code, the VCS records them in a way that allows you to go back in time. Think of it as a checkpoint system for your code—it gives you the freedom to make drastic changes without irreversible damage.

There is really only one king in the VCS world: Git. I would like to say that Git is a simple tool, but it's not. However, you can go far with simple commands, so the learning curve isn't very steep at all.

If you're submitting code assignments for your class, you will almost certainly do it via a service like GitHub, a place that hosts Git software repositories.

Package Managers: The First Tool You Will Truly Need

You won't get very far writing code without installing third-party libraries (aka dependencies, or packages). We install packages with a package manager. Every language has their go-to package manager and method for installing packages.

Package managers differ in ways that are not obvious. In Python, each package manager stores downloaded packages in different locations, some global and some local to your project. For JavaScript, some package managers use up lots of space; others were designed to avoid that specifically.

Below are some common package managers for common languages:

• Python: uv, pip, pipx

• JavaScript: NPM, pnpm

• Java: Maven

• C: Conan, vcpkg

• C++: Conan, vcpkg

Package managers are as crucial as the wheels on a car.

Test Runners: No Tests; Bad Code

Testing is a crucial component when developing software. A test runner is a language-specific testing framework. You use such a framework to run portions of your code under controlled conditions, then ensure that it matches expectations.

Tests serve two purposes:

1. Ensure that the software works.

2. Ensure that the software doesn't break after changes (aka regression tests).

When you change something, how do you know that something else hasn't broken? Consequently, when your code starts to become complex, testing frameworks are an absolute must. Software without tests is like hiring doctors without credentials; it's absolute lunacy.

A testing framework is language-dependent, and the most common ones that you're likely to need are:

• C: GoogleTest or Unity

• JavaScript: Jest, Mocha, or Vitest

• Java: JUnit

• Lua: Busted or LuaUnit

• Python: Pytest

IDEs: The Centerpiece of Your Toolset

An IDE, or integrated development environment, is a software application that brings together the essential tools often needed to develop software. Many IDEs are available—some are designed for specific programming languages, while others support a wide range of languages.

Without an IDE, you will miss out on several crucial features, such as

• Language intelligence: Provides code auto-completion (code suggestions), syntax highlighting (colored text), and other advanced features, like refactoring (code changes).

• Syntax highlighting: Applies colors to your source code to make it more readable.

• Debugger: A tool that runs your code and allows you to step through it line by line to identify and fix bugs.

• Build automation: Tools to help build and run your software.

• Test runner interface: Allows you to run and manage tests directly within the IDE, often integrating with language-specific test frameworks so you can quickly execute individual tests without leaving the IDE or writing out complex commands.

The above list is just scratching the surface of what an IDE can do. Almost everyone who writes software uses an IDE or a similar tool—for example, Vim, Emacs, or Neovim. I've previously given a list of reasons why I use Neovim , which may interest you.

You can find a comparison list of IDEs on Wikipedia, but the most popular choice is often VSCode. VSCode supports many languages, and it's extensible. There are thousands of extensions in the VS Code marketplace that solve a great many problems. In fact, we've covered a list of essential VS Code extensions before. Some even claim that VS Code makes them a better programmer .

---

IDEs, VCS, notebooks, and code formatters all make your life easier by taking some of the laborious elements out of writing software.

Linters and test runners are essential for catching bugs and ensuring an acceptable standard of quality for your code.

Package managers and containerization let you use other people's code, but containers also allow you to wrap up your code in a way that's guaranteed to work on every machine.

Since you're new to programming, you may also be interested in habits to grow to become a better programmer .