Computing Foundations › Systems Foundations: Storage, Observability, and Tooling › Day 36

Day 36: Choosing and Configuring a Code Editor

Day 36 of 365 — Choosing and Configuring a Code Editor

After this lesson you will be able to choose a code editor with clear reasons, configure the handful of settings and shared rules that actually pay off, and explain why a well-organized editor makes you faster at every project — including the AI work later in this course.

Course
Computing Foundations
Category
Systems Foundations: Storage, Observability, and Tooling
Reading time
≈ 40 min
Practical time
≈ 30 min
Lesson duration
1h 10m
Last verified
2026-07-12

Hands-on lab for this lesson

Lab files on GitHub: https://github.com/ai-roadmap-365/ai-roadmap-365.github.io/tree/main/labs/sections/computing-foundations/day-036-choosing-and-configuring-a-code-editor

  1. Get the hands-on files. Clone the labs repository once (you can reuse this clone for every lesson). This works on macOS, Linux, and Windows (PowerShell or WSL):
    git clone https://github.com/ai-roadmap-365/ai-roadmap-365.github.io.git
    cd ai-roadmap-365.github.io
  2. Open this lesson's lab. Move into the directory for this specific day. Every lab lives at the same predictable path — section / subsection / week / day:
    cd labs/sections/computing-foundations/day-036-choosing-and-configuring-a-code-editor
  3. Read the lab guide. Open `README.md` in that directory. It lists the exact commands, what each does, the expected output, and how to check your work — read it before running anything.
  4. Run it and check your work. Follow the README's "How to run" section: run the example first to see the finished result, then complete the numbered exercises in `starter/`, then run the tests. The tests pass (exit 0) only when your work is correct.
    bash tests/run_tests.sh   # or the test command named in the lab README

You can also open the lab as a local page (works offline, shows the file tree and expected output).

Learning objectives

By the end of this lesson you will be able to:

Prerequisites

Why this matters


The idea in plain language


Historical background

Diagram: the evolution from line editors to modern code editors


What it is — and what it is not

A code editor is:

It is not:


Why it was created and what problems it solves


How it works

The window

Diagram: the anatomy of a code editor window with its main parts labelled

The Language Server Protocol

Diagram: the exchange between an editor and a language server

The three things you configure

Diagram: the four editor settings worth configuring


An everyday analogy

Diagram: the five most valuable editor keyboard shortcuts

A well-organised workshop.

The workshopThe editor
The plan chest of drawingsThe file explorer
The bench you work atThe editor pane
The tools within arm’s reachThe integrated terminal
A specialist consultant on callA language server
Tools laid out how you like themKeybindings
The house standard for joint sizesEditorConfig
A gauge that checks as you cutFormat on save

Examples in practice

Diagram: a diff with formatting noise compared with a clean one

Flowchart: from a plain text editor to a code editor with extensions to a full IDE


Implications: security, privacy, performance, scalability, and cost

Diagram: the access an editor extension has


Alternatives: free, open source, and commercial

Diagram: user settings compared with workspace settings

ToolTypeWhere it fits
VS CodeFreeThe default; enormous extension ecosystem
NeovimFree, open sourceFast, keyboard-driven, deeply configurable; steep start
JetBrains IDEsCommercial, free tiersDeepest language-specific tooling, especially refactoring
Zed, HelixFree, open sourceNewer, fast, opinionated
Jupyter / notebook editorsFree, open sourceExploratory analysis; not for building software
nanoFree, built inEditing a config file on a server, and nothing more

Diagram: a code editor compared with an integrated development environment

TermWhat it actually is
Text editorEdits characters; knows nothing about code
Code editorAdds structure, extensions and language servers
IDEThe same, with build, debug and refactoring preassembled
Language serverA separate program that analyses one language
ExtensionAn add-on that teaches the editor something
EditorConfigA shared file agreeing basic formatting
Format on saveRunning a formatter automatically on every write

When to use it — and when not to

Diagram: when to use a notebook and when to use an editor


The AI connection


Knowledge check

quiz:
  question: "One editor supports dozens of languages with autocompletion and error checking, yet its developers do not know most of those languages. How?"
  options:
    - "It speaks the Language Server Protocol to a separate server written by each language's community"
    - "It downloads a language definition file describing the syntax of each language"
    - "It runs each language's compiler in the background and parses the output"
    - "Its extensions each reimplement the analysis inside the editor itself"
  answer_index: 0
  explanation: "The protocol separates the editor from language knowledge entirely. Each language community writes one server; every editor that speaks the protocol gets that language's support without its authors knowing anything about it — which is precisely why the ecosystem grew so fast after 2016."

Hands-on exercise

Configure the four things that matter, then verify each. Worked through fully in the Day 36 lab directory.

What you are doingWhere
Install your language’s extensionThe extensions panel
Confirm the language server startedThe status bar, or the output panel
Turn on format on saveSettings, editor.formatOnSave
Write an .editorconfigThe project root
Prove it worksOpen a file with the wrong indentation and save
Learn five shortcutsGo to file, go to symbol, find in project, rename, terminal
Open the integrated terminalAnd run your tests from inside the editor

Expected output

[Info] Python language server started (pylsp 1.10.0)
root = true

[*]
indent_style = space
indent_size = 4
end_of_line = lf
insert_final_newline = true

Validate your work

Troubleshooting

Common mistakes


Practice assignment


Extension challenge


Quiz

Q1. What single capability most clearly separates a code editor from a plain text editor?

  1. A code editor can save files to disk, which a plain text editor cannot
  2. A code editor stores text with hidden formatting like a word processor
  3. A code editor understands the text is code, so it can help
  4. A code editor can only open one file at a time
Show answer

Answer: C. A code editor understands the text is code, so it can help

Both store plain-text characters, but a code editor adds a layer of language awareness — syntax highlighting, autocomplete, and inline error checking — that a plain text editor lacks entirely.

Q2. What does the Language Server Protocol (LSP) make possible?

  1. It encrypts your source files while you edit them
  2. It translates your code from one programming language into another automatically
  3. It runs your program on a remote server instead of your machine
  4. One editor can talk to reusable language servers for any language
Show answer

Answer: D. One editor can talk to reusable language servers for any language

Before LSP, every editor had to build language intelligence itself. LSP defines a common language between editors and separate language servers, so a single Python server can power completion and errors in dozens of different editors.

Q3. How does an IDE differ from a code editor?

  1. An IDE bundles build, run, and debug; an editor grows by extensions
  2. An IDE only works with one operating system
  3. An IDE cannot install extensions, while a code editor can
  4. An IDE stores files as images rather than text
Show answer

Answer: A. An IDE bundles build, run, and debug; an editor grows by extensions

An IDE is an Integrated Development Environment: it packages the heavier machinery of compiling, running, and debugging for a language, all preconfigured. A code editor starts lighter and adds capability through extensions.

Q4. What is the purpose of an .editorconfig file placed at the root of a project?

  1. To store your personal editor preferences that only apply to you
  2. To share editor-agnostic formatting rules across a team
  3. To list which extensions each teammate must install
  4. To run the project's tests automatically on every save
Show answer

Answer: B. To share editor-agnostic formatting rules across a team

EditorConfig is a small standard many editors read automatically. Because it lives with the project and is editor-agnostic, a whole team formats code the same way — indentation, line endings, final newlines — without each person configuring their editor by hand.

Q5. For a beginner in this course, which editor is the recommended default, and what does it cost?

  1. PyCharm Professional, which is paid
  2. Sublime Text, whose license must be purchased before use
  3. Visual Studio Code, which is free and open source
  4. A plain text editor, because code editors cost money
Show answer

Answer: C. Visual Studio Code, which is free and open source

VS Code is free, open source, cross-platform, forgiving for beginners, and flexible enough to handle every topic in this course — which is why it is the recommended starting point. Nothing in the course requires a paid editor.

Q6. Which problem does the multi-cursor feature (together with project-wide search and replace) directly solve?

  1. Running a program without leaving the editor
  2. Remembering your git commit history
  3. Coloring keywords so the structure of code is visible
  4. Changing the same word or making the same edit in many places at once
Show answer

Answer: D. Changing the same word or making the same edit in many places at once

Multi-cursor editing and project-wide search and replace answer the pain of needing to make the same change in many places — for example renaming a variable everywhere it appears — quickly and consistently.

Q7. Why can installing many extensions hurt your editing experience?

  1. Each extension adds startup time and memory use
  2. Extensions permanently change the files on disk
  3. Extensions disable the integrated terminal
  4. Editors refuse to open once more than five extensions are installed
Show answer

Answer: A. Each extension adds startup time and memory use

Every extension costs some startup time and memory. Installing only the ones you actually use keeps the editor fast and focused; loading dozens "just in case" taxes performance and attention.

Q8. Where do AI coding assistants run, and why does that matter for how you set up your editor?

  1. On a separate website you visit; your editor setup is irrelevant to them
  2. Inside the editor, reading your open file and project
  3. Only inside the operating system, with no access to your code
  4. Exclusively on the language server, never touching your files
Show answer

Answer: B. Inside the editor, reading your open file and project

AI coding assistants live inside the editor and read the file you have open and the project around it. A well-organized, well-configured workspace is the foundation they stand on, which is why configuring your primary tool now pays off for every later AI project.

Glossary

code editor
A program for writing and editing source code that understands the text is programming code — coloring it, completing names, and flagging errors — and grows through add-ons called extensions.
IDE
An Integrated Development Environment: an editor bundled with the preconfigured machinery for building, running, and debugging a particular language or platform, all in one package.
syntax highlighting
Coloring the different parts of code — keywords, strings, comments — differently so the structure of the code is easy to see at a glance; a display effect that never changes the file on disk.
autocomplete
A feature that suggests and completes valid names as you type and shows what a function expects; Microsoft's branded version is called IntelliSense.
LSP
The Language Server Protocol, a common language (introduced by Microsoft in 2016) that lets an editor talk to a separate language server, so many editors can share expert completion and error-checking for the same programming language.
extension
An add-on that expands a code editor with new capabilities — support for a language, a theme, a tool — installed and managed from the editor.
keybinding
A mapping from a keystroke to an editor action, letting frequent operations become muscle memory instead of menu hunts.
EditorConfig
A small standard — a file named .editorconfig placed in a project — that many editors read automatically to agree on basic formatting like indentation, line endings, and final newlines, keeping a whole team consistent regardless of editor.
integrated terminal
A full command-line shell running inside the editor, so you can run commands, tests, and git without switching to a separate window.
multi-cursor
An editing feature that places several cursors at once so you can type or edit in many places simultaneously — for example renaming a name everywhere it appears.
settings
A list of an editor's preferences — font size, tab width, whether to trim stray whitespace on save — usually stored as a plain-text file you can edit and share.
language server
A separate program that understands one programming language and provides completion, go-to-definition, and error-checking to an editor, usually through the Language Server Protocol.
plain text editor
A basic editor that stores characters and nothing more, with no awareness that the text might be code — the Notepad-style app that ships with an operating system.

Sources and further reading


Kept in this browser, no account needed. Your progress page turns the whole record into one link you can bookmark or open on another device.