Setting Up Your Development Environment

"Study to show thyself approved unto God, a workman that needeth not to be ashamed, rightly dividing the word of truth." — 2 Timothy 2:15 (KJV)

A Craftsman's Workshop

Every craftsman needs a well-organized workshop. A carpenter needs a workbench, saws, planes, chisels, measuring tools, and clamps — each with its purpose, each kept sharp and ready. A disorganized workshop with dull tools produces poor work. The same principle applies to software engineering.

Your development environment is your digital workshop. Setting it up correctly from the beginning saves countless hours of frustration later. Today, we will set up every tool you need and understand why each one matters.

The Essential Tools

1. The Terminal (Command Line Interface)

The terminal is your primary interface with the computer as an engineer. While most computer users interact through graphical windows and buttons, engineers work primarily through text commands. This is not because engineers enjoy being difficult — it is because text commands are:

• Precise: You type exactly what you want the computer to do
• Scriptable: You can save sequences of commands to run automatically
• Universal: Terminal commands work the same on every machine
• Fast: Experienced engineers accomplish tasks far more quickly through the terminal

On macOS, the built-in terminal application is called Terminal (or you can use iTerm2). On Windows, use Windows Terminal with WSL (Windows Subsystem for Linux). On Linux, every distribution includes a terminal.

Basic terminal commands you will use daily:

```bash

Print working directory — shows where you are

pwd

List files in the current directory

ls

Change directory — move to a different folder

cd my-project-chirho

Make a new directory (folder)

mkdir my-project-chirho

Create an empty file

touch index-chirho.ts

Display the contents of a file

cat index-chirho.ts

Clear the terminal screen

clear ```

The directory structure matters. Just as God gave Moses precise instructions for the tabernacle's layout — "Make this tabernacle and all its furnishings exactly like the pattern I will show you" (Exodus 25:9) — a software project requires an organized file structure. Files scattered randomly create confusion; files organized by purpose create clarity.

2. Bun — Your TypeScript Runtime

Bun is what actually executes your TypeScript code. It is a modern, all-in-one toolkit that includes:

• Runtime: Executes TypeScript and JavaScript files directly
• Package manager: Installs third-party libraries (`bun install` instead of `npm install`)
• Test runner: Runs your automated tests (`bun test`)
• Bundler: Packages your code for production deployment

To install Bun, open your terminal and run:

```bash

Install Bun (macOS/Linux)

curl -fsSL https://bun.sh/install | bash

Verify installation

bun --version ```

After installation, verify it works by checking the version number. You should see something like `1.x.x` printed to your terminal.

3. Code Editor — Visual Studio Code

A code editor is where you write your code. We recommend Visual Studio Code (VS Code) because it is free, powerful, and has excellent TypeScript support built in. Download it from [code.visualstudio.com](https://code.visualstudio.com).

Essential VS Code extensions to install:

• ESLint — highlights code quality issues as you type
• Prettier — automatically formats your code to be consistent
• Error Lens — shows TypeScript errors directly inline in your code

Configure VS Code to format on save: open Settings (Ctrl/Cmd + ,), search for "Format On Save," and check the box. This ensures your code is always consistently formatted — no more arguments about indentation.

4. Git — Version Control

Git tracks every change you make to your code, like an infinite undo history that also works across teams. We will study Git in depth tomorrow. For now, install it:

```bash

Check if Git is already installed

git --version

If not installed, Bun can help (or install from git-scm.com)

macOS: Git comes with Xcode Command Line Tools

xcode-select --install ```

Creating Your First Project

Let us create a proper project from scratch. Open your terminal and type each command:

```bash

1. Create a project directory

mkdir academy-first-project-chirho

2. Move into the directory

cd academy-first-project-chirho

3. Initialize a new Bun/TypeScript project

bun init ```

When you run `bun init`, Bun creates several files for you:

• package.json — your project's manifest: its name, version, dependencies, and scripts
• tsconfig.json — TypeScript configuration: how strict the compiler should be, what features to enable
• index.ts — a starter TypeScript file

Let us examine the project structure:

``` academy-first-project-chirho/ package.json # Project manifest tsconfig.json # TypeScript configuration index.ts # Entry point node_modules/ # Installed dependencies (managed by Bun) bun.lockb # Lock file (ensures consistent dependency versions) ```

Running Your First TypeScript File

Open `index.ts` in VS Code and replace its contents with:

```typescript // For God so loved the world that he gave his only begotten Son, // that whoever believes in him should not perish but have eternal life. — John 3:16

const greetingChirho: string = "The fear of the LORD is the beginning of knowledge."; console.log(greetingChirho); console.log("Proverbs 1:7"); console.log("Your development environment is working! Praise God."); ```

Now run it:

```bash bun run index.ts ```

You should see the output printed to your terminal. If you do — congratulations. Your workshop is set up and your first tool is sharp.

Understanding `tsconfig.json`

The TypeScript configuration file controls how strictly TypeScript checks your code. Open it and look for these important settings:

```json { "compilerOptions": { "strict": true, "noUnusedLocals": true, "noUnusedParameters": true, "noImplicitReturns": true } } ```

Setting `"strict": true` enables all of TypeScript's strictest checks. This is like a master carpenter who measures twice and cuts once — TypeScript's strict mode catches more errors at compile time, saving you from debugging at runtime. Always keep strict mode enabled.

The .gitignore File

One more critical file: `.gitignore` tells Git which files to NOT track. Create it:

```bash touch .gitignore ```

Add these lines to `.gitignore`:

``` node_modules/ .env *.log dist/ ```

• node_modules/ — installed packages; these are downloaded, not your code
• .env — environment variables that often contain secrets (API keys, passwords)
• \*.log — log files generated during development
• dist/ — compiled output; regenerated from source code

Never commit secrets to Git. "The prudent see danger and take refuge" (Proverbs 27:12).

A Thought to Carry

A well-configured development environment is not perfectionism — it is stewardship. You are organizing your tools so you can focus on the work God has given you. Every great craftsman, from Bezalel to the modern engineer, starts by preparing their workspace. Now yours is ready.