Pre-Programming Training Plan

Objective:
Equip individuals with essential computing, development, collaboration, and workplace
readiness skills before they begin language-specific training or professional internships. This
foundational program ensures participants are well-prepared to understand core technical
concepts, development workflows, and professional practices.

Training Topics:
1.​ Computer Fundamentals
2.​ Networking Basics
3.​ Software Development Fundamentals
4.​ Web and API Fundamentals
5.​ Database Basics (SQL & NoSQL)
6.​ Testing and Debugging Fundamentals
7.​ Version Control (Git & GitHub Basics)
8.​ Command Line Basics (Ubuntu Focused)
9.​ Introduction to IDEs and Developer Tools
10.​Technical Documentation and Communication
11.​Soft Skills and Workplace Etiquette

1. Computer Fundamentals

Objective:

To provide a foundational understanding of how computers work, including their components,

architecture, memory, and how data is processed and stored.

Detailed Content
●​ What is a Computer?​
Definition, importance in modern life, and general use-cases.
 ●​ Types of Computers:​
Desktops, Laptops, Servers, Embedded Systems – use-case comparisons.

Core Components:

●​ CPU (Central Processing Unit): The “brain” of the computer

●​ RAM (Random Access Memory): Temporary memory used during processing
●​ ROM (Read-Only Memory): Stores essential firmware
●​ Storage Devices: HDD vs SSD (speed, durability, use cases)
●​ Input/Output Devices: Mouse, Keyboard, Monitor, Printer, etc.

Number Systems (Basics):

●​ Binary vs Decimal, converting between them, and relevance in computing​

CPU Architecture Overview:

●​ ALU (Arithmetic Logic Unit), Control Unit, Registers, Instruction cycle (Fetch → Decode
→ Execute)​

System Bus:
●​ Data Bus, Address Bus, Control Bus – their role in data movement​

Memory Hierarchy:
●​ Registers, Cache, RAM, SSD – comparison of speed vs capacity​

Storage vs Memory:
●​ RAM vs HDD/SSD – understanding temporary vs persistent data​

Introduction to Operating Systems:

●​ Purpose of an OS (interface between user and hardware)
●​ Types: Single-user, Multi-user, Real-time, Distributed
●​ Examples: Windows, Linux, macOS
●​ Functions: Process Management, Memory Management, File System Handling
Learning Outcomes:

By the end of this section, learners should be able to:

●​ Identify major components of a computer system.

●​ Differentiate between memory types and data storage methods
●​ Explain how data flows inside a computer
●​ Understand the role of an operating system and its core responsibilities

2. Networking Basics:

Objective:

Equip freshers with foundational knowledge of computer networks, internet communication,

protocols, and how systems communicate in a software-driven environment.

Detailed Content
●​ What is a Computer?​
Definition, importance in modern life, and general use-cases.
●​ Types of Computers:​
Desktops, Laptops, Servers, Embedded Systems – use-case comparisons.

Introduction to Networking:

Goals: Understand what networking is and why it matters in software systems.

●​ What is networking?
○​ Definition and analogy (e.g., post office, road system)
○​ Relevance in web/mobile/software development
●​ Types of networks:
○​ LAN (home, office), WAN (internet), PAN (Bluetooth), MAN (city-level)
●​ Network devices:
○​ Router (directs traffic), Switch (connects devices in LAN), Hub (basic switch),
Modem (connects to ISP), Access Point (extends wireless range)
 ●​ IP Addressing:
○​ IPv4 (e.g., 192.168.0.1) vs IPv6 (e.g., 2001:0db8::1)
○​ MAC Address – unique identifier for devices.
●​ Public vs Private IP:
○​ Examples and use in home/enterprise environments

OSI & TCP/IP Models:

Goals: Understand how data travels through different layers in a network.

●​ OSI 7-Layer Model (conceptual overview):

○​ Physical – cables, signals
○​ Data Link – MAC addresses, switches
○​ Network – IP addressing, routing
○​ Transport – TCP/UDP, error checking
○​ Session – manages sessions between apps
○​ Presentation – data formatting, encryption
○​ Application – interface for the end-user (HTTP, FTP)
●​ TCP/IP Model (practical model used):
○​ Application, Transport, Internet, Link layers
●​ Real-world Examples:
○​ Opening a web page: how layers are used in browser-to-server communication
●​ Packet structure (basic):
○​ Header + Payload
○​ IP header and TCP/UDP headers (conceptually)

Common Protocols & Communication:

Goals: Learn about protocols used daily in development and communication.

●​ HTTP vs HTTPS:
○​ Plain text vs encrypted communication

●​ Common Protocols:
○​ FTP – file transfer
○​ TCP – reliable transmission​
 ○​ UDP – faster, no error checking (e.g., video stream)
○​ SMTP – email sending
○​ DNS – domain name resolution
○​ DHCP – auto-assigning IPs
●​ Common Ports:
○​ HTTP (80), HTTPS (443), FTP (21), SSH (22), DNS (53)

●​ Client-Server Architecture:
○​ Request-response cycle
○​ Role of frontend and backend
●​ Basic Tools:
○​ ping – test connectivity
○​ traceroute – trace network path
​
​

Network Addressing and Tools

Goals: Explore addressing schemes and hands-on tools for network diagnostics.

●​ IP Addressing:
○​ Static (manual) vs Dynamic (DHCP-based)

●​ Subnetting (conceptual only):

○​ Why subnetting is used in large networks
●​ DNS – How domain names resolve:
○​ DNS resolver → root server → TLD → authoritative server

●​ Common Commands:
○​ ping – checks reachability
○​ tracert/traceroute – route tracing
○​ ipconfig / ifconfig – view IP configuration
○​ nslookup – domain resolution info

●​ Firewalls & NAT:

○​ Basics of network security
○​ Role of NAT in IP sharing within LAN

Recap and Application

Goals: Reinforce concepts through real-world scenarios and teamwork.

●​ Activity - Trace the journey of a browser request to www.google.com

○​ DNS lookup → TCP handshake → HTTP request → Response → Render
 ●​ Group Quiz/Discussion:
○​ Match protocols to scenarios (e.g., “email sending” → SMTP)

●​ Visual Activity:
○​ Design a simple home/office network diagram

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand how devices communicate over a network

●​ Recognize the role of protocols like HTTP, TCP, and DNS in daily applications
●​ Use basic networking commands and troubleshoot simple network issues
●​ Grasp the concepts behind IP addressing, ports, and data routing

3. Software Development Fundamentals:

Objective:

Provide foundational knowledge of how software is built - from logic, programming, debugging,
and collaboration - preparing freshers to start writing real code with good practices.

Detailed Content

What is Software Development?

●​ Definition & Importance:

What is software? Types of software – system software, application software,
web/mobile/desktop apps.

●​ Software Development Life Cycle (SDLC):

Phases: Requirement → Design → Development → Testing → Deployment →
Maintenance
 Models: Waterfall vs Agile (basic overview)

●​ Programming Languages:
High-level vs Low-level, Compiled vs Interpreted (with examples: C, Java, Python, JS)

●​ Roles in Development:
Developer, Tester, DevOps, Product Manager, Designer – how they collaborate

●​ Real-World Example:
How a simple login feature is developed and tested.

Debugging, Code Management & Version Control (Intro)

●​ What is a Bug?
Common types – syntax error, runtime error, logic error

●​ Debugging Skills
Print statements, debugging tools (e.g., browser dev tools, IDE breakpoints)

●​ Intro to Git & GitHub

What is Git? Why version control is essential
Basic Git commands: git init, git status, git add, git commit, git push
Collaboration via GitHub

●​ Activity:
Simulate coding, introducing a bug and finding/fixing it​

From Code to Working Software

●​ How Code Becomes Software

Compilation, interpretation, execution
Real example: writing code → saving → running in terminal/browser

●​ Build Tools and Package Managers

npm (Node.js), pip (Python) – concept only
 ●​ APIs and Reusability
What are APIs? How software talks to software

●​ Activity:
Simulate coding, introducing a bug and finding/fixing it

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand how software is developed from idea to execution

●​ Grasp how developers collaborate and manage code using tools like Git
●​ Be ready to dive into specific languages or frameworks confidently

4. Web and API Fundamentals:

Objective:

Introduce freshers to how websites and web applications work, the basics of frontend vs
backend, how browsers communicate with servers, and how APIs enable software integration
and data sharing.

Detailed Content

Introduction to the Web

●​ What is the World Wide Web (WWW)?

○​ History and evolution
○​ Difference between the internet and the web
●​ How browsers, servers, and the internet interact
○​ Request-response cycle
○​ Role of DNS, IP, and HTTP
 ●​ Website vs Web Application
○​ Informational sites vs interactive applications
○​ Real-world examples (e.g., Wikipedia vs Gmail)
●​ Static vs Dynamic Websites
○​ How HTML pages are served as-is vs dynamic pages that involve server
processing
○​ Role of scripting languages and databases
●​ Web Addresses: Domain Names, URLs, and IPs
○​ Structure of a URL
○​ Domain name system (DNS) in simple terms
○​ Mapping of domains to IPs
●​ Introduction to HTTP/HTTPS
○​ What is a protocol?
○​ Difference between HTTP and HTTPS
○​ Status codes (200, 404, 500 – basic overview)
●​ Client-Side vs Server-Side
○​ Code that runs in the browser vs on the server
○​ Technologies involved (HTML/CSS/JS vs Node.js, PHP, etc.)
●​ Hands-on Activities:
○​ Open dev tools in a browser and inspect network requests
○​ Visit http://example.com and https://example.com – observe
differences
○​ Use whois or dig to look up domain info (demonstration)​

​
Frontend and Backend Basics

●​ What is the frontend?

Understand what the user sees and interacts with – the visual part of a website or web
app.

●​ HTML, CSS, and JavaScript – what are they used for?

○​ HTML: Structure/content of web pages
○​ CSS: Styling and layout
○​ JavaScript: Interactivity and logic on the client-side
●​ Introduction to backend
○​ Handles business logic, data processing, and server-side operations.
●​ Common backend languages
○​ Examples: Node.js, Python, Java, Ruby
●​ Overview of databases
○​ SQL (structured): MySQL, PostgreSQL
○​ NoSQL (flexible): MongoDB, Firebase
●​ How frontend and backend communicate
○​ Through APIs and HTTP requests (GET, POST, etc.)​
​

What is an API?

●​ Definition of API (Application Programming Interface)

An API is a set of rules and protocols that allows one software application to interact with
another. It acts as a bridge between systems, enabling them to exchange data and
perform operations.

●​ Why are APIs important in software development?

○​ They allow integration between services (e.g., payment gateways, third-party
login, chat apps).
○​ Promote code reusability and scalability.
○​ Enable modular system design – each module or service can evolve
independently.
●​ Examples of APIs used in daily life
○​ Weather apps: Use weather data APIs
○​ Google Maps: Location and direction APIs
○​ Food delivery apps: APIs to fetch restaurants, payments, and track delivery
○​ Login via Facebook/Google: Authentication APIs
●​ Types of APIs
○​ REST (Representational State Transfer) – modern, widely used, lightweight,
and uses standard HTTP
○​ SOAP (Simple Object Access Protocol) – older, heavier, uses XML and
specific protocols

Focus will be on REST APIs in training due to simplicity and industry adoption

●​ HTTP Methods
○​ GET – Retrieve data
○​ POST – Create new data
○​ PUT – Update existing data
○​ DELETE – Remove data

These methods form the foundation of CRUD operations (Create, Read, Update, Delete)​

●​ API endpoints, request & response format (JSON)

○​ Endpoint: URL path that performs a specific action (e.g.,
https://api.example.com/users)
○​ Request: The data sent to the server (headers, parameters, body)
○​ Response: The data received from the server (often in JSON format –
JavaScript Object Notation)​
 Example:​
​ {

"id": 1,

"name": "John Doe",

"email": "john@example.com"

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand what software is and types (system vs application).

●​ Learn software development basics and SDLC stages.
●​ Know the developer’s role in building applications.
●​ Understand frontend (HTML, CSS, JS) vs backend (logic, database).
●​ Learn how browsers, servers, and internet interact.
●​ Grasp static vs dynamic sites, domains, IPs, and HTTP basics.
●​ Know what APIs are and why they matter.
●​ Recognize real-world API examples (e.g., maps, weather).
●​ Learn REST API basics, HTTP methods, JSON, and endpoints.

5. Database Basics (SQL & NoSQL)

Objective:

To introduce the concept of databases, explain the difference between SQL and NoSQL in a
simple way, and understand why both are used in the real world.
Detailed Content

Introduction to Databases

●​ What is a database?
A database is like a digital cupboard where we store information in an organized way
so we can easily find, update, or remove it when needed.

●​ Why do we need a database?

Without a database, information would be scattered in files and would be difficult to
search or manage.

●​ Examples in daily life:

○​ Your phone’s contact list (names, numbers, emails).
○​ Online shopping apps storing product details, prices, and reviews.
○​ Bank systems storing customer account information.

SQL Databases (Structured Query Language)

●​ What is SQL?
SQL databases store data in tables — like spreadsheets with rows and columns.

●​ When to use SQL databases:

○​ When data is structured and follows fixed rules.
○​ When we need relationships between data.
●​ Examples:
○​ A student database in a college (students, courses, grades).
○​ Banking systems storing account details and linking transactions to specific
customers.
●​ Advantages:
○​ Data is well-organized and easy to search.
○​ Strong rules help keep data accurate.​
NoSQL Databases (Not Only SQL)

●​ What is NoSQL?
NoSQL databases store data in a more flexible way — not just tables. Data can be in
forms like documents, key-value pairs, or graphs.

●​ When to use NoSQL databases:

○​ When data is unstructured or changes often.
○​ When speed and scalability are important.

●​ Examples:
○​ Social media storing posts, comments, and likes (all different shapes and sizes).
○​ E-commerce storing product details that vary a lot between items.

●​ Advantages:
○​ Flexible - can store different types of data easily.
○​ Can handle a huge amount of data and still work fast.

Why We Need Both SQL and NoSQL

●​ SQL is like a well-organized library - every book (data) is in the right section and
follows strict rules.
●​ NoSQL is like a big box of notes - you can store anything without worrying too much
about structure, and still find it quickly.
●​ Real-time example:​
An online shopping app might use:
○​ SQL to store customer details, payment history, and order records.
○​ NoSQL to store product images, customer reviews, and recommendations.

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand what a database is and why it is important.

●​ Differentiate between SQL and NoSQL in simple terms.
●​ Recognize situations where each type of database is useful.
●​ Relate database concepts to everyday applications.
6. Testing and Debugging Fundamentals

Objective:

To introduce the importance of testing and debugging in software development, explaining how
they ensure the software works correctly, meets user needs, and is free of major errors before
release.

Detailed Content

What is Testing?

Testing is the process of checking if the software works as expected.

Think of it like trying on a shirt before buying it - you want to see if it fits, looks good, and has no
defects.

Purpose of Testing:
●​ To find mistakes before users do.
●​ To ensure the product meets the requirements.
●​ To improve the quality and reliability of the software.

Why Testing is Important

●​ Saves time and money: Fixing problems early is cheaper than fixing them after release.
●​ Improves user experience: A bug-free app makes users happy.
●​ Builds trust: Reliable software creates a good reputation for the company.
●​ Prevents failures: Avoids serious issues like system crashes or incorrect data.

Types of Testing (Beginner Level)

We can think of testing in different stages:

●​ Manual Testing
○​ Humans check the software by using it directly.
○​ Example: Clicking every button in an app to ensure they work.
 ●​ Automated Testing
○​ Computers run tests automatically using pre-written instructions.
○​ Example: A script automatically checking if a login page accepts valid
usernames.
●​ Functional Testing
○​ Checks if the software does what it’s supposed to do.
○​ Example: Does the "Add to Cart" button actually add the product?
●​ Non-functional Testing
○​ Checks performance, speed, and reliability.
○​ Example: How fast does the app load with 1000 users?

Introduction to Debugging

Debugging is the process of finding and fixing the cause of a problem in software.
It’s like being a detective—you spot something wrong, investigate, and solve it.

●​ Steps in Debugging:
1.​ Identify the problem.
2.​ Understand why it happened.
3.​ Fix the code or configuration.
4.​ Test again to ensure the fix works.

Real-life Analogy

●​ Testing: Like checking your homework before submitting it.

●​ Debugging: Like finding and correcting spelling mistakes after you check your
homework.​

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand the importance of testing and debugging.

●​ Identify different types of basic testing.
●​ Follow a simple process to test software features.
●​ Debug small issues using logical thinking and available tools.
7. Version Control (Git & GitHub Basics)

Objective:

Introduce the concept of version control, why it is important in software development, and
provide a beginner-friendly introduction to Git and GitHub for collaboration and code
management.

Detailed Content

What is Version Control?

●​ Imagine writing an essay and saving different versions like essay_v1.doc,

essay_final.doc, essay_final_final.doc.
●​ In software, the same problem exists when multiple developers work on code.
●​ Version Control Systems (VCS) help track changes, manage different versions, and
collaborate without losing work. It’s a system that helps developers track changes in
code over time.
●​ Think of it like a "time machine for code" – you can see what changed, when, and who
made the change.

Why Is It Needed?

●​ Multiple people can work on the same project without overwriting each other’s work.
●​ Easy to roll back if something breaks.
●​ Creates a history of progress and accountability.

What is Git?​

●​ A distributed version control system created by Linus Torvalds (creator of Linux).

●​ Stores changes as "snapshots" of your project.
●​ Works offline on your computer (no internet required for local tracking).
●​ Commands are used to save and manage versions (e.g., git add, git commit).
What is GitHub?

●​ A cloud-based platform that hosts Git repositories online.

●​ Think of Git as your local diary, and GitHub as a shared online diary for your whole team.
●​ Enables collaboration, code reviews, issue tracking, and project management.

Key Concepts:

●​ Repository (Repo): A folder that contains your project and its version history.
●​ Commit: A snapshot of changes at a point in time (like saving progress in a game).
●​ Branch: A separate line of development where you can experiment without affecting the
main project.
●​ Merge: Combining changes from one branch into another.
●​ Push & Pull: Sending changes to GitHub (push) and getting updates from GitHub (pull).​

Real-World Example:

Imagine 3 interns working on a college project website:

●​ One intern designs the homepage.

●​ Another writes the backend logic.
●​ A third works on styling.

Without GitHub:

●​ They’d keep sending updated files on WhatsApp/Drive, often overwriting each other’s
work.
●​ It's hard to know which version is correct.​

Without GitHub:

●​ Each intern works on a branch.

●​ They push their changes.
●​ The team merges everything into the main project safely.
●​ If a mistake happens, they can roll back to a previous commit.
Basic Workflow (Simplified):

1.​ Create a local repo → git init

2.​ Save changes → git add → git commit
3.​ Connect to GitHub → git remote add origin <url>
4.​ Share work → git push
5.​ Get updates → git pull

Activity:​

●​ Create a folder, make it a Git repository.

●​ Save a text file, make a few commits (like writing a diary).
●​ Push to GitHub and view the history of changes.

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand the importance of version control in software projects.

●​ Know what Git and GitHub are and how they work together.
●​ Recognize basic concepts: repository, commit, branch, merge, push, pull.

8. Command Line Basics (Ubuntu Focused)

Objective:

Introduce learners to the Ubuntu/Linux command line interface (CLI), helping them understand
why developers often prefer it over graphical interfaces, and enabling them to perform basic file,
directory, and system operations confidently.
Detailed Content

Why Command Line?

●​ GUI (Graphical User Interface) is easy, but limited.

●​ CLI (Command Line Interface) is powerful, faster, and gives more control.
●​ Almost every server (like AWS, Azure, GCP) uses Linux/Ubuntu without GUI.
●​ Developers and DevOps engineers heavily rely on CLI for automation and
troubleshooting.

Real-life example:

When you host a website on AWS, you’ll connect to the server using CLI (via SSH), not by
clicking folders like in Windows.

Basic Concepts

●​ Terminal – The application used to type commands.

●​ Shell – The program that interprets commands (Ubuntu uses bash by default).
●​ Commands – Instructions you type into the shell.

Essential Ubuntu Commands

Navigation

●​ pwd → Show current working directory (where you are).

●​ ls → List files and directories.
●​ cd <directory> → Change directory.
●​ cd .. → Move one step back.

File & Directory Management

●​ touch file.txt → Create an empty file.

●​ mkdir myfolder → Create a folder.
●​ cp file1 file2 → Copy file.
 ●​ mv file1 file2 → Move/rename file.
●​ rm file.txt → Remove (delete) file.
●​ rm -r foldername → Remove folder (recursively).

Viewing Files

●​ cat file.txt → Show file contents.

●​ less file.txt → Scroll through file contents.
●​ head file.txt → Show first 10 lines.
●​ tail file.txt → Show last 10 lines.

System & User Commands

●​ whoami → Show current logged-in user.

●​ uname -a → Show system details.
●​ df -h → Show disk usage.
●​ top → Show running processes (like Task Manager).

Package Management

●​ sudo apt update → Update package list.

●​ sudo apt install <package> → Install software.
●​ sudo apt remove <package> → Remove software.

Activity:
●​ Open the following link in browser -
https://bellard.org/jslinux/vm.html?url=alpine-x86.cfg&mem=192

●​ Create a folder practice, and inside it create a file notes.txt.

●​ Write a line inside notes.txt using echo "Hello Ubuntu" >> notes.txt and
then view it using cat.
 ●​ Install a small package (like cowsay) using sudo apt install cowsay and run
cowsay "Hello Interns!".​

Learning Outcomes:

By the end of this section, learners should be able to:

●​ Understand why CLI is important in development.

●​ Perform basic file and folder operations.
●​ View and manage files using CLI.
●​ Install and manage software in Ubuntu.
●​ Be comfortable with simple daily developer tasks on the command line.