🧹 धडा 01 — shell का: केअरटेकरचा आवाज

📍 तुम्ही इथे आहात: 12 पैकी धडा 01 · पुढे: lesson-02-files-and-paths

📦 या ब्रँचमध्ये काय आहे

shell कोणती समस्या सोडवतो — आणि प्रत्येक command कडे असणाऱ्या तीन गोष्टी: एक उत्तर, एक log, आणि एक exit code. पूर्ण कोर्सभर तुम्ही वापराल अशा खऱ्या files:

bin/school.sh — command-line tool म्हणून शाळेची नोंदवही: पाच sub-commands, पूर्ण कोर्स एकाच script मध्ये
bin/backup.sh — lock, rotation आणि verification असलेला रात्रीचा backup (capstone)
bin/smoke_test.sh — प्रत्येक धड्याची कल्पना, खऱ्या scripts वर सिद्ध केलेली
tests/run_tests.sh — साध्या bash च्या ~30 ओळींमध्ये 14 checks
data/register.csv — नोंदवही

🎒 सुरू करण्यापूर्वी: तुम्हाला bash आणि एक terminal लागेल — macOS, Linux, किंवा Windows वर WSL. काहीही install करायचे नाही. चांगले शेजारी: CI/CD शाळा (जिथे या scripts प्रत्येक push वर चालतात) आणि Docker शाळा (प्रत्येक container ची entrypoint ही एक script असते).

🧒 5 वर्षांच्या मुलाला समजावल्यासारखे

शाळेत एक केअरटेकर आहे जो तुम्ही सांगाल तेच करतो, एका वेळी एक ओळ: "नोंदवही दाखव", "नोंदींचा backup घे", "दोन वाजता घंटा वाजव". तुम्ही arguments सह commands मध्ये बोलता. केअरटेकर सूचना फलकावर (stdout) उत्तर देतो, वहीत (stderr) कुरकुर लिहितो, आणि शेवटी एक कार्ड उंचावतो: "झाले" साठी 0, "नाही" साठी इतर कोणताही आकडा. script म्हणजे तेच आदेश लिहून ठेवलेले, म्हणजे केअरटेकर ते रात्री तुमच्याशिवाय चालवू शकतो.

🗺️ आकृती

flowchart LR
  P["$ bin/school.sh list --class 3A"] --> C["🧹 the caretaker (bash)"]
  C --> O["📄 stdout — the report"]
  C --> E["📣 stderr — the log"]
  C --> X["🔢 exit code $? — 0 or not"]

❓ काय

command म्हणजे एक program किंवा built-in; त्यामागे arguments येतात; flags (--class, -h) हे रूढीने arguments च असतात.
प्रत्येक command एका exit code ने संपतो: 0 यश, 1–255 अपयश. $? मध्ये शेवटचा code असतो. &&, ||, if, cron, CI आणि Docker सगळे तोच वाचतात.
बहुतेक Linux आणि macOS वर bash हा shell आहे; sh (POSIX) ही जुनी सामायिक भाषा आहे. file च्या सुरुवातीचे #!/usr/bin/env bash निवड करते.
man cmd, cmd --help, type cmd, which cmd हा सूचना फलक आहे.

🤔 का

प्रत्येक server, container आणि CI runner अजूनही असेच आदेश घेतो. पाच commands pipe मध्ये जोडू शकणारा developer दहा seconds मध्ये जे करतो, त्याला दुसऱ्या भाषेत script लिहून दहा मिनिटे लागतात — आणि प्रत्येक deploy, backup आणि incident shell मधूनच सुरू होतो.

🔧 कसे (या repo मध्ये)

bin/school.sh सुमारे ~70 ओळींची आहे: strict mode, एक HERE anchor, सामायिक log library, पाच cmd_* functions आणि case असलेले एक main. प्रत्येक धडा त्याला शिकवणाऱ्या ओळींकडे बोट दाखवतो.

🧪 करून पाहा

bin/school.sh list                       # the register
bin/school.sh list --class 3A; echo "exit code: $?"
bin/school.sh teleport; echo "exit code: $?"   # an unknown command: a log line, exit 1
bin/school.sh --help
bash bin/smoke_test.sh                   # the whole course in a minute

✅ तपासा — तुम्हाला काय दिसायला हवे

पाच विद्यार्थ्यांचे table; चांगल्या command नंतर exit code: 0 आणि teleport नंतर 1, आणि stderr वर ERROR: unknown command छापलेले; smoke test 🎉 the caretaker's routine runs ने संपतो. expected-output.txt शी तुलना करा.

🏁 तुम्ही आत्ताच काय सिद्ध केले

command कडे एक उत्तर, एक log आणि एक exit code असतो — आणि तुम्ही ते तिन्ही वाचू शकता.

⚠️ नेहमीच्या चुका

यश ठरवण्यासाठी output वाचणे. $? वाचा.
School.sh टाइप करणे — अक्षरांचा case महत्त्वाचा आहे; आणि ./ किंवा bin/ लागते, shell सध्याच्या directory मध्ये शोधत नाही.
shell ची भीती वाटणे. तो केअरटेकर आहे, जादूगार नाही.

🏭 प्रत्यक्ष वापरात हे का महत्त्वाचे: exit code हा तुमची script आणि ती चालवणारे सगळे यांच्यामधला करार आहे. "ERROR" छापणारा पण 0 ने exit होणारा deploy म्हणजे हिरवी खूण आणि तुटलेली site.

⏭️ पुढे

धडा 02 — files, paths आणि permissions: इमारतीचा नकाशा आणि कोणत्या खोलीत कोण जाऊ शकते.

🧹 Lesson 01 — Why the shell: the caretaker's voice

📍 You are here: Lesson 01 of 12 · Next: lesson-02-files-and-paths

📦 What's in this branch

The problem the shell solves — and the three things every command has: an answer, a log, and an exit code. Real files you will use all the way through:

bin/school.sh — the school register as a command-line tool: five sub-commands, the whole course in one script
bin/backup.sh — the nightly backup with a lock, rotation and verification (the capstone)
bin/smoke_test.sh — every lesson's idea, proven on the real scripts
tests/run_tests.sh — 14 checks in ~30 lines of plain bash
data/register.csv — the register

🎒 Before you start: you need bash and a terminal — macOS, Linux, or WSL on Windows. Nothing to install. Good neighbours: the CI/CD school (where these scripts run on every push) and the Docker school (a script is the entrypoint of every container).

🧒 Explain like I'm 5

The school has a caretaker who does exactly what you say, one line at a time: "list the register", "back up the records", "ring the bell at two". You speak in commands with arguments. The caretaker answers on the notice board (stdout), grumbles into a notebook (stderr), and holds up a card at the end: 0 for "done", any other number for "no". A script is the same orders written down so the caretaker can run them at night without you.

🗺️ Diagram

flowchart LR
  P["$ bin/school.sh list --class 3A"] --> C["🧹 the caretaker (bash)"]
  C --> O["📄 stdout — the report"]
  C --> E["📣 stderr — the log"]
  C --> X["🔢 exit code $? — 0 or not"]

❓ What

A command is a program or a built-in; arguments follow it; flags (--class, -h) are arguments by convention.
Every command ends with an exit code: 0 success, 1–255 failure. $? holds the last one. &&, ||, if, cron, CI and Docker all read it.
bash is the shell on most Linux and macOS; sh (POSIX) is the older common tongue. #!/usr/bin/env bash at the top of a file chooses.
man cmd, cmd --help, type cmd, which cmd are the notice board.

🤔 Why

Every server, container and CI runner still takes orders this way. A developer who can string five commands together in a pipe does in ten seconds what takes a script in another language ten minutes — and every deploy, backup and incident starts in a shell.

🔧 How (in this repo)

bin/school.sh is ~70 lines: strict mode, a HERE anchor, a shared log library, five cmd_* functions and a main with a case. Each lesson points at the lines that teach it.

🧪 Try it

bin/school.sh list                       # the register
bin/school.sh list --class 3A; echo "exit code: $?"
bin/school.sh teleport; echo "exit code: $?"   # an unknown command: a log line, exit 1
bin/school.sh --help
bash bin/smoke_test.sh                   # the whole course in a minute

✅ Verify — what you should see

A table of five students; exit code: 0 after a good command and 1 after teleport, with ERROR: unknown command printed on stderr; the smoke test ends with 🎉 the caretaker's routine runs. Compare with expected-output.txt.

🏁 What you just proved

A command has an answer, a log and an exit code — and you can read all three.

⚠️ Common mistakes

Reading the output to decide success. Read $?.
Typing School.sh — case matters; and ./ or bin/ is needed, the shell does not look in the current directory.
Fearing the shell. It is a caretaker, not a wizard.

🏭 Why this matters in production: the exit code is the contract between your script and everything that runs it. A deploy that prints "ERROR" but exits 0 is a green tick and a broken site.

⏭️ Next

Lesson 02 — files, paths & permissions: the building map and who may enter which room.

← Course homeall lessons Next →files and paths

This page is the lesson's README from the lesson-01-why-the-shell branch, shown here so the whole School stays on one site. Code files open on GitHub at the same branch.