Keyboard shortcuts

Press ← or → to navigate between chapters

Press S or / to search in the book

Press ? to show this help

Press Esc to hide this help

Home

FOSS MEC logo

FOSS MEC · Model Engineering College

Open notes. Open source. Open to everyone.

A permanent knowledge library for MEC: permission-cleared study material, verified open resources, and starter guides maintained by FOSS MEC.

Status: this library is new. The academic sections show an honest empty state until verified, permission-cleared material is accepted. The Git, Linux and workshop pages are starter drafts, not student submissions, and are open to correction.

Start here

What is in the library

The library is deliberately small and human-reviewed. Everything is plain Markdown in one repository, so it stays searchable, portable and easy for the next team to maintain.

SectionWhat you will findFormats
Academic MaterialsOriginal notes and study material, organised by semester and subjectNotes PDF Slides
Open Learning ResourcesLinks to official documentation, open books, courses and repositoriesDocs Book Course Video
Community GuidesLong-form tutorials on Git, GitHub and the Linux command lineNotes
Let’s Git ItWorkshop exercises and a printable Git cheat sheetNotes

Note — search covers the words on the page, not inside PDFs. mdBook search indexes rendered Markdown. A PDF or slide deck is discoverable only through the listing page that describes it, so every material listing includes a title, subject, keywords and a short description.

How contributions work

This is a read-only website backed by GitHub. There is no upload form, account system or database — suggestions and files travel through GitHub Issues and pull requests, where a maintainer can review them before publication.

Everything is done in a browser. You need a free GitHub account, but you do not need to install Rust, mdBook, Git or an editor to contribute.

Read the full contribution guide →

Built for the next team

  • One book, not many sites. New subjects and guides become chapters, not new deployments.
  • No runtime dependencies. The site is static HTML, CSS and JavaScript generated by mdBook.
  • Reviewed before publishing. Every change lands through a pull request and an automatic build.
  • Licensed content only. Contributors confirm they wrote the material or have permission to share it.

The source lives at github.com/FossMec/foss-mec-library. Every page has a Suggest an edit pencil in the top bar that opens its exact Markdown file.

Every merged contribution is credited on the Contributors page. Names are added after a real, reviewed contribution — never as placeholders.

Academic Materials

This section is for notes, slides, diagrams and question banks for MEC courses, organised by semester and subject. Materials are published only when the contributor wrote them or has explicit permission to redistribute them.

Browse by semester

Semester 3 onwards will get their own pages when the first verified material for those semesters is accepted. Until then, use the Open Learning Resources directory for free official references.

What belongs here

AcceptedNot accepted
Original notes you wrote in Markdown, PDF or slidesCopyrighted textbook PDFs or publisher slides
Diagrams and summaries created by youScanned pages from a textbook
Question papers only where the institution permits sharingLeaked or confidential exam papers
Material with a clear licence or written permissionFiles containing personal student data

Each listing must include a human-readable title, the subject, relevant keywords, a one-line description, the author/credit, the licence or permission note, and a working relative link.

Listing format

Use a Markdown table with four columns: Resource (a relative link), Format (Notes/PDF/Slides), Description (one line) and Credit / licence (author and permission). Do not publish a row until the file and permission are verified.

Place the file at:

src/assets/materials/<semester>/<subject>/<descriptive-name>.<ext>

Then link it from the page with a path relative to the Markdown file:

[descriptive title](../../assets/materials/<semester>/<subject>/<descriptive-name>.<ext>)

Do not use a leading /assets/... path: the site is published under https://fossmec.github.io/foss-mec-library/, so root-relative links break.

Before you upload

  • Size: keep each file at or below 10 MiB.
  • Formats: .pdf, .pptx, .docx, .png, .jpg, .webp, .svg and .md.
  • Name: lowercase kebab-case, descriptive, with a version suffix only when needed.
  • Permission: state the licence (for example CC BY 4.0) or attach the author’s written permission in the pull request description.
  • Search: describe the content in the Markdown listing, because search cannot read inside a PDF.

Have material to add? The browser-only guide walks you through forking, uploading and opening a pull request.

Upload a file → · All contribution paths →

Semester 1

This is the Semester 1 index. The university scheme in force for your admission year decides the course codes and syllabus — verify them with your department. No subject list is published here until verified material for that subject is accepted.

Published materials

No verified student materials have been published for Semester 1 yet.

This is deliberate: the library only lists files that the author wrote or explicitly allowed us to share. An empty section is better than an unlicensed upload.

Be the first contributor:

Submitting for Semester 1? Put the file under src/assets/materials/semester-1/<subject>/ and link it from this page with a relative path.

Read the upload guide →

Semester 2

This is the Semester 2 index. The university scheme decides the course codes and syllabus; confirm them with your department. No subject list is published here until verified material for that subject is accepted.

Published materials

No verified student materials have been published for Semester 2 yet.

The library does not host textbook scans or material uploaded without permission. If you wrote a summary, lab record or problem set yourself, it can be published here with credit.

Submitting for Semester 2? Put the file under src/assets/materials/semester-2/<subject>/ and add a listing with title, description, author and licence.

Read the upload guide →

Open Learning Resources

A curated directory of free, official or openly licensed learning material. These links point to the original source; the library does not mirror other people’s files.

Browse by topic

Every entry should be:

  1. Free to access without a paywall, trial or “request access” step.
  2. Authoritative — the project’s own documentation, the author’s site, or a recognised educational institution.
  3. Alive — checked when added; reported and fixed when it dies.
  4. Useful — a short description explains why a student would open it.

Excluded: pirated textbooks, affiliate links, content dumps, AI-generated summaries presented as official material, and anything locked behind an account the description calls free.

Found a good resource? Send the canonical URL, the topic, a two-sentence description and its licence/access details through the resource suggestion form.

Suggest a resource → · How suggestions are reviewed →

Git and GitHub

Version control is the core skill for contributing to open source. Start with the official book, then practise in a sandbox before touching a real repository.

Learn Git

ResourceFormatDescriptionSource / access
Pro Git, 2nd editionBookThe definitive free book. Chapters 1–3 cover repositories, commits and branching.Scott Chacon and Ben Straub — free online, CC BY-NC-SA 3.0
Git reference manualDocsOfficial command reference when you need exact flags and behaviour.Git project — free
Learn Git BranchingCourseInteractive visual exercises for branching, merging and rebasing.Free, browser-based
Oh My Git!GameAn open-source game that teaches Git concepts through play.Free and open source
GitHub Git cheat sheetPDFOne-page reminder of everyday commands.GitHub Education — free

Learn GitHub

ResourceFormatDescriptionSource / access
GitHub DocsDocsOfficial documentation for repositories, issues, pull requests and Pages.GitHub — free
Git and GitHub learning resourcesDocsGitHub’s curated entry point for beginners.GitHub — free
GitHub SkillsCourseShort, hands-on courses that run inside a real repository.GitHub — free
About pull requestsDocsWhat a pull request is and how review works.GitHub — free

Practice in this library

The Let’s Git It workshop includes a browser-only contribution path and exercises that use this repository as the practice ground.

Know a better Git resource? Official, free and currently maintained only.

Suggest a resource →

Linux and the Command Line

Almost every workshop, server and development tool assumes basic Linux comfort. These resources take you from navigating directories to reading manual pages and writing small scripts.

Start from zero

ResourceFormatDescriptionSource / access
The Linux Command LineBookA patient, complete introduction by William Shotts. Free PDF and online edition.Free, CC BY-NC-ND 3.0
Ubuntu command-line tutorialDocsA short guided tour of the terminal for absolute beginners.Canonical — free
Linux man-pagesDocsThe reference for system calls and C library behaviour. Use it with man.Free
GNU Bash manualDocsOfficial shell reference: expansions, builtins, job control.GNU Project — free

Go deeper

ResourceFormatDescriptionSource / access
The Missing SemesterCourseMIT’s practical course on the shell, editors, data wrangling and Git.Free
Advanced Bash-Scripting GuideBookA long, example-driven reference for shell scripting.Free
GNU Coreutils manualDocsExact behaviour of ls, cp, sort, find and friends.GNU Project — free
explainshellToolPaste a command and see each argument explained from the man pages.Free
ShellCheckToolPaste a script and catch common shell mistakes before running it.Free and open source
BanditPracticeSSH-based wargame that teaches Linux commands through puzzles.Free

Local practice

The Linux Command Line guide in this library is a short starter walkthrough of the commands you need for workshops; it is not a student submission. For deeper practice, install a Linux distribution in a virtual machine or use Windows Subsystem for Linux.

Know a free Linux resource written for students? Suggest it with a short description of what it covers.

Suggest a resource →

Programming

Free, official starting points for learning to program. Pick one language and one course, then write code every week — collecting links is not practice.

Python

ResourceFormatDescriptionSource / access
The Python TutorialDocsOfficial language tutorial, from data types to modules.Python Software Foundation — free
Python for EverybodyCourseDr. Chuck’s beginner course with videos, exercises and a free textbook.Free
Automate the Boring StuffBookPractical Python for files, spreadsheets and small scripts.Al Sweigart — free online

Web development

ResourceFormatDescriptionSource / access
MDN Learn Web DevelopmentCourseStructured HTML, CSS and JavaScript curriculum with exercises.Mozilla — free
MDN Web DocsDocsThe reference for browser APIs, HTML elements and CSS properties.Mozilla — free
freeCodeCampCourseProject-based certifications in web development and programming.Free, open curriculum

Computer science foundations

ResourceFormatDescriptionSource / access
CS50xCourseHarvard’s introduction to computer science; strong on problem solving.Free to audit
The Missing SemesterCourseThe computing skills a degree often assumes you already have.MIT — free
The Rust BookBookOfficial Rust guide if you want systems programming and memory safety.Free

Practice and roadmaps

ResourceFormatDescriptionSource / access
ExercismPracticeHundreds of exercises with human mentoring in many languages.Free
roadmap.shDocsCommunity roadmaps for frontend, backend, DevOps and more. Use as a map, not a checklist.Free

Write something original

The best way to prove you learned a topic is to explain it. Add a short guide or worked example to this library — see Add Written Notes.

Found a better beginner course? It must be free to access and actively maintained.

Suggest a resource →

Open Source and Self-Learning

Open source is more than free code: it is a way of collaborating in public. These resources explain the culture, the licensing and the mechanics of making a first contribution.

Understand open source

ResourceFormatDescriptionSource / access
Open Source GuidesDocsGitHub’s guides on starting, running and contributing to projects.CC BY 4.0
Choose a LicenseToolPlain-language comparison of MIT, Apache-2.0, GPL and CC licences.Free
First ContributionsRepositoryA deliberately tiny repository for practising the fork → pull request loop.MIT
GitHub SkillsCourseHands-on GitHub courses that run inside a repository.Free

Find something to work on

ResourceFormatDescriptionSource / access
Good First IssueToolBeginner-friendly issues aggregated from popular open-source projects.Free
Up For GrabsToolProjects explicitly welcoming new contributors.Free
HacktoberfestEventAnnual October event with beginner-friendly contribution guidance.Free

Learned something? Teach it

Self-learning is most durable when you turn it into a short, tested explanation. A good guide:

  • starts from a real problem you hit;
  • shows the exact commands or code;
  • explains the error messages a beginner will meet;
  • ends with a small exercise the reader can verify.

That is exactly the kind of original content this library wants. Read Add Written Notes and open a pull request.

Remember: a contribution does not have to be code. Fixing a typo, improving an explanation, adding a verified link or reporting a broken page all help.

Try the workshop exercises →

Community Guides

Starter guides maintained in this repository. They were drafted as workshop reference material, not student submissions, and are expected to be corrected and expanded by contributors. Unlike the resource directory, these pages are maintained here: if something is unclear or wrong, you can fix it with a pull request.

Available guides

Write a guide

These pages are a starting point, not a finished curriculum. Good guides come from problems you actually solved. A useful contribution:

  • targets one reader and one outcome;
  • uses short sections with runnable examples;
  • explains the error message, not just the happy path;
  • keeps commands copy-pasteable and avoids hidden assumptions;
  • cites official documentation for anything version-specific.

Read Add Written Notes for the chapter conventions and how to update src/SUMMARY.md. If you only want to fix a sentence, use the Suggest an edit pencil on the page — no local setup required.

Git Essentials

Starter draft. This page is workshop reference material, not a student submission. Check commands against the official Git documentation and improve the page with a pull request.

Git records the history of a project as a series of snapshots. You decide when to take a snapshot, what goes into it, and which line of history it belongs to. This guide covers the commands you need for the Let’s Git It workshop and for everyday coursework.

Check that Git is installed

git --version

If the command is missing, install Git from git-scm.com/downloads. On Debian or Ubuntu:

sudo apt install git

Configure your identity once

Git writes an author into every commit. Use the same email as your GitHub account.

git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main

Check the result:

git config --list --show-origin

Use --global for your laptop. Omit it inside a repository when a project needs a different identity.

Create a repository

A repository is a folder whose history Git tracks.

mkdir hello-git
cd hello-git
git init

git init creates a hidden .git/ directory. Do not delete or edit it by hand.

Check what Git sees:

git status

The three places a change can be

Understanding these three places prevents most beginner confusion:

working directory  →  staging area  →  repository
   (your files)        (git add)        (git commit)
  • The working directory is the folder you edit.
  • The staging area (also called the index) is the draft of your next commit.
  • The repository is the recorded history inside .git/.

Make your first commit

Create a file, stage it, then commit:

echo "# Hello Git" > README.md
git add README.md
git status
git commit -m "docs: add initial readme"

git add . stages every change below the current directory. That is convenient, but check git status first so you do not commit generated files or secrets.

A commit message should say what changed and why. The project uses short imperative messages, for example:

docs: fix broken Linux permissions example
feat: add semester 3 data structures page
fix: correct the workshop fork instructions

Inspect what happened

git status              # what is modified or staged
git diff                # unstaged changes
git diff --staged       # staged changes
git log --oneline       # compact history
git log --oneline --graph --all
git show HEAD           # the latest commit

HEAD means “the commit you currently have checked out”.

Ignore files you should not commit

Create a .gitignore in the repository root:

book/
target/
node_modules/
.env
*.log

Rules apply to untracked files. If a file is already tracked, remove it from the index first:

git rm --cached .env

Never commit passwords, API keys, private student data or generated build output.

Branches

A branch is a movable name for a line of commits. main is the default branch in most projects.

git branch                  # list local branches
git switch -c fix-typo      # create and switch
git switch main             # switch back
git branch -d fix-typo      # delete a merged branch

Make a branch for every independent change. This keeps main clean and makes pull requests easy to review.

Merge a branch

git switch main
git merge fix-typo

If both branches changed the same lines, Git stops and marks a conflict:

<<<<<<< HEAD
current version
=======
incoming version
>>>>>>> fix-typo

Edit the file to keep the correct result, delete the markers, then:

git add path/to/file
git commit

Do not blindly choose one side. Read both versions and test the result.

Remotes

A remote is a copy of the repository hosted somewhere else, usually GitHub.

git remote -v
git remote add origin git@github.com:USERNAME/REPO.git
git push -u origin main

-u links your local main to origin/main, so later you can run plain git push and git pull.

Clone an existing repository with:

git clone https://github.com/FossMec/foss-mec-library.git

Undo without panic

SituationCommand
Discard unstaged edits to one filegit restore path/to/file
Unstage a file but keep the editsgit restore --staged path/to/file
Amend the last commit message or contentsgit commit --amend
Undo the last commit, keep changes stagedgit reset --soft HEAD~1
Create a new commit that reverses an old onegit revert <commit>
Find a lost commit after a bad resetgit reflog

git reset --hard throws away uncommitted work. Use it only when you are certain.

Read the status output

When git status says:

Changes not staged for commit:
  modified:   README.md

the file is changed but not staged. Run git add README.md, then commit.

When it says:

Your branch is ahead of 'origin/main' by 1 commit.

you have a local commit that has not been pushed. Run git push.

Next step

Continue with Collaborating on GitHub to turn a local branch into a pull request. For a printable reminder, open the Git cheat sheet.

Collaborating on GitHub

Starter draft. This page is workshop reference material, not a student submission. Check current GitHub documentation and improve the page with a pull request.

Git tracks history on your machine. GitHub adds a shared home for that history, issues for discussion, and pull requests for review. This guide follows the fork-and-pull-request workflow used by the FOSS MEC Library.

The model

You usually do not have write access to the organisation repository. Instead:

FossMec/foss-mec-library          (upstream, read-only for you)
        │ fork
        ▼
your-username/foss-mec-library    (your copy, writable)
        │ clone / branch / commit / push
        ▼
pull request → review → merge → deploy

A fork is a full copy of the repository under your account. A pull request (PR) asks the maintainers to merge one of your branches into theirs.

Before you start

Option A — entirely in the browser

This is the workshop path and needs no local tools.

  1. Open FossMec/foss-mec-library.
  2. Click Fork (top right) and choose your account.
  3. In your fork, open the Markdown page you want to change, for example src/guides/git/collaboration.md.
  4. Click the pencil (Edit this file) or Add file → Create new file.
  5. Make one small, meaningful change.
  6. Scroll to Commit changes. Choose Create a new branch for this commit, give it a short name such as docs/fix-clone-command, and commit.
  7. GitHub offers Compare & pull request. Open the PR against FossMec/foss-mec-library, branch main.
  8. Fill in the pull request template and submit.

If you do not see the Fork button, check that you are signed in. If your account is new, GitHub may ask you to verify your email before enabling forks.

Option B — with Git on your machine

Fork and clone

Fork on GitHub, then clone your fork, not the organisation repository:

git clone https://github.com/YOUR-USERNAME/foss-mec-library.git
cd foss-mec-library
git remote add upstream https://github.com/FossMec/foss-mec-library.git
git remote -v

You should see:

origin    https://github.com/YOUR-USERNAME/foss-mec-library.git
upstream  https://github.com/FossMec/foss-mec-library.git

origin is your fork. upstream is the canonical project.

Create a branch

git switch main
git pull upstream main
git switch -c docs/add-git-tip

Use a branch name that describes the change. Avoid working directly on main in your fork.

Make and preview the change

Edit one or two files. If you changed Markdown, you can preview the book locally:

mdbook serve --open

If mdBook is not installed, skip the preview — CI will build the book for you. Keep the change focused; unrelated edits make review harder.

Stage, commit and push

git status
git diff
git add src/guides/git/README.md
git commit -m "docs: explain how to unstage a file"
git push -u origin docs/add-git-tip

The push output includes a link like:

https://github.com/YOUR-USERNAME/foss-mec-library/pull/new/docs/add-git-tip

Open it, or go to the upstream repository and click Compare & pull request.

Open the pull request

Write a title in the same style as your commit. In the description:

  • say what changed and why;
  • name the target subject or page;
  • state the source, author and licence for any uploaded file;
  • confirm you have permission to share the material;
  • list what you checked (for example, “opened the page in mdbook serve”).

A maintainer reviews the content, the licence and the links. CI builds the book on every PR. When both are green, the PR is squash-merged and the site deploys automatically.

Keep your fork up to date

GitHub’s web interface has Sync fork → Update branch on your fork’s main page. From the command line:

git switch main
git fetch upstream
git merge --ff-only upstream/main
git push origin main

If you use the GitHub CLI:

gh repo sync YOUR-USERNAME/foss-mec-library --source FossMec/foss-mec-library

Start each new contribution from an updated main to reduce conflicts.

Review and merge

A review may ask for changes. Push more commits to the same branch; the PR updates automatically.

git add .
git commit -m "docs: apply review feedback"
git push

Do not open a second PR for the same change. Do not force-push after review unless a maintainer asks you to, because it hides the review history.

Resolve a conflict

If main changed the same lines while your PR was open, GitHub reports a conflict. On your branch:

git fetch upstream
git merge upstream/main

Git marks the conflicting lines. Keep the correct combination, remove the <<<<<<<, ======= and >>>>>>> markers, then:

git add path/to/conflicted-file
git commit
git push

The PR becomes mergeable again.

What makes a good contribution

  • Small: one typo fix, one new resource, one guide section.
  • Accurate: commands tested, links opened, syllabus claims verified.
  • Attributed: source and licence stated for anything you did not write.
  • Kind: review comments are about the change, not the person.

Glossary

TermMeaning
ForkYour own copy of someone else’s repository
CloneA local copy of a repository
BranchA named line of commits
CommitA recorded snapshot with a message
PushUpload commits to a remote
PullFetch and integrate remote commits
Pull requestA request to merge a branch into another
MergeCombine histories, usually after review
UpstreamThe canonical repository you forked from

Still stuck? Open an issue and describe the step, the command and the exact error message.

Linux Command Line

Starter draft. This page is workshop reference material, not a student submission. Check commands against your distribution’s manual pages and improve the page with a pull request.

A short, practical introduction to the commands used in FOSS MEC workshops. It is not a complete Linux course; it is enough to navigate a system, edit files, inspect what is running and ask the right question.

The shell

When you open a terminal, a shell reads commands and runs programs. Most distributions use Bash or Zsh. The prompt usually shows your user, host and current directory:

dijith@laptop:~/projects$

$ means a normal user. # means root (administrator). Be careful with root commands.

Where am I?

pwd                 # print working directory
ls                  # list files
ls -la              # long listing, including hidden files
cd Documents        # enter a directory
cd ..               # go up one level
cd ~                # go to your home directory
cd -                # go back to the previous directory

Paths beginning with / are absolute: /home/dijith/notes. Paths without a leading slash are relative to the current directory.

Useful path shortcuts:

ShortcutMeaning
.current directory
..parent directory
~your home directory
-previous directory (for cd)
/filesystem root

Create, copy, move, remove

touch notes.md              # create an empty file (or update its timestamp)
mkdir projects              # create a directory
mkdir -p projects/git/demo  # create nested directories
cp notes.md backup.md       # copy a file
cp -r projects projects-old # copy a directory recursively
mv notes.md drafts/         # move or rename
rm backup.md                # delete a file
rm -r old-folder            # delete a directory and its contents

rm does not use a trash bin. Check the path before pressing Enter. Never run rm -rf / or paste a destructive command you do not understand.

Read files

cat notes.md            # print the whole file
less notes.md           # scrollable viewer: q to quit, / to search
head -n 20 notes.md     # first 20 lines
tail -n 20 notes.md     # last 20 lines
tail -f server.log      # follow a growing log, Ctrl+C to stop
wc -l notes.md          # count lines

less is safer than cat for large files. Inside less: Space next page, b previous page, /pattern search, n next match, q quit.

grep "TODO" notes.md              # lines containing TODO
grep -rn "TODO" src/              # recursive, with line numbers
grep -i "error" server.log        # case-insensitive
find . -name "*.md"               # files by name below the current directory
find . -type f -size +10M         # files larger than 10 MiB

Quote patterns that contain spaces or shell characters. Prefer grep -F when searching for literal text rather than a regular expression.

Pipes and redirection

A pipe sends the output of one command into another:

ls -la | less
grep -rn "TODO" src/ | wc -l
cat names.txt | sort | uniq

Redirection writes output to a file:

echo "hello" > hello.txt      # create or overwrite
echo "world" >> hello.txt     # append
command 2> errors.log         # redirect standard error
command > output.log 2>&1     # both stdout and stderr

> overwrites. Use >> when you mean to append.

Permissions

ls -l script.sh
# -rwxr-xr-- 1 dijith users 120 Jan 1 10:00 script.sh

The first character is the file type (- file, d directory). The next nine characters are permissions for user, group and others: read (r), write (w), execute (x).

chmod +x script.sh        # make a script executable
chmod 644 notes.md        # owner read/write; group and others read
chmod 755 script.sh       # owner read/write/execute; others read/execute

sudo runs one command with administrator privileges. Use it only when a task genuinely requires it, and never pipe an unknown script straight into sudo bash.

Processes

ps aux                 # all running processes
top                    # live process viewer, q to quit
htop                   # friendlier viewer if installed
pgrep -af python       # find processes matching a name
kill 1234              # politely stop process ID 1234
kill -9 1234           # force stop; last resort

Ctrl+C interrupts the foreground process. Ctrl+Z suspends it; fg resumes it, bg continues it in the background.

Packages

Package managers install, update and remove software. Use the one for your distribution:

DistributionInstallUpdate indexUpgrade
Debian / Ubuntusudo apt install PACKAGEsudo apt updatesudo apt upgrade
Fedorasudo dnf install PACKAGEsudo dnf check-updatesudo dnf upgrade
Archsudo pacman -S PACKAGEsudo pacman -Sysudo pacman -Syu
macOS (Homebrew)brew install PACKAGEbrew updatebrew upgrade

Avoid mixing package managers on the same system.

Manuals

man ls                 # manual page for ls
man 5 passwd           # section 5: file formats
apropos "copy files"   # search manual descriptions
ls --help              # short built-in help

Inside man: Space next page, /pattern search, q quit. If a command behaves unexpectedly, read its manual before searching the web.

SSH

Secure Shell connects to another machine:

ssh username@host.example.com
ssh -i ~/.ssh/id_ed25519 username@host

Generate a key pair if you do not have one:

ssh-keygen -t ed25519 -C "you@example.com"

This creates a private key (never share it) and a public key ending in .pub (safe to add to GitHub or a server).

Environment and PATH

echo $HOME             # print a variable
echo $PATH             # directories searched for commands
export EDITOR=nano     # set a variable for this shell session
which git              # locate the executable

If a command is “not found”, its directory is usually missing from PATH, or the package is not installed.

A first script

#!/usr/bin/env bash
set -euo pipefail

name="${1:-world}"
echo "Hello, ${name}!"

Save as hello.sh, then:

chmod +x hello.sh
./hello.sh
./hello.sh MEC

set -euo pipefail makes the script stop on errors, undefined variables and failed pipes. It is a good default for anything you will run more than once.

Practice

Work through Bandit or the Let’s Git It exercises. For a structured course, see Linux and the Command Line.

Let’s Git It

Let’s Git It is FOSS MEC’s beginner workshop on Git, GitHub and contributing to a real project. This library is the practice ground: every exercise uses the same repository that publishes this website.

What you will be able to do

By the end of the workshop you should be able to:

  • explain the difference between Git and GitHub;
  • fork a repository, create a branch and commit a change;
  • open a pull request and respond to review;
  • add a Markdown note or an external resource to this library;
  • find the site’s source file from the Suggest an edit link.

You do not need to install anything. Everything can be done in a browser.

Before you arrive

  1. Create a free GitHub account and verify your email.
  2. Bring a laptop or a phone with a browser. A laptop is easier for file uploads.
  3. Read the contribution paths for two minutes.
  4. Optionally install Git locally if you want to practise the command line.

Workshop route

StepTimeWhat happens
1. Concepts10 minRepositories, commits, branches, forks, pull requests
2. Tour10 minThe library structure and the browser-only GitHub editor
3. Quickstart15 minFork → edit → commit → pull request
4. Exercises25 minPick one task from the exercise list
5. Review10 minRead a partner’s PR and leave a kind, specific comment
6. Merge and deploy5 minA maintainer merges; GitHub Actions publishes the site

Start here

Ground rules

  • One small change per pull request. Small PRs are reviewed faster and teach more.
  • Do not edit src/SUMMARY.md unless you are adding a new chapter. Most fixes do not need it.
  • Only upload what you wrote or are allowed to share. State the licence in the PR.
  • Be kind in review. Critique the change, not the person.
  • Ask early. Open an issue or ask a maintainer if a step fails; do not guess around a permission error.

After the workshop

Continue with the Git Essentials guide and Collaborating on GitHub. Then pick a good first issue and keep contributing.

Quickstart — your first pull request

This walkthrough takes about 15 minutes and uses only a browser. You will fork the library, make one small documentation change and open a pull request.

What is a pull request? A request to merge your branch into the project’s main branch. A maintainer reviews it, automated checks build the book, and then it is merged.

1. Sign in and fork

  1. Open github.com/FossMec/foss-mec-library.
  2. Sign in. If you do not have an account, create one and verify your email.
  3. Click Fork at the top right.
  4. Choose your own account as the destination and click Create fork.

You now have https://github.com/YOUR-USERNAME/foss-mec-library.

If the Fork button is missing, you are probably not signed in, or your email is unverified.

2. Pick one small change

Choose one of these. They touch different files, which keeps the workshop free of merge conflicts.

ChangeFile to edit
Add a term to the glossarysrc/glossary.md
Improve one sentence in the Git guidesrc/guides/git/README.md
Add a free official Git resourcesrc/resources/git.md
Improve the Linux guidesrc/guides/linux/README.md
Add a free Linux resourcesrc/resources/linux.md

Read the page first. The change must be true, useful and in your own words.

3. Edit in the browser

  1. In your fork, open the file from the table above.

  2. Click the pencil icon (Edit this file).

  3. Make the change. Keep Markdown formatting intact:

    | [Git reference manual](https://git-scm.com/docs) | <span class="fmt fmt-docs">Docs</span> | Official command reference. | Git project — free |
    
  4. Scroll down to Commit changes.

  5. In the message box, write what changed, for example:

    docs: add glossary entry for upstream
    
  6. Choose Create a new branch for this commit and start a pull request.

  7. Name the branch docs/add-upstream-term and click Propose changes.

4. Open the pull request

GitHub opens the compare page. Check:

  • base repository: FossMec/foss-mec-library
  • base branch: main
  • head repository: YOUR-USERNAME/foss-mec-library
  • compare branch: the branch you just created

Write a title beginning with docs: and complete the pull request template:

  • Summary: one or two sentences.
  • Content type: tick Documentation fix or Resource link.
  • Permission: tick the confirmation that the text is yours or appropriately licensed.
  • Checklist: tick what you actually checked.

Click Create pull request.

5. Watch the checks

Two things happen:

  1. build runs the content validator and builds the book. It usually takes a minute.
  2. A maintainer reviews the change.

A red check is normal while you are learning. Open the failed step and read the message. A broken local link, a disallowed file or an unlisted chapter are the usual causes. Fix the file in your branch and commit again; the same pull request updates.

Deployment does not run on pull requests. Only merged changes to main are published.

6. After review

  • If changes are requested, edit the same file again and commit to the same branch.
  • When approved and green, a maintainer squash-merges the pull request.
  • GitHub Actions rebuilds and deploys the site automatically.
  • Your change appears at fossmec.github.io/foss-mec-library within a few minutes.

If something goes wrong

ProblemFix
No Fork buttonSign in and verify your email
Cannot edit the fileMake sure you are in your fork, not FossMec/foss-mec-library
No Compare & pull request bannerOpen the Pull requests tab → New pull request → compare across forks
Check failed on a linkOpen the log, find the file and line, fix the path
Merge conflictAsk a maintainer; do not force anything
Wrong base repositoryEdit the pull request and change the base to FossMec/foss-mec-library

Practice complete

You have used the same workflow as every contributor to this library. Next, try one of the workshop exercises or read Collaborating on GitHub for the command-line version.

Workshop Exercises

Seven non-conflicting tasks. Pick one, read the linked file, and open a pull request. Each task lists the file to change and what counts as done.

Rule: one exercise per pull request. Do not edit src/SUMMARY.md — none of these tasks need a new chapter.

1. Add a glossary term

File: src/glossary.md

Add one term that a first-year would meet in this library, for example repository, remote, staging area, fork, upstream, merge conflict or pull request. Keep the existing alphabetical order and the existing format.

Done when:

  • the term is defined in one or two plain-English sentences;
  • the definition is original;
  • the table still renders correctly;
  • no other glossary rows are changed.

2. Fix an unclear sentence

File: src/guides/git/README.md

Find one sentence that assumes too much or could be misread. Rewrite it without changing the meaning of the commands.

Done when:

  • the change is limited to a few lines;
  • the technical meaning stays correct;
  • the page still builds.

3. Add a free Git resource

File: src/resources/git.md

Add one official, free, currently maintained resource. It must be new to the page. Include its canonical URL, a format label, a one-line description and the source/licence.

Done when:

  • the link opens without a paywall or sign-up;
  • the title matches the destination page;
  • the description says why a student would use it;
  • the entry appears in the correct table.

4. Improve the Linux guide

File: src/guides/linux/README.md

Add a short, tested example to an existing section — for example one more safe find pattern or a note about a common error message. Do not create a new page.

Done when:

  • the command is correct and safe;
  • the explanation says what the output means;
  • no unrelated section is reformatted.

5. Add a free Linux resource

File: src/resources/linux.md

Add one authoritative, free resource that is not already listed. Official documentation, a free book, or a recognised university course are good candidates.

Done when:

  • the URL is the canonical source;
  • access is genuinely free (no trial or institutional login);
  • attribution and licence/access are stated.

6. Add a programming resource

File: src/resources/programming.md

Add one beginner-friendly free resource for Python, the web or computer-science foundations. Avoid link dumps and SEO listicles.

Done when:

  • it teaches, rather than only linking onward;
  • it is free to access;
  • the description is specific enough to choose it over the alternatives.

7. Report a problem

No file edit needed.

Use the structured issue form:

Done when:

  • the form is complete;
  • the page/resource is identified precisely;
  • the expected and actual behaviour are clear.

Review your own work

Before submitting, check:

  • I changed only the files needed for this task.
  • I opened every link I added.
  • I ran the commands I documented, or marked them clearly as examples.
  • The text is mine, or the source and licence are stated.
  • I did not upload copyrighted material or personal data.
  • The pull request description follows the template.

A maintainer will review content, attribution and links. CI will validate the build. If a check fails, read the message and push a fix to the same branch.

Git Cheat Sheet

A one-page reference for the workshop. Commands are safe unless marked otherwise.

Setup

git --version
git config --global user.name "Your Name"
git config --global user.email "you@example.com"
git config --global init.defaultBranch main

Start a repository

git init                     # start tracking the current folder
git clone URL                # copy an existing repository
git status                   # what changed?

Everyday loop

git status
git diff                     # unstaged changes
git add FILE                 # stage one file
git add .                    # stage everything below this folder
git diff --staged            # review what will be committed
git commit -m "docs: message"
git log --oneline

Branches

git branch                   # list branches
git switch -c my-branch      # create and switch
git switch main              # switch back
git merge my-branch          # merge into the current branch
git branch -d my-branch      # delete a merged branch

Remotes

git remote -v
git remote add upstream https://github.com/FossMec/foss-mec-library.git
git fetch upstream
git merge --ff-only upstream/main
git push -u origin my-branch
git pull

Undo

git restore FILE                 # discard unstaged edits (destructive)
git restore --staged FILE        # unstage, keep edits
git commit --amend               # edit the last commit
git reset --soft HEAD~1          # undo last commit, keep changes staged
git revert COMMIT                # safe undo with a new commit
git reflog                       # find lost commits

Fork → pull request

  1. Fork the repository on GitHub.
  2. Clone your fork: git clone https://github.com/YOU/REPO.git.
  3. Add upstream: git remote add upstream https://github.com/OWNER/REPO.git.
  4. Update main: git switch main && git pull upstream main.
  5. Branch: git switch -c docs/short-description.
  6. Edit, then git add FILE and git commit -m "docs: ...".
  7. Push: git push -u origin docs/short-description.
  8. Open the link GitHub prints and create the pull request.
  9. Push more commits to the same branch to answer review.

Markdown used in this library

# Page title

## Section

**bold**  *italic*  `inline code`

- list item
- [Git reference](https://git-scm.com/docs)

| Column | Column |
| --- | --- |
| cell | cell |

> A note or warning.

```bash
git status
```

Format labels

Use the existing HTML labels inside tables:

<span class="fmt fmt-notes">Notes</span>
<span class="fmt fmt-pdf">PDF</span>
<span class="fmt fmt-slides">Slides</span>
<span class="fmt fmt-docs">Docs</span>
<span class="fmt fmt-book">Book</span>
<span class="fmt fmt-video">Video</span>
<span class="fmt fmt-repo">Repository</span>
<span class="fmt fmt-course">Course</span>

File naming

  • lowercase kebab-case: stack-basics.pdf, not Stack Basics.PDF;
  • materials under src/assets/materials/<semester>/<subject>/;
  • maximum 10 MiB per file;
  • allowed: .md, .pdf, .pptx, .docx, .png, .jpg, .webp, .svg;
  • never commit secrets, personal data or unlicensed textbooks.

Pull request checklist

  • One focused change.
  • Links opened and working.
  • Commands tested.
  • Source, author and licence stated.
  • src/SUMMARY.md updated only if a new chapter was added.
  • No leading / in local asset links.
  • PR template completed.

If a check fails

MessageLikely fix
missing chapterAdd the file listed in src/SUMMARY.md, or correct the path
broken local linkFix the relative path; decode %20 spaces
disallowed extensionUse an allowed format or link to the original host
file too largeCompress it, or link to the authorised source instead
create-missing errorCreate the missing README.md or remove the summary entry

Ask in the pull request if the message is unclear. Do not close and reopen a new PR for the same change.

How to Contribute

The library is a static website built from Markdown in one GitHub repository. There is no upload server, login system or admin panel. Contributions travel through GitHub, where a maintainer can review them before they are published.

You need a free GitHub account. You do not need Rust, mdBook, Git or a code editor — every path below can be completed in a browser.

Choose a path

The shortest successful path

  1. Find the page you want to improve. Use the Suggest an edit pencil in the top bar; it opens the exact source file on GitHub.
  2. Fork the repository if you do not already have a fork.
  3. Create a branch with a short name, for example docs/fix-linux-permissions.
  4. Make one focused change in the browser editor or upload the file through GitHub.
  5. Open a pull request against FossMec/foss-mec-library:main.
  6. Respond to review. Push fixes to the same branch; the pull request updates.
  7. After merge, GitHub Actions deploys automatically. No manual deploy step.

The quickstart walks through this in 15 minutes.

What maintainers review

CheckWhy it matters
AccuracyWrong commands or claims are worse than no page
PermissionMaterial must be yours or explicitly shareable
AttributionAuthor, source and licence must be clear
LinksCanonical, free and working
ScopeOne focused change is easier to review and revert
BuildThe validator and mdbook build must pass

Review is a conversation, not a gate. If a maintainer asks a question, answer in the pull request thread. If you disagree, explain why with a source.

Content rules

  • Write in your own words. Do not paste copyrighted text.
  • Do not upload textbook scans, publisher slides, leaked question papers or personal student data.
  • Do not add executables, archives, password-protected files or secrets.
  • Keep files at or below 10 MiB.
  • Use lowercase kebab-case filenames with no spaces.
  • Link local files with relative paths, never /assets/....
  • New original documentation is contributed under CC BY 4.0; code and scripts use MIT.
  • Do not add unreviewed link dumps. Curate a few genuinely useful entries.

See LICENSE-CONTENT.md and CONTRIBUTING.md in the repository for the full policy.

What this site cannot do

To set expectations honestly:

  • it cannot accept a file directly from the website;
  • it cannot create a GitHub account for you;
  • it cannot publish a change before review;
  • it cannot search inside a PDF or slide deck — only the Markdown listing is indexed;
  • it cannot notify you outside GitHub (no email newsletter or account system).

If a workshop facilitator gives you a different route (for example, a shared issue thread), follow their instructions for the session and still use the pull request template for the final change.

Need help?

  • Read the workshop exercises for small, well-defined tasks.
  • Open an issue with the exact step, command and error message.
  • Ask a FOSS MEC maintainer at a workshop or through the community channels listed at foss.mec.ac.in.

Add Written Notes

Use this path for original Markdown: a new explanation, a worked example, a glossary entry, or a longer guide. It is the easiest contribution because GitHub can render and review the change in the browser.

Decide what kind of page you are writing

Your contentWhere it goesNeeds SUMMARY.md?
A correction or clarificationThe existing pageNo
A new section inside an existing guideThe existing guide chapterNo
A new resource linkThe relevant src/resources/*.md pageNo
A new standalone chapter or guideA new .md file under src/guides/ or src/academics/Yes
A glossary termsrc/glossary.mdNo

Most first contributions should not touch src/SUMMARY.md. That keeps pull requests small and avoids conflicts.

Step 1 — Fork and branch

Fork FossMec/foss-mec-library to your account, then create a branch in your fork:

docs/add-terminal-shortcuts

In the browser: open your fork, click the branch selector, type the new name and choose Create branch.

With Git:

git clone https://github.com/YOUR-USERNAME/foss-mec-library.git
cd foss-mec-library
git remote add upstream https://github.com/FossMec/foss-mec-library.git
git switch -c docs/add-terminal-shortcuts

Step 2 — Write the page

Create or edit a Markdown file under src/. Follow the existing style:

  • exactly one # heading at the top;
  • ## for main sections and ### below that;
  • short paragraphs, lists and tables;
  • fenced code blocks with a language tag;
  • relative links to other chapters and assets;
  • no HTML layout unless the existing page already uses it (the home page and resource labels do).

A minimal chapter:

# Understanding the Git staging area

The staging area is the draft of your next commit.

## Why it exists

It lets you choose which changes belong in a snapshot.

## Try it

```bash
git add README.md
git status
git commit -m "docs: explain staging"
```

Do not copy the example line git add blindly; run commands before documenting them.

Step 3 — Add it to SUMMARY.md (only for a new chapter)

src/SUMMARY.md controls the sidebar. Add one line in the correct section:

- [Understanding the staging area](guides/git/staging.md)

The path is relative to src/. create-missing = false means a summary entry without a file fails the build, which is intentional.

If you are editing an existing page, skip this step.

Put images in src/assets/images/ (or a subject folder under src/assets/materials/). Link them relative to the Markdown file:

![Stack diagram](../../assets/images/stack-diagram.png)

From src/guides/git/staging.md, ../../assets/images/... resolves correctly. A leading /assets/... breaks on GitHub Pages because the site lives under /foss-mec-library/.

Step 5 — State authorship and licence

By opening the pull request you agree to publish your original text under CC BY 4.0, with attribution to you as the author. Say in the PR description:

  • your name (or the name you want credited);
  • whether the text is entirely yours;
  • any sources you paraphrased;
  • if you adapted existing material, its licence and a link.

Do not paste large extracts from textbooks, paid courses or other websites.

Step 6 — Check the Markdown

You do not need mdBook to submit a PR: CI builds the book for you. If you have mdBook installed locally, preview with:

mdbook serve --open

Then run the same content check as CI:

python3 scripts/validate_content.py

Step 7 — Open the pull request

Commit with a clear message:

git add src/guides/git/staging.md src/SUMMARY.md
git commit -m "docs: add staging area guide"
git push -u origin docs/add-terminal-shortcuts

Open the pull request against main and complete the template. In the description, say what the reader will learn and list the commands you tested.

Review checklist

  • One topic, one focused change.
  • Original wording; sources paraphrased, not copied.
  • One # heading; sensible nested headings.
  • Local links are relative and resolve.
  • New chapter added to SUMMARY.md; existing page left out of it.
  • Author, source and licence stated in the PR.
  • No personal data, secrets or copyrighted uploads.
  • CI build check passes.

A maintainer may edit wording for clarity or ask for a split if the PR covers too much. That is normal review, not rejection.

Upload a File

Use this path for a PDF, slide deck, diagram or document you wrote — or for material you have explicit written permission to share. The website has no upload box: files are added to the repository through GitHub, which gives every upload a reviewable history.

Before you upload

Answer these questions honestly:

  1. Did I create this file? If yes, state the licence you are granting.
  2. Did someone else create it? Do you have written permission to redistribute it? A link to the original is not permission.
  3. Is it already freely available from the author? If so, link to the original host instead of copying it into the repository.
  4. Does it contain personal data? Remove names, roll numbers, marks, phone numbers and email addresses belonging to other people.
  5. Is it under 10 MiB? Compress it or link to the authorised source.

Never upload textbook scans, publisher slides, leaked question papers, exam answers, executables, archives, password-protected files or anything you do not have the right to share.

File rules

RuleValue
Maximum size10 MiB per file (GitHub’s browser upload limit is 25 MiB)
Allowed extensions.pdf, .pptx, .docx, .png, .jpg, .jpeg, .webp, .svg, .md
Filename stylelowercase kebab-case, no spaces, descriptive
Locationsrc/assets/materials/<semester>/<subject>/
LicenceState it in the listing and the pull request

The pattern is:

src/assets/materials/<semester>/<subject>/<descriptive-name>.<ext>

Use the real semester, subject and descriptive name for your file. Do not copy an example subject from another contribution.

Version a file with a suffix only when both versions are genuinely useful: notes-v2.pdf. Do not keep near-duplicate copies.

Step 1 — Fork the repository

Open FossMec/foss-mec-library, click Fork, and create the fork under your account. If you already have a fork, click Sync fork → Update branch before starting.

Step 2 — Create the folders in your fork

GitHub cannot create an empty folder, so navigate to the intended parent and use Add file → Create new file. In the filename box type the full path, including the new folder name and a temporary .md file. Replace each <...> field with your real semester and subject:

src/assets/materials/<semester>/<subject>/README.md

Put a single line in the file:

# <Subject> — Semester <number>

Commit it to a new branch such as materials/<semester>-<subject>. The folder now exists in your branch.

Why a README? It gives the folder a human-readable subject title and keeps the repository navigable. It is not added to SUMMARY.md, so it is not a website chapter.

Step 3 — Upload the file

  1. In your fork, switch to your new branch.

  2. Navigate to the folder you created.

  3. Click Add file → Upload files.

  4. Drag in the PDF or slides, or choose files from your device.

  5. Write a commit message:

    materials: add <subject> notes
    
  6. Commit directly to your branch.

The file must keep its lowercase kebab-case name. GitHub preserves the filename exactly.

Step 4 — Add the listing to a Markdown page

A file becomes discoverable only when a Markdown index describes it. Open the relevant semester page, for example src/academics/semester-1/README.md, click the pencil, and add an entry:

| Resource | Format | Description | Credit / licence |
| --- | --- | --- | --- |
| [<descriptive title>](<relative-path>.<ext>) | <span class="fmt fmt-pdf">PDF</span> | <one line about the subject and topic> | <author> — <licence or permission> |

Replace every <...> field with real information. Do not publish a row until the file and the permission are verified.

The resource link must be relative to that Markdown file. For a page at src/academics/semester-1/README.md, a file at src/assets/materials/semester-1/<subject>/<descriptive-name>.<ext> is linked as:

[<descriptive title>](../../assets/materials/semester-1/<subject>/<descriptive-name>.<ext>)

The link must start with ../../, not /assets/. Test it after the build deploys.

Include keywords a student would search for in the description: subject, topic, semester, author. Search indexes the Markdown listing, not the PDF contents.

If the subject deserves its own chapter (several files and a long explanation), create a page under src/academics/semester-1/<subject>/README.md and add it to src/SUMMARY.md using the chapter format. One file is usually not enough to justify a new chapter.

Step 5 — Open the pull request

Commit the listing change, then open a pull request against FossMec/foss-mec-library:main.

In the description include:

  • File: the path you added.
  • Subject and semester: the actual subject and semester, not an example.
  • Author: the person who created the file.
  • Permission: “I wrote this file” or “I have written permission from the author; attached in this thread.”
  • Licence: for example CC BY 4.0, or the existing licence with a link.
  • Description: what the file covers and who it helps.
  • Checks: confirm the file is under 10 MiB, contains no personal data and the relative link resolves.

Download the one-page contribution checklist if you want the requirements beside you while preparing the PR. The checklist is an original template prepared for this library, not student material.

Step 6 — CI and review

Two automated checks run:

  • python3 scripts/validate_content.py checks extensions, size, local links and SUMMARY.md.
  • mdbook build builds the site with create-missing = false.

A maintainer then checks origin, permission, attribution and usefulness. If something is missing, they will ask in the pull request. Push the fix to the same branch.

After merge, GitHub Actions deploys automatically. Open the live page and click the download link to confirm the file serves correctly.

Common mistakes

MistakeResultFix
File over 10 MiBValidation failsCompress, split, or link to the original
.zip, .exe, .rarDisallowed extensionDo not upload; use the canonical source
/assets/materials/... linkBroken on project PagesUse ../../assets/materials/...
Spaces or capitals in filenameInconsistent paths, fragile linksRename to kebab-case
New chapter not in SUMMARY.mdBuild fails with create-missingAdd the chapter or do not create a page
Listing without description/creditReview blockedAdd title, description, author, licence
PDF only, no Markdown listingInvisible to search and navigationAdd the table entry

If a file is rejected, that is not a judgement of its quality. It usually means the licence or origin cannot be verified, and the library must stay safe to publish.

Suggest a Resource

The fastest contribution: send a free, authoritative link through a structured GitHub issue form. No fork, no branch, no Markdown required. A maintainer reviews the suggestion and adds it to the right directory page.

Submit a suggestion

You need a GitHub account to submit the form. The issue is public and visible to everyone.

What the form asks

FieldWhat to write
Resource titleThe title shown on the destination page
Canonical URLThe original author’s or project’s URL, not a mirror or shortener
Topic / courseGit, Linux, programming, open source, or a specific semester subject
DescriptionOne or two sentences: what it teaches and who it is for
Source / authorOrganisation or person who maintains it
Access and licence“Free, CC BY 4.0”, “Free, official docs”, “Free to audit”, etc.
Why it belongsWhat gap it fills compared with entries already listed

What gets accepted

  • Free to access without a paywall, trial, invite or misleading “free” login wall.
  • Authoritative: the project’s own documentation, a recognised institution, or the author’s site.
  • Current: maintained recently, not an abandoned course from a decade ago.
  • Specific: teaches something, rather than being a list of more links.
  • Safe: no pirated textbooks, cracked software, malware, affiliate links or exam leaks.

Link to the original host. Do not ask us to mirror a file unless you own it or it is openly licensed for redistribution.

What happens next

  1. A maintainer reads the issue and checks the link, author and licence.
  2. If it fits, they either add the entry themselves or ask you to open a pull request.
  3. The entry is added to the relevant page, for example src/resources/git.md.
  4. CI builds the change, a maintainer merges it, and the site deploys automatically.
  5. The issue is closed with a link to the published page.

Typical turnaround is a few days around workshops, longer during exams. If an issue gets no response after a week, leave a polite comment — do not open duplicates.

Prefer to make the edit yourself?

This is the workshop’s direct-PR path and teaches the GitHub flow:

  1. Fork the repository.

  2. Open the relevant page, for example src/resources/linux.md.

  3. Click the pencil and add one row to the correct table:

    | [Git reference manual](https://git-scm.com/docs) | <span class="fmt fmt-docs">Docs</span> | Official command reference. | Git project — free |
    
  4. Commit to a branch such as resources/add-linux-book.

  5. Open a pull request with the template completed.

Use the same acceptance rules as above. Do not reorder or reformat unrelated rows; a focused diff is easier to review.

Format labels

Use the label that matches the destination:

LabelUse for
<span class="fmt fmt-docs">Docs</span>Official documentation or reference
<span class="fmt fmt-book">Book</span>A free book or long-form text
<span class="fmt fmt-course">Course</span>A structured course or curriculum
<span class="fmt fmt-video">Video</span>A video series or recorded lecture
<span class="fmt fmt-repo">Repository</span>A code repository or example project
<span class="fmt fmt-pdf">PDF</span>A downloadable PDF
<span class="fmt fmt-notes">Notes</span>Original written notes
<span class="fmt fmt-slides">Slides</span>A slide deck

Use the broken link form and include:

  • the library page where you found the link;
  • the URL that fails;
  • what you expected and what happened (404, redirect to an unrelated page, paywall, wrong content);
  • the date you checked, if the site is intermittent.

Do not paste the entire page or personal data. A maintainer will fix or remove the entry through a pull request. External links are checked by humans during review; the build deliberately does not fail because a remote server is temporarily down.

Glossary

Short definitions for terms used across the library. Add a term by editing the table in alphabetical order — no new chapter or SUMMARY.md change is needed.

TermMeaning
BranchA named line of commits. Branches let you work on a change without affecting main.
CloneA local copy of a Git repository, including its history.
CommitA recorded snapshot of the staged changes, with an author, timestamp and message.
ForkYour own copy of someone else’s repository on GitHub. You can change it without affecting the original.
GitThe version-control program that records changes locally.
GitHubA hosting and collaboration platform for Git repositories, issues and pull requests.
HEADThe commit currently checked out in your working copy.
IssueA GitHub discussion item used to report a bug, suggest a resource or request a topic.
mainThe default branch of this repository. Changes reach it through pull requests.
MarkdownA plain-text formatting language using # headings, lists and links. All library pages are Markdown.
mdBookThe static-site generator that turns src/SUMMARY.md and Markdown files into this website.
MergeCombining the history of one branch into another.
Merge conflictA state where Git cannot combine two changes automatically because they touch the same lines.
OriginThe default name for the remote repository you cloned from, usually your fork.
Pull request (PR)A GitHub request to merge a branch into another branch, with review and automated checks.
RebaseReplaying commits on top of another branch to create a linear history. It rewrites commit hashes, so avoid rebasing shared branches.
RemoteA named copy of a repository hosted elsewhere, such as origin or upstream.
Repository (repo)A project folder tracked by Git, including its history in .git/.
Staging areaThe draft of the next commit; files enter it with git add.
UpstreamThe canonical project repository that you fork from, usually FossMec/foss-mec-library.
Working treeThe files currently on disk that you are editing.

Contributors

This library exists because people contribute documentation, code, design, review and workshop material. This page lists real, verified people only. There are no placeholder names, and automated bots are not presented as human contributors.

People

NameGitHubContribution
DIJITH@dijith-481Project maintainer: repository setup, mdBook theme, GitHub Actions deployment, contribution workflow and workshop material

How this page is maintained

  • A maintainer adds a row after a person’s first merged contribution.
  • Credit is for merged work: documentation, code, design, review or workshop facilitation.
  • Use the name and link the contributor prefers. Ask before adding a personal name.
  • A contributor can request a correction or removal at any time through an issue.
  • Automated dependency updates are performed by Dependabot and are not listed as people.

The automatically generated commit graph is also available at github.com/FossMec/foss-mec-library/graphs/contributors. It includes bot accounts; this page is the curated human list.

Get listed

Make one focused contribution and open a pull request:

Include your preferred credit name in the pull request. A maintainer will add you after the merge.

Colophon

About

FOSS MEC Library is a knowledge library from FOSS MEC, the Free and Open Source Software community at Government Model Engineering College, Kochi. It will collect permission-cleared notes, curated open resources and contributor-maintained guides in one permanent, searchable place.

Provenance

The initial Git, GitHub and Linux guides and the contribution checklist were drafted as workshop starting points. They are not student submissions and are not attributed to any student. They are published so that contributors can correct and improve them. Academic sections remain empty until a real, permission-cleared file is accepted through review.

External resources are linked at their canonical source and remain under their own licences.

How it is built

  • Generator: mdBook 0.5.4, pinned in CI.
  • Source: Markdown under src/.
  • Hosting: GitHub Pages, deployed from GitHub Actions on every merge to main.
  • Search: mdBook’s built-in full-text search over rendered Markdown.
  • Backend: none. There is no database, account system or upload service.

Theme

The visual language follows the FOSS MEC website theme:

  • navy #0C2444 and paper #F2F7FC;
  • accent yellow #FFD022 and the logo gradient #FDCE21 → #F69D1D;
  • the official FOSS MEC logo;
  • Martian Mono for display type, Uncut Sans for body text and DM Mono for code.

The theme menu includes Light, Rust, Material, Nord, Everforest, Pine, Coal, Navy and Ayu. Navy is the default theme and the site does not switch automatically; the others are alternate palettes chosen explicitly from the picker. Only theme/foss-mec.css, theme/index.hbs, theme/header.hbs and theme/head.hbs override mdBook’s defaults. Navigation, search, keyboard shortcuts and theme persistence remain mdBook’s built-in behaviour.

Licensing

  • Original documentation and notes: CC BY 4.0, with attribution to the named contributor.
  • Code, scripts and theme overrides: MIT.
  • Fonts: SIL Open Font License 1.1; see FONT-LICENSES.md.
  • External resources: remain under their own licences and are linked, not mirrored.

Contributors

The curated list of people who have contributed to this library is on the Contributors page. It is updated after a contribution is merged and contains no placeholder names.

Contact

For corrections, use the Suggest an edit pencil on any page or open an issue. Do not email attachments of copyrighted material.