Demo: setting up a project folder using only the terminal

Written Explanation

The plan

A project folder for a small Java practice app might look like this. We use demo as the root, with two subfolders:

demo
├── src
│   └── Hello.txt
├── docs
│   └── notes.txt
└── listing.txt

The files are plain text for now, so nothing else needs to be installed. The point is the terminal skills, not the contents. You will use .txt files; real Java source files come in later modules.

The plan has six phases: stand, build, fill, inspect, search, clean up.

Phase 1: Stand

Open a terminal. Check where you are, then move to a folder that is safe for practice, such as a sandbox folder in your home folder.

Bash (Linux or macOS):

$ pwd
/home/ana
$ mkdir -p sandbox
$ cd sandbox
$ pwd
/home/ana/sandbox

PowerShell (Windows):

PS> pwd
Path
----
C:\Users\Ana
PS> mkdir sandbox
PS> cd sandbox
PS> pwd

Two checks happened: you saw where you started, and you confirmed where you ended. If sandbox already exists, mkdir complains and you just cd into it.

Phase 2: Build

Create the project and its two subfolders:

$ mkdir -p demo/src demo/docs
$ cd demo
$ pwd
/home/ana/sandbox/demo

PowerShell: mkdir demo/src and mkdir demo/docs (two commands, or one mkdir src, docs after cd demo), then cd demo. Then create two empty files:

$ touch src/Hello.txt docs/notes.txt
PS> New-Item src/Hello.txt -ItemType File
PS> New-Item docs/notes.txt -ItemType File

The two paths in the Bash command are relative to demo, which is why pwd first matters.

Phase 3: Fill

Write text into the files with redirection (Lesson 4). > starts a file fresh and >> adds:

$ echo "Hello from the terminal" > src/Hello.txt
$ echo "Project notes" > docs/notes.txt
$ echo "Created without a mouse" >> docs/notes.txt
$ cat docs/notes.txt
Project notes
Created without a mouse

PowerShell uses the same echo, >, and >>, and Get-Content docs/notes.txt (or cat) to read the file back.

Now set a variable for the session and use it. A variable can hold the project name:

$ export PROJECT=demo
$ echo "Project is $PROJECT" >> docs/notes.txt
PS> $env:PROJECT = "demo"
PS> echo "Project is $env:PROJECT" >> docs/notes.txt

Double quotes let the shell insert the variable's value. The notes file now has three lines. This variable disappears when you close the terminal, as Lesson 5 explained; the line it added to the file stays.

Phase 4: Inspect

List the project recursively, so you see the whole tree:

$ ls -R
PS> Get-ChildItem -Recurse -Name

ls -R lists subfolders too (the capital R means "recursive" here). Get-ChildItem -Recurse -Name prints the relative path of every item. Some systems also have a tree command that draws the layout; it may not be installed on yours. Check before you rely on it.

Now list the files in docs and src sorted by size, and save the result:

$ ls -lS src docs > listing.txt
PS> Get-ChildItem src, docs | Sort-Object Length -Descending > listing.txt

In Bash, ls -lS sorts by size with the biggest first. In PowerShell, the objects are sorted by their Length property. Look at the saved file:

$ cat listing.txt

Your sizes will differ from anyone else's, which is fine.

Phase 5: Search

Use a filter to find a word in the saved listing:

$ grep notes listing.txt
PS> Select-String notes listing.txt

You should see the line for notes.txt. If nothing appears, check your spelling and the capitalisation: grep is case-sensitive unless you add -i. Then try the pipe form straight from the folder, with no file in between: ls src docs | grep Hello, or Get-ChildItem src, docs -Name | Select-String Hello.

Phase 6: Save your evidence

The lab asks for two things: a command history file and the final folder tree. Capture both:

$ history > ../history.txt
$ ls -R > ../tree.txt
PS> Get-History > ../history.txt
PS> Get-ChildItem -Recurse -Name > ../tree.txt

They are saved in sandbox, one level above demo, so they are not part of the project they describe. A note: history in Bash prints the commands of the current session; on some systems a few of the latest commands may not yet show up in a file until the session ends. If your history looks short, run the command and look at the file before you hand it in. Get-History shows the commands of the current PowerShell session. The details can vary between systems, so check the output.

The planned mistake

Now the part you must not skip. We use two dummy folders, so nothing real is at risk. Do this only in sandbox.

$ cd ..
$ mkdir scratch precious
$ touch scratch/a.tmp scratch/b.tmp precious/a.tmp precious/keep.txt

(PowerShell: New-Item scratch/a.tmp -ItemType File and so on.)

You intend to clean the temporary files out of scratch. But you are standing in precious, because a previous task left you there:

$ cd precious
$ rm *.tmp
$ ls
keep.txt

The command ran perfectly. It deleted precious/a.tmp, not the files in scratch. No error, no warning, no recycle bin. The wildcard *.tmp meant "every .tmp file in the current folder", and the current folder was the wrong one.

Now replay it the safe way. Recreate the file, then do the three checks from Lesson 3:

$ touch a.tmp
$ pwd
/home/ana/sandbox/precious
$ ls
a.tmp  keep.txt

The pwd shows precious. You wanted scratch. The mistake is caught before it happens. Move, then delete:

$ cd ../scratch
$ pwd
$ rm *.tmp
$ ls

On PowerShell, a built-in preview adds a further layer of safety: Remove-Item *.tmp -WhatIf prints what would be deleted without deleting it. Microsoft's documentation describes the -WhatIf parameter for this purpose.

Clean up

When you are finished, remove the practice material deliberately:

$ cd ..
$ pwd
$ ls
$ rm -r scratch precious demo

(PowerShell: Remove-Item scratch, precious, demo -Recurse.) Keep history.txt and tree.txt if you want to show your work, and delete sandbox only when you are done with them.