Orientation to Computing — I

Unit 5: Version Control, Modern AI Trends & Profile Creation

From your first git push to crafting AI prompts to building a recruiter-ready developer identity — the skills that get you hired.

🏢 Industry-Aligned | 📝 15 MCQs (Bloom's Taxonomy) | 🔬 5 Lab Exercises | 💼 Interview & Career Prep

Section 1

Why This Chapter Changes How You Think About Computing

This is the chapter that directly determines whether you get hired. Not theory exams. Not CGPA alone. Your GitHub profile, your ability to use AI tools intelligently, and your presence on coding platforms — these are what recruiters look at in 2025. At TCS, Infosys, and every startup, the first interview question is increasingly: "Show me your GitHub."

🏢 Industry Snapshot — Who Uses This Knowledge Daily?

Razorpay — Every developer pushes code via Git multiple times daily. Pull requests, code reviews, branch protection, CI/CD pipelines — their entire engineering culture is built on Git. A developer who can't use Git is like a driver who can't steer.

Google / DeepMind — Built Gemini, one of the most powerful AI models. Every Google product — Search, Maps, YouTube, Gmail — uses AI. Understanding prompt engineering and AI capabilities isn't optional for any tech career in 2025.

TCS / Infosys / Wipro — Campus placement processes now include HackerRank tests, GitHub profile reviews, and AI tool awareness questions. 83% of Indian IT companies check candidates' online coding profiles before shortlisting.

🇮🇳 Razorpay🇮🇳 TCS🇮🇳 FlipkartGoogle🇮🇳 CRED🇮🇳 Zerodha

Prerequisite Checklist ✅

✅ Basic computer usage (you've saved files, used a browser)
✅ Awareness of what programming is (from Unit 2)
✅ Access to a computer with internet connection
✅ No prior Git, AI, or platform experience required

Linus Torvalds (creator of Linux) also created Git in 2005 — in just 10 days. He built it because the existing version control tool (BitKeeper) revoked Linux's free license. Today, 100 million+ developers use Git worldwide. The tool born from frustration became the backbone of all modern software development.

Section 2

Learning Outcomes — Bloom's Taxonomy

Bloom's Level	Learning Outcome
L1 — Remember	List the core Git commands (init, add, commit, push, pull, branch, merge) and name 5 types of generative AI tools
L2 — Understand	Explain the Git workflow (working directory → staging → commit → remote) and describe how LLMs generate text using token prediction
L3 — Apply	Create a GitHub repository, push code with proper commit messages, and write effective AI prompts using few-shot and chain-of-thought techniques
L4 — Analyze	Compare ChatGPT vs Claude vs Gemini for specific tasks and differentiate between good and poor prompts with reasoning
L5 — Evaluate	Justify the ethical use of AI in academic work and evaluate when AI-generated code is assistance vs plagiarism
L6 — Create	Design a complete developer profile strategy (GitHub README, HackerRank certifications, LeetCode plan) and build a portfolio on GitHub Pages

Section 3

Concept Explanations

Part A — Version Control with Git & GitHub

3.1 What Is Version Control?

📌 Version Control — Your Code's Time Machine

📌 WHAT IT IS

Version control is a system that records changes to files over time so you can recall specific versions later. Every modification is tracked — who changed what, when, and why. It's not just for code — designers use it for Figma files, writers for manuscripts, and data scientists for datasets.

🌍 REAL-WORLD ANALOGY

Think of Google Docs version history. You can see every edit, who made it, and restore any previous version. Git is the same concept, but infinitely more powerful — designed for code, supporting branches (parallel versions), merges (combining work), and collaboration across teams of thousands.

🏢 INDUSTRY USE

Every software company on Earth uses Git. Flipkart's 2,000+ engineers push code to Git repositories daily. Razorpay's payment gateway codebase has 50,000+ commits. The Linux kernel itself has 1 million+ commits from 20,000+ contributors. Your first day at TCS/Infosys starts with Git training.

⚠️ COMMON MISCONCEPTION

"Git and GitHub are the same thing." No. Git is a local tool installed on your computer — it tracks changes. GitHub is a cloud platform where you store and share Git repositories. You can use Git without GitHub (local only), but not GitHub without Git. Other platforms like GitLab and Bitbucket also host Git repositories.

3.2 Core Git Workflow

Repository (Repo) — A folder tracked by Git. Contains your project files plus a hidden .git directory that stores the entire history. Every Git command operates within a repository.

Git Workflow
┌─────────────────┐    git add     ┌─────────────┐   git commit    ┌────────────────┐
│ WORKING         │──────────────▶│  STAGING     │──────────────▶│  LOCAL REPO     │
│ DIRECTORY       │               │  AREA        │               │  (.git folder)  │
│ (your files)    │◀──────────────│  (index)     │               │  (commit history)│
│                 │   git restore │              │               │                 │
└─────────────────┘               └─────────────┘               └────────┬────────┘
                                                                         │ git push
                                                                         ▼
                                                                ┌────────────────┐
                                                                │  REMOTE REPO   │
                                                                │  (GitHub)      │
                                                                │                │
                                                                └────────────────┘

Every Command You Need — With Examples

Setting Up

Terminal
# Configure your identity (run once after installing Git)
$ git config --global user.name "Rahul Sharma"
$ git config --global user.email "rahul@example.com"

# Initialize a new repository
$ mkdir my-project && cd my-project
$ git init
Initialized empty Git repository in /home/rahul/my-project/.git/

The Daily Workflow: add → commit → push

Terminal
# Check what's changed
$ git status
On branch main
Untracked files:
  index.html
  style.css

# Stage ALL changes (or specific files)
$ git add .                          # Stage everything
$ git add index.html                  # Stage one file

# Commit with a descriptive message
$ git commit -m "Add landing page with responsive navbar"
[main a1b2c3d] Add landing page with responsive navbar
 2 files changed, 145 insertions(+)

# View commit history
$ git log --oneline
a1b2c3d Add landing page with responsive navbar
f4e5d6c Initial commit

# See what exactly changed
$ git diff

# Push to GitHub
$ git push origin main

Branching & Merging — Team Collaboration

Terminal
# Create and switch to a new branch
$ git checkout -b feature/payment-page
Switched to a new branch 'feature/payment-page'

# List all branches (* = current)
$ git branch
  main
* feature/payment-page

# After making changes and committing, merge back
$ git checkout main
$ git merge feature/payment-page
Updating a1b2c3d..e7f8g9h
Fast-forward
 payment.html | 89 +++++++++++++++++++++++++++
 1 file changed, 89 insertions(+)

# Temporarily save work without committing
$ git stash
$ git stash pop        # Restore stashed changes

# Clone an existing repository
$ git clone https://github.com/username/repo.git

.gitignore — What to NEVER Commit

.gitignore
# Never commit these:
node_modules/          # Dependencies (npm install regenerates them)
.env                   # API keys, database passwords — SECURITY RISK
__pycache__/           # Python compiled bytecode
*.pyc                  # Python cache files
.DS_Store              # macOS system files
dist/                  # Build output (can be regenerated)
*.log                  # Log files

"I committed my API keys to GitHub and now someone is using my AWS account." This happens weekly to beginners. NEVER commit .env files, API keys, passwords, or tokens. Use .gitignore to exclude them. If you accidentally commit a secret, rotate the key immediately — Git history preserves every version, even deleted files.

3.3 GitHub — Collaboration & Your Public Resume

Pull Requests — The Industry Workflow

📌 Pull Requests (PRs) — How Teams Ship Code

📌 WHAT IT IS

A Pull Request is a proposal to merge your branch's changes into the main branch. It includes a description, code diff, and space for team members to review, comment, and approve before merging. No code enters production without a PR at any serious company.

⚙️ PR WORKFLOW

PR Workflow
1. Create branch:    git checkout -b feature/upi-integration
2. Write code, commit:  git commit -m "Add UPI payment flow"
3. Push branch:      git push origin feature/upi-integration
4. Open PR on GitHub: Click "Compare & pull request"
5. Team reviews:     Comments, suggestions, approve/request changes
6. CI tests run:     Automated tests verify nothing breaks
7. Merge:            Reviewer approves → Merge into main
8. Deploy:           CI/CD pipeline deploys to production

🏢 INDUSTRY USE

At Razorpay, every PR requires at least 2 approvals from senior engineers. At Flipkart, PRs trigger 500+ automated tests before merge is allowed. At Google, the average PR takes 4 hours from submission to merge. Learning PRs now means you're job-ready on day 1.

GitHub Pages — Free Portfolio Hosting

GitHub Pages lets you deploy a static website for free directly from a repository. Your portfolio website at username.github.io — zero hosting cost, professional URL, deployed with a single git push.

Create your profile README. A special repository named exactly your GitHub username (e.g., rahul-sharma/rahul-sharma) shows a README.md on your profile page. Add: your skills, current learning goals, pinned projects, contribution graph stats, and links to your LinkedIn/portfolio. "Green squares matter to recruiters."

Part B — Modern AI Trends & Tools

3.4 What Is Artificial Intelligence?

📌 AI — Machines That Learn

📌 WHAT IT IS

Artificial Intelligence is the field of computer science focused on building systems that can perform tasks that normally require human intelligence: understanding language, recognizing images, making decisions, and generating content.

⚙️ THREE LEVELS OF AI

Type	What It Can Do	Status	Example
Narrow AI (ANI)	One specific task — better than humans at it	✅ Exists today	Google Maps routing, Swiggy delivery prediction, Aadhaar face matching
General AI (AGI)	Any intellectual task a human can do	⏳ Doesn't exist yet	A system that can write code AND diagnose diseases AND compose music — like a human
Super AI (ASI)	Surpasses all human intelligence combined	❌ Hypothetical	Science fiction territory — no clear path to building this

🏢 REAL-LIFE AI IN INDIA

Application	Company	How AI Is Used
Face Recognition	UIDAI (Aadhaar)	Matches your face against database of 1.4 billion for KYC
Fraud Detection	Google Pay / PhonePe	Detects suspicious UPI transactions in real-time
Delivery Prediction	Swiggy / Zomato	Predicts delivery time based on restaurant prep, traffic, weather
Credit Scoring	CIBIL / Experian	ML models calculate credit score from transaction history
Diagnostic Assist	Practo / Qure.ai	AI reads chest X-rays to detect tuberculosis with 95%+ accuracy
Recommendation	YouTube / Spotify India	"Suggested for you" feeds powered by deep learning models

3.5 Generative AI — Creating, Not Just Analyzing

Generative AI — AI systems that create new content (text, images, code, video, music) rather than just classifying or analyzing existing data. Powered by Large Language Models (LLMs) for text and Diffusion Models for images. The "AI revolution" of 2023-25 is primarily about generative AI.

Text Generation — LLMs

Tool	Company	Strengths	Limitations	Free Tier	Best For
ChatGPT (GPT-4o)	OpenAI	Best all-rounder, largest user base, plugins	Can hallucinate, knowledge cutoff, expensive Pro	GPT-4o-mini free	General tasks, coding, writing
Claude	Anthropic	Longest context (200K tokens), safest, best for long docs	Smaller ecosystem, no image generation	Free tier available	Long documents, analysis, safety
Gemini	Google	Multimodal (text+image+video), Google integration	Newer, smaller plugin ecosystem	Free with Google account	Research, multimodal tasks
Llama 3	Meta	Open-source, can run locally, privacy	Needs powerful hardware locally	Fully free (open source)	Privacy-sensitive, custom deployment
Mistral	Mistral AI	European, efficient, strong coding	Smaller training data than GPT-4	Free API tier	Coding, European data compliance

Image, Video & Research Tools

Category	Tools	What They Do
Image Generation	DALL-E 3, Midjourney, Stable Diffusion, Adobe Firefly	Create images from text descriptions. DALL-E 3 integrates with ChatGPT. Midjourney excels at artistic quality. Stable Diffusion is open-source. Adobe Firefly is copyright-safe (trained on licensed images).
Video Generation	Sora (OpenAI), Runway ML, Pika Labs	Generate short videos from text prompts. Still early-stage (2025) — 5-15 second clips with artifacts. Sora produces photorealistic results but isn't publicly available to all users yet.
Research Tools	Perplexity AI, NotebookLM (Google), JenniAI	Perplexity: AI search with citations. NotebookLM: upload your notes/PDFs, ask questions — perfect for exam prep. JenniAI: academic writing assistant with citation generation.

3.6 Prompt Engineering — The New Programming

📌 Prompt Engineering — Quality In = Quality Out

📌 WHAT IT IS

A prompt is the instruction you give to an AI model. Prompt engineering is the skill of crafting inputs that produce the best possible outputs. It's the difference between getting a useless response and getting a perfectly structured answer that saves you 3 hours of work.

🌍 REAL-WORLD ANALOGY

Ordering food: "Give me something to eat" (bad prompt) vs "I'd like a medium paneer butter masala, less spicy, with 2 garlic naan and a cold lassi" (good prompt). Specificity gets you what you actually want.

5 Side-by-Side Prompt Comparisons

Explain Python

Explain Python's key advantages for a first-year B.Tech student with zero coding experience. Include 3 real-world examples from Indian companies and compare briefly with C.

Write code for sorting

Write a Python function that sorts a list of student dictionaries by marks in descending order using a lambda function. Include input/output examples and time complexity.

Help me with my resume

I'm a 2nd year B.Tech CSE student applying for summer internships at Indian startups. Review this resume bullet point and make it more impactful using the XYZ formula: "Worked on a Python project for data analysis."

What is RAID?

Act as a senior systems administrator at TCS. Explain RAID 5 vs RAID 6 to a junior engineer, using a hospital patient records scenario. Include a usable space calculation for 6 × 4 TB drives.

Debug my code

This Python code throws "IndexError: list index out of range" on line 15. The function is supposed to find the second largest element. Here's the full code: [paste code]. Explain WHY the error occurs and fix it.

Prompting Techniques

Technique	What It Is	Example
Zero-Shot	Ask directly without examples	"Translate 'How are you?' to Hindi"
Few-Shot	Provide 2-3 examples before your actual question	"Convert: cat → बिल्ली, dog → कुत्ता, bird → ?"
Chain-of-Thought	Ask the AI to reason step-by-step	"Calculate RAID 5 usable space for 4 × 2TB. Show each step of your reasoning."
Role Prompting	Assign a persona to the AI	"You are a GATE CS examiner. Create 3 questions on process scheduling."
System Prompt	Set rules for the entire conversation	"You are a friendly Python tutor. Explain concepts using Indian daily-life analogies. Never give answers directly — ask guiding questions."

3.7 Ethical Use of AI

Concern	Issue	Indian Context
Bias	AI models trained on biased data produce biased outputs	An AI hiring tool at an Indian IT company may discriminate against candidates from certain colleges or regions if trained on biased historical hiring data
Deepfakes	AI-generated fake videos/audio of real people	Deepfake videos of Indian politicians have circulated on WhatsApp during elections. Detection tools are improving but lagging behind creation tools
Academic Integrity	When does AI help become cheating?	Using AI to understand a concept = ✅ learning. Submitting AI-generated code as your own assignment = ❌ plagiarism. The line: did you learn, or did you outsource thinking?
Copyright	Who owns AI-generated content?	India's copyright law currently doesn't recognize AI as an author. MEITY is drafting guidelines. For now: AI-generated content has uncertain legal status
Environment	Training large AI models consumes massive energy	Training GPT-4 consumed an estimated 50 GWh — equivalent to 5,000 Indian households' annual electricity usage. Every AI query has a carbon footprint

India's AI regulation landscape (2025): MEITY (Ministry of Electronics and IT) released advisory guidelines requiring AI platforms to label AI-generated content, prevent deepfakes, and ensure outputs don't violate Indian law. India is taking a "pro-innovation, guardrails-based" approach — no blanket AI ban like some countries.

Part C — Profile Creation (Developer Identity)

3.8 Why Your Online Profile IS Your Resume

In 2025, a PDF resume is the minimum. What recruiters actually check: your GitHub (can you actually code?), LinkedIn (professional network), HackerRank/LeetCode (problem-solving ability), and portfolio website (can you build and ship?). 83% of Indian IT recruiters check online profiles before shortlisting candidates.

3.9 Platform-by-Platform Guide

GitHub — Your Code Portfolio

What to Do	Why It Matters	How
Create profile README	First thing visitors see on your profile	Create repo named `your-username`, add README.md with skills, learning goals, stats
Pin 6 best repositories	Showcases your best work immediately	Profile → Customize → Pin repositories
Green contribution graph	"Green squares = active developer" signal to recruiters	Commit regularly — even small changes count
Write good README.md files	Shows communication skills, not just coding	Include: project description, screenshots, tech stack, how to run, future plans

HackerRank — Certification & Hiring Tests

Feature	Details	Career Impact
Skill Certifications	Free certificates: Python, SQL, Java, Problem Solving, REST API	Visible on profile, shareable on LinkedIn. Recruiters filter by certifications.
Company Tests	TCS NQT, Cognizant GenC, Capgemini, DXC — all use HackerRank	Your campus placement test might literally be on HackerRank. Practice here = practice for the real test.
Badges	Gold/Silver/Bronze badges for each skill domain	Gold Python badge = you've solved 70+ Python challenges

LeetCode — The Gold Standard for Coding Interviews

Feature	Details	Strategy
Problem Levels	Easy (acceptance ~60%), Medium (~40%), Hard (~25%)	Start with Easy, move to Medium by Sem 3. Hard for FAANG-level prep.
Company Tags	Problems tagged by company: Amazon, Flipkart, Walmart, Google	Before Flipkart interview, solve all "Flipkart" tagged problems
Curated Lists	"LeetCode 75" (beginner), "Blind 75" (interview essentials), "Neetcode 150"	Start with LeetCode 75 → Blind 75 → Company-specific
Contests	Weekly coding contests (Sunday)	Participate even if you solve 1/4 problems — rating system motivates improvement

Other Platforms

Platform	Best For	Indian Context
GeeksforGeeks	Structured DSA learning, company-specific question banks	Most popular in India. Free content covers 90% of placement topics. GFG Practice = daily DSA habit.
HackerEarth	Competitive programming, hackathons, company challenges	Indian startups (Meesho, Swiggy, Razorpay) host hiring challenges on HackerEarth.
Stack Overflow	Q&A, learning from real-world problems	Reputation = credibility. Even lurking and learning from answers is a skill. Answer 10 good questions = shows expertise.
Figma	UI/UX design, wireframing, prototyping	Browser-based, free tier generous. Career path: UI/UX Designer avg ₹6-12 LPA fresher. Design your portfolio wireframe before coding it.
LinkedIn	Professional networking, job applications	95% of Indian tech recruiters use LinkedIn. Post your projects, certifications, learning journey. Connect with alumni.

Semester-by-Semester Profile Building Strategy

Phase	Focus	Deliverables
Semester 1	GitHub setup + HackerRank Python cert	GitHub profile README, 3 small repos (lab exercises), HackerRank Python Basic cert
Semester 2	LeetCode Easy + GeeksforGeeks	50 LeetCode Easy solved, GFG DSA self-paced practice, SQL HackerRank cert
Year 2	LeetCode Medium + projects + open source	100 LeetCode problems, 2 substantial GitHub projects (with README), first open-source contribution
Placement Year	LinkedIn + portfolio + company-specific prep	Portfolio website on GitHub Pages, LinkedIn optimized, Blind 75 complete, company-tagged problems

AI Coding Assistants — GitHub Copilot, Cursor, Codeium, and Amazon CodeWhisperer can auto-complete code as you type. Ethical use in assignments: use them to LEARN (understand the suggestions), not to CHEAT (blindly submit). Companies increasingly expect you to know how to use AI assistants productively — it's a skill, not a shortcut.

Section 4

Industry Problems

🏢 Industry Problem #1 — Empty GitHub Profile, 2 Weeks Before Placements

Company Type: Engineering college (Tier-2 city, campus placements starting)

Scenario: Priya is a 3rd-year B.Tech CSE student. She's good at DSA (solved 200+ LeetCode) but her GitHub is completely empty. Campus placements start in 14 days. Recruiters from TCS, Infosys, and two startups will check GitHub profiles.

Your Task: Create a 14-day action plan to build a credible GitHub profile from scratch.

💡 Solution: 14-Day GitHub Rescue Plan

Day	Action	Deliverable
1	Setup: Create GitHub account, install Git, configure user	Profile photo, bio, profile README with skills
2-3	Push existing DSA solutions (organized by topic)	Repo: `dsa-solutions` with folder structure (arrays/, trees/, dp/)
4-5	Build a personal portfolio website (HTML/CSS/JS)	Repo: `portfolio`, deployed on GitHub Pages
6-8	Build a full-stack mini project (To-Do app / Weather dashboard)	Repo with README: screenshots, tech stack, how to run
9-10	Add a Python/Java project (e.g., file organizer, quiz app)	Repo with clean code, comments, README
11-12	Earn HackerRank certifications (Python Basic + SQL Basic)	Certificates linked on GitHub profile
13	Polish: Pin 6 repos, add contribution graph, write consistent commit messages	Polished profile page
14	LinkedIn post: "Here's what I built this month" — share GitHub link	Public visibility, recruiter reach

Industry Insight: Recruiters spend 30 seconds on a profile. They check: (1) Is the contribution graph green? (2) Are pinned repos real projects (not just forked repos)? (3) Do READMEs explain the project? A polished profile built in 14 days beats an empty profile with 4 years of enrollment.

🏢 Industry Problem #2 — AI Tool Comparison for Academic Research

Company Type: University research lab (IIT Hyderabad, NLP group)

Scenario: A professor asks your group to evaluate AI tools for literature review in a research paper on "Machine Learning Applications in Indian Agriculture." You must compare 3 tools and recommend the best approach.

Your Task: Use Perplexity AI, ChatGPT, and NotebookLM for the same research question. Compare outputs.

💡 Solution Walkthrough

Criterion	Perplexity AI	ChatGPT (GPT-4o)	NotebookLM
Citation quality	🟢 Cites real URLs, verifiable	🔴 Often hallucinates citations	🟢 Cites from YOUR uploaded papers
Recency	🟢 Real-time web search	🟡 Knowledge cutoff (training data)	🟡 Limited to uploaded documents
Depth	🟡 Broad overview	🟢 Deep analysis with prompting	🟢 Deep analysis of specific papers
Best for	Finding papers, initial literature survey	Synthesizing ideas, drafting sections	Deeply understanding specific papers

Recommended workflow: Start with Perplexity (find relevant papers with real citations) → Upload papers to NotebookLM (deep understanding + Q&A) → Use ChatGPT (synthesize themes, draft initial sections — then rewrite in your own words).

Ethics note: Always verify AI citations independently. Never submit AI-generated text as your own. Use AI as a research accelerator, not a ghostwriter.

🏢 Industry Problem #3 — Setting Up Git Workflow for a Startup Team

Company Type: Early-stage edtech startup (5 developers, Bangalore)

Scenario: Your 5-person team has been pushing code directly to main branch. Last week, a junior developer accidentally broke the production website by pushing untested code. The CTO asks you to set up a proper Git workflow.

Your Task: Design a branching strategy and PR workflow for the team.

💡 Solution: Git Flow for Small Teams

Branching Strategy
main ────────●────────●────────●────────●──── (production - always stable)
              \      /          \      /
develop ───●───●──●──────●───●───●──●──── (integration branch)
            \  /          \  /
feature/ ──●──          ──●──               (individual feature branches)

Rules:

Never push directly to main — enable branch protection on GitHub
Create feature branches: git checkout -b feature/user-dashboard
Open PR to merge into develop — requires 1 code review approval
Weekly: merge develop → main via PR with full team review
.gitignore: exclude node_modules/, .env, build artifacts
Commit message format: "feat: add user login", "fix: resolve payment timeout", "docs: update README"

Section 5

Lab Exercises

Exercise 1: Your First GitHub Repository

⏱ 40 minutes🟢 Beginner

Objective: Create a GitHub account, initialize a repo, and push your first commit.

Task:

Create a GitHub account at github.com (use a professional username — not coolboy2005)
Install Git on your machine. Verify: git --version
Configure: git config --global user.name "Your Name" and user.email
Create a folder hello-world, run git init
Create README.md with your name and a one-line project description
Run: git add . → git commit -m "Initial commit: add README"
Create a repo on GitHub, link it: git remote add origin <url>
Push: git push -u origin main

Expected Output: A live GitHub repository at github.com/yourusername/hello-world

Extension: Add a .gitignore file and make a second commit: "feat: add .gitignore for Python projects"

Exercise 2: Create Your GitHub Profile README

⏱ 35 minutes🟡 Intermediate

Objective: Build a professional GitHub profile page using a special README repository.

Task:

Create a new repo with the same name as your GitHub username
Add a README.md with: greeting banner, about you section, current learning (skills you're building), tech stack (icons/badges), GitHub stats widget, and links (LinkedIn, portfolio)
Use Markdown formatting: headers, bullet points, badges (shields.io), and embedded images
Push and verify it appears on your profile page

Expected Output: A polished profile README visible at github.com/yourusername

Hints: Search "awesome GitHub profile README" for inspiration. Use github-readme-stats for auto-generated stats cards.

Exercise 3: Earn Your First HackerRank Certification

⏱ 60 minutes🟡 Intermediate

Objective: Complete the HackerRank Python (Basic) certification test.

Task:

Create a HackerRank account at hackerrank.com
Practice: Solve 10 Python challenges in the "Python" domain (start with Easy)
Take the Python (Basic) certification test (free, 90 minutes, 2 questions)
If you pass, download the certificate and add it to your LinkedIn
Bonus: Also attempt the SQL (Basic) certification

Expected Output: HackerRank Python Basic certificate (shareable link)

Hints: The test covers: string manipulation, list comprehension, sets, tuples, and basic OOP. Practice these topics before attempting.

Exercise 4: AI Prompt Engineering Challenge

⏱ 45 minutes🟢 Beginner

Objective: Write the same task as 5 different prompts and compare AI output quality.

Task:

Choose a creative task: "Explain the concept of recursion to a first-year student"
Write 5 prompts of increasing quality: (a) Basic one-liner, (b) With context about audience, (c) With an analogy request, (d) With role prompting, (e) With few-shot examples + constraints
Submit each to the same AI tool (ChatGPT, Claude, or Gemini)
Create a comparison table: Prompt text | Output quality (1-5) | Length | Accuracy | Usefulness
Write a 200-word reflection on how prompt quality affects output quality

Expected Output: Comparison table with 5 prompts + outputs + quality ratings + reflection

Exercise 5: Deploy a Portfolio Website on GitHub Pages

⏱ 90 minutes🔴 Advanced

Objective: Build and deploy a personal portfolio website accessible at yourusername.github.io

Task:

Create a new repo named yourusername.github.io
Build a portfolio with: About section, Skills, Projects (3+), Education, Contact
Use HTML, CSS, and optional JavaScript. Make it responsive.
Push to GitHub and enable GitHub Pages (Settings → Pages → Source: main branch)
Verify your site is live at https://yourusername.github.io

Expected Output: A live, professional portfolio website

Extension: Add Google Analytics to track visitors. Add a custom domain (₹500/year from GoDaddy/Namecheap).

Section 6

MCQ Assessment Bank — 15 Questions

Hover over any question to reveal the answer.

What does git add . do?

Commits all changes
Stages all modified and new files in the current directory for the next commit
Pushes code to GitHub
Creates a new branch

✅ B. git add . moves all changes (new files, modified files) from the working directory to the staging area (index). It does NOT commit — that requires git commit. The . means "current directory and everything inside it."
🏢 Every developer runs this command 10+ times daily.

L1 — RememberGit

Which of the following is an example of Narrow AI (ANI)?

A robot that can cook, drive, write poetry, and diagnose diseases
Google Maps calculating the fastest route based on real-time traffic
A computer that is smarter than all humans combined
An AI that passed every university exam in every subject

✅ B. Narrow AI excels at ONE specific task. Google Maps uses ML to predict traffic and optimize routes — but it can't write an essay or diagnose a disease. AGI (option A, D) and ASI (option C) don't exist yet.
🏢 All commercial AI in 2025 is narrow AI: Swiggy delivery, Google Pay fraud detection, YouTube recommendations.

L1 — RememberAI

What should NEVER be committed to a Git repository?

README.md
Source code files (.py, .js, .java)
.env files containing API keys and database passwords
Configuration files like package.json

✅ C. .env files contain secrets (API keys, passwords, tokens). Committing them to a public (or even private) repository is a serious security risk. Use .gitignore to exclude them. If accidentally committed, rotate all keys immediately — Git history preserves everything.
🏢 AWS automatically scans GitHub for leaked AWS keys and disables compromised accounts. This happens thousands of times daily.

L1 — RememberSecurity

Why is the staging area (index) a useful concept in Git?

It makes Git slower and more complex
It allows you to selectively choose which changes to include in a commit, enabling clean, focused commit history
It's required by GitHub but not by Git
It automatically writes commit messages

✅ B. The staging area lets you craft precise commits. If you changed 5 files but only 2 are related to "fix login bug", you stage only those 2: git add login.py auth.py. This creates a clean, reviewable history where each commit represents one logical change.
🏢 At Flipkart, messy commits are rejected in code review. Clean commit history is a professional expectation.

L2 — UnderstandGit

What makes Generative AI different from traditional AI?

Generative AI is faster
Generative AI creates NEW content (text, images, code) while traditional AI classifies, predicts, or analyzes existing data
Traditional AI doesn't use neural networks
Generative AI doesn't need training data

✅ B. Traditional AI: spam filter (classifies email), recommendation engine (predicts preference). Generative AI: ChatGPT (creates new text), DALL-E (creates new images), Copilot (creates new code). The key word is creates vs classifies.
🏢 Companies like CRED and Swiggy use traditional AI for recommendations and generative AI for marketing copy and customer support chatbots.

L2 — UnderstandAI

Why does a "few-shot" prompt produce better results than a "zero-shot" prompt?

Few-shot prompts use more computing power
Providing examples helps the AI understand the exact format, style, and quality expected in the output
Zero-shot prompts are always wrong
Few-shot prompts bypass the AI's content filters

✅ B. Examples demonstrate the pattern you want. "Translate: cat → बिल्ली, dog → कुत्ता, bird → ?" gives the AI a clear format to follow. Without examples (zero-shot), the AI must guess your intent, format, and level of detail — leading to inconsistent results.
🏢 Prompt engineering is now a job title — companies hire "AI prompt engineers" at ₹15-30 LPA to optimize AI tool usage.

L2 — UnderstandPrompts

You've made changes to 3 files but want to commit only payment.py. Which sequence is correct?

git commit -m "fix payment"
git add payment.py then git commit -m "fix: resolve payment timeout bug"
git push payment.py
git add . then git commit -m "fix payment"

✅ B. Stage only the specific file (git add payment.py), then commit with a descriptive message. Option A skips staging (only works with -a flag for tracked files). Option C: push sends to remote, not related to selective staging. Option D stages ALL files including the 2 you don't want in this commit.
🏢 Clean, atomic commits are a code review best practice at every company.

L3 — ApplyGit

Which prompt technique is MOST effective for getting an AI to solve a complex math problem step-by-step?

Zero-shot: "Solve this problem"
Role prompting: "You are a math teacher"
Chain-of-thought: "Solve this step by step, showing all intermediate calculations and reasoning"
Few-shot: "Here's an example of a solved problem"

✅ C. Chain-of-thought — Asking the AI to "think step by step" forces it to show intermediate reasoning, significantly improving accuracy on math, logic, and multi-step problems. Research shows CoT prompting improves GPT-4's math accuracy from 57% to 87% on complex problems.
🏢 Chain-of-thought is the most impactful prompting technique for technical and analytical tasks.

L3 — ApplyPrompts

A student wants to showcase their Python skills to recruiters. Which combination of actions is MOST effective?

Only solve 500 LeetCode problems
Only build a beautiful portfolio website
Push 3 well-documented Python projects to GitHub + earn HackerRank Python certification + solve 50 LeetCode Easy problems
Only create a LinkedIn profile

✅ C. A balanced approach: GitHub projects prove you can BUILD, HackerRank certification proves you can SOLVE, LeetCode proves you can THINK algorithmically. No single platform is enough. Recruiters check GitHub (can they code?), HackerRank (do they have certifications?), and LeetCode (can they handle technical interviews?).
🏢 This is the exact profile-building strategy recommended by TCS iON and Infosys InfyTQ career guides.

L3 — ApplyProfiles

Q10

Two AI tools are asked: "Write a research summary on quantum computing." Tool A gives a fluent summary but cites 3 papers that don't exist. Tool B gives a shorter summary but every citation is verifiable. Which tool is more reliable for academic work and why?

Tool A — longer output means better quality
Tool B — verifiable citations are essential for academic integrity; hallucinated citations undermine research credibility entirely
Both are equally reliable
Neither — AI should never be used for research

✅ B. AI "hallucination" (generating plausible-sounding but false information) is a critical problem. In academic work, a single fake citation can invalidate your entire paper. Tool B (like Perplexity AI) with verifiable sources is far more reliable. Always verify AI citations independently. This is why NotebookLM (grounded in YOUR uploaded documents) is preferred for research.
🏢 IITs and NITs are updating academic integrity policies to address AI hallucination in student submissions.

L4 — AnalyzeAI Ethics

Q11

A team uses Git but everyone pushes directly to main. Last week, a junior developer broke production. What Git workflow practice would have PREVENTED this?

Using a bigger monitor
Branch protection rules requiring PR reviews and CI tests before merging to main
Deleting Git history weekly
Giving only the team lead push access

✅ B. Branch protection rules on GitHub prevent direct pushes to main. They require: (1) code changes go through a Pull Request, (2) at least 1 reviewer approves, (3) CI tests pass. This means broken code is caught before it reaches production. Option D creates a bottleneck — the team lead becomes a single point of failure.
🏢 Every serious engineering team (Razorpay, Zerodha, Flipkart) uses branch protection. It's standard DevOps practice.

L4 — AnalyzeGit Workflow

Q12

A student uses ChatGPT to generate their entire programming assignment and submits it as their own work. Is this ethical?

Yes — AI is just another tool like a calculator
No — submitting AI-generated work as your own is plagiarism; the purpose of assignments is to develop YOUR problem-solving skills, which is bypassed when AI does the thinking
Yes — if the professor didn't explicitly ban AI
Depends on whether the code is correct

✅ B. The purpose of assignments is learning through practice. Using AI to generate complete solutions bypasses the learning process — you haven't developed the skill. Ethical AI use: understand concepts WITH AI help, then write code yourself. Unethical: copy-paste AI output. Analogy: using a calculator to check your mental math = fine. Using it instead of learning multiplication = defeats the purpose.
🏢 IITs, NITs, and UGC are implementing AI detection and updated academic integrity policies. Companies test your skills in live coding interviews — AI-generated assignments won't help you there.

L5 — EvaluateAI Ethics

Q13

A company must choose between ChatGPT (paid) and Llama 3 (open-source, self-hosted) for an internal customer support chatbot handling sensitive financial data. Which is better and why?

ChatGPT — more powerful model
Llama 3 self-hosted — sensitive financial data should not be sent to external APIs; self-hosting gives complete control over data privacy, compliance (RBI guidelines), and customization
Neither — AI shouldn't handle financial data
Both simultaneously for redundancy

✅ B. For financial data: (1) Sending customer data to OpenAI's API may violate RBI data localization guidelines. (2) Self-hosting Llama 3 keeps data within the company's infrastructure. (3) Open-source allows fine-tuning on domain-specific data. (4) No per-query API costs at scale. ChatGPT is more powerful out-of-the-box, but data sovereignty and compliance take priority for financial services.
🏢 Indian banks and NBFCs (Razorpay, PhonePe) increasingly self-host AI models due to RBI data localization requirements.

L5 — EvaluateAI Deployment

Q14

Design a 3-month GitHub contribution plan for a first-year B.Tech student with ZERO coding experience, targeting campus placements.

Only fork popular repos to show activity
Month 1: Learn Python basics + push daily practice exercises. Month 2: Build 2 mini-projects (calculator, quiz app) with READMEs. Month 3: Create portfolio website + earn HackerRank cert + write profile README
Copy-paste code from tutorials without modification
Wait until 3rd year to start

✅ B. A progressive plan: foundational skills (Month 1) → applied projects (Month 2) → public identity (Month 3). Forking repos without contribution (A) shows no real skill. Copy-pasting (C) doesn't demonstrate understanding. Waiting (D) wastes 2 years of potential profile building. Consistency matters more than volume — 1 commit per day beats 50 commits in one day.
🏢 Recruiters check commit frequency and consistency. A 90-day streak of daily commits signals discipline and passion.

L6 — CreateStrategy

Q15

Design a prompt for an AI to generate a study plan for GATE CS preparation, covering all subjects with time allocation. Which prompt structure would produce the BEST output?

"Help me with GATE"
"You are a GATE CS topper and coaching mentor. Create a 6-month study plan for a working professional preparing for GATE 2026 CS. Include: subject-wise weekly schedule, recommended resources (free + paid), past year question practice strategy, and mock test timeline. Prioritize subjects by weightage. Format as a weekly table."
"What topics come in GATE?"
"Make a GATE plan for me"

✅ B. This prompt uses multiple techniques: (1) Role prompting ("You are a GATE topper"), (2) Specific constraints (6-month, working professional, 2026), (3) Detailed output requirements (weekly schedule, resources, mock tests), (4) Format specification (weekly table), (5) Prioritization instruction (by weightage). Options A, C, D are vague and will produce generic, unhelpful responses.
🏢 This level of prompt crafting is what makes AI tools 10× more useful — and it's a skill employers increasingly value.

L6 — CreatePrompts

Section 7

Chapter Summary

VERSION CONTROL, AI & PROFILES │ ├── PART A: GIT & GITHUB │ ├── Version Control — tracking changes over time │ ├── Git vs GitHub — local tool vs cloud platform │ ├── Core Workflow │ │ ├── git init → git add → git commit → git push │ │ ├── git branch → git checkout → git merge │ │ ├── git clone → git pull → git stash │ │ └── .gitignore — exclude secrets & build files │ ├── GitHub Features │ │ ├── Pull Requests — team code review workflow │ │ ├── Branch Protection — prevent direct pushes to main │ │ ├── GitHub Pages — free static site hosting │ │ └── Profile README — your public developer identity │ └── Industry Standard — 100M+ devs, required at every company │ ├── PART B: AI TRENDS │ ├── AI Types: Narrow (exists) → General → Super (hypothetical) │ ├── Indian AI: Aadhaar, Google Pay fraud, Swiggy, CIBIL │ ├── Generative AI │ │ ├── Text: ChatGPT, Claude, Gemini, Llama, Mistral │ │ ├── Image: DALL-E 3, Midjourney, Stable Diffusion │ │ ├── Video: Sora, Runway ML, Pika Labs │ │ └── Research: Perplexity, NotebookLM, JenniAI │ ├── Prompt Engineering │ │ ├── Zero-shot → Few-shot → Chain-of-thought │ │ ├── Role prompting → System prompts │ │ └── Quality of input = quality of output │ └── Ethics: Bias, deepfakes, academic integrity, copyright │ └── PART C: DEVELOPER PROFILES ├── GitHub — code portfolio, green squares, README ├── HackerRank — certifications (Python, SQL, Java) ├── LeetCode — interview prep (LeetCode 75, Blind 75) ├── GeeksforGeeks — DSA learning path ├── HackerEarth — hackathons, company challenges ├── Stack Overflow — reputation, Q&A credibility ├── Figma — UI/UX design skills ├── LinkedIn — professional networking 🆕 └── Strategy: Sem1 (GitHub) → Sem2 (LeetCode) → Year2 (projects) → Placement (polish)

🎯 3 Things Industry Expects You to Know

Git workflow — init, add, commit, push, branch, merge, PR. You WILL use this on day 1 at any tech job.
AI literacy — Know what generative AI can and can't do. Write effective prompts. Understand ethical boundaries.
Online presence — GitHub with real projects, HackerRank certifications, and a LeetCode profile demonstrate skills that a resume PDF cannot.

📋 Git Quick Reference

SETUP:       git config --global user.name "Name"
INIT:        git init
STATUS:      git status
STAGE:       git add .  |  git add file.py
COMMIT:      git commit -m "descriptive message"
LOG:         git log --oneline
DIFF:        git diff
BRANCH:      git branch  |  git checkout -b feature/x
MERGE:       git checkout main && git merge feature/x
STASH:       git stash  |  git stash pop
REMOTE:      git remote add origin <url>
PUSH:        git push origin main
PULL:        git pull origin main
CLONE:       git clone <url>
IGNORE:      echo "node_modules/" >> .gitignore

COMMIT MESSAGE FORMAT:
  feat:   new feature        fix:    bug fix
  docs:   documentation      style:  formatting
  refactor: code restructure test:   tests

🎓 Certification Roadmap

GitHub Foundations Certification — GitHub's official cert covering Git, repos, PRs, Actions. Validates your version control skills. ~$99 exam.
HackerRank Certifications — Free: Python (Basic/Intermediate), SQL (Basic/Intermediate/Advanced), Java, Problem Solving, REST API. Add to LinkedIn immediately.
Google AI Essentials (Coursera) — Free to audit. Covers responsible AI use and prompt engineering. Google-branded certificate.

Section 8

Interview & Career Preparation

Q1: What is Git and why is it used?

Model Answer: Git is a distributed version control system that tracks changes to files over time. It lets developers: (1) maintain a complete history of all changes, (2) revert to any previous version, (3) work on parallel branches without conflicts, (4) collaborate with teams by merging changes. It's used because modern software development is collaborative — multiple developers work on the same codebase simultaneously. Without Git, code management would be chaotic and error-prone.

Q2: What is the difference between git add and git commit?

Model Answer: git add moves changes from the working directory to the staging area (index) — selecting which changes to include. git commit saves the staged changes as a permanent snapshot in the repository history with a descriptive message. Think of it as: add = putting items in a shopping cart, commit = checking out and paying. You can add selectively, then commit once with a clear description of what changed.

Q3: What is a Pull Request?

Model Answer: A Pull Request (PR) is a proposal to merge changes from one branch into another (typically feature branch → main). It includes: the code diff, a description of changes, and a space for team review. Before merging, teammates review the code, suggest improvements, and verify it passes automated tests. PRs are the standard collaboration workflow in industry — no code enters production without review.

Q4: What is .gitignore and why is it important?

Model Answer: .gitignore is a file that tells Git which files/directories to exclude from tracking. Important exclusions: .env (API keys, passwords — security risk), node_modules/ (dependencies — regenerated by npm install), __pycache__/ (Python cache), build outputs. Without .gitignore, sensitive credentials could be exposed publicly, and repositories would be bloated with unnecessary files.

Q5: What is Generative AI? Give examples.

Model Answer: Generative AI creates NEW content rather than just analyzing existing data. Text generation: ChatGPT, Claude, Gemini — generate human-like text, code, essays. Image generation: DALL-E 3, Midjourney — create images from text descriptions. Video: Sora by OpenAI. Code: GitHub Copilot. Key technology: Large Language Models (LLMs) for text, Diffusion Models for images. Important limitation: AI can "hallucinate" — generating plausible-sounding but factually incorrect information.

Q6: What is prompt engineering?

Model Answer: Prompt engineering is the skill of crafting AI inputs to get optimal outputs. Key techniques: (1) Be specific — include context, constraints, format. (2) Few-shot — provide examples. (3) Chain-of-thought — ask for step-by-step reasoning. (4) Role prompting — assign a persona. The quality of AI output directly depends on input quality. It's increasingly considered a valuable professional skill — some companies have dedicated prompt engineer roles.

Q7: How do you resolve a merge conflict in Git?

Model Answer: A merge conflict occurs when two branches modify the same lines of the same file. Git marks the conflict with <<<<<<<, =======, >>>>>>> markers. To resolve: (1) Open the conflicted file, (2) Identify both versions between the markers, (3) Manually choose the correct code (or combine both), (4) Remove the conflict markers, (5) git add the resolved file, (6) git commit. Communication with the other developer is key to choosing the right resolution.

Q8: What coding platforms do you use and what's your strategy?

Model Answer: I use a multi-platform approach: (1) GitHub — for project portfolios and open-source contributions. (2) LeetCode — for algorithmic problem-solving (currently working through LeetCode 75 list). (3) HackerRank — earned Python Basic and SQL Basic certifications. (4) GeeksforGeeks — for structured DSA learning. My strategy: daily LeetCode practice (1 problem/day), weekly project commits on GitHub, and monthly certification targets on HackerRank.

Q9: What are the ethical concerns with AI?

Model Answer: Key concerns: (1) Bias — AI trained on biased data produces biased outputs (e.g., discriminatory hiring tools). (2) Hallucination — AI generates false but plausible information (dangerous for medical, legal, academic use). (3) Deepfakes — realistic fake videos/audio for misinformation. (4) Privacy — AI systems process vast amounts of personal data. (5) Job displacement — automation of routine cognitive tasks. (6) Environmental impact — training large models consumes significant energy. India's MEITY guidelines require AI labeling and deepfake prevention.

Q10: What is GitHub Pages and how would you use it?

Model Answer: GitHub Pages is a free static website hosting service directly from a GitHub repository. Create a repo named username.github.io, push HTML/CSS/JS files, and your site is live at https://username.github.io. I use it to host my portfolio website — showcasing projects, skills, and contact information. It's deployed via git push — no separate hosting needed. Perfect for developer portfolios because recruiters see both your website AND the code behind it in the same repository.

💼 "Day 1 at a Tech Job" — What You'll Use

Day 1 at TCS/Infosys/any startup: (1) You'll git clone the company's codebase. (2) You'll create a feature branch. (3) You'll make changes, commit, and open a Pull Request. (4) You'll use AI tools (Copilot, ChatGPT) to understand unfamiliar code. (5) Your manager will check your GitHub and say "Good, you've already used Git." This chapter IS your first week at work.

📂 GitHub Portfolio Tip

After this chapter, your GitHub should have: (1) A polished profile README. (2) A hello-world repo (Lab Exercise 1). (3) A portfolio website deployed on GitHub Pages (Lab Exercise 5). (4) HackerRank certifications linked. These 4 things alone put you ahead of 90% of first-year students.