Step into almost any school or college computer laboratory across India, and you will likely encounter a strict, campus-wide anomaly: a neat row of footwear lined up outside the entrance. While students are permitted to wear shoes into chemistry labs, physics labs, libraries, and lecture halls, the computer lab remains a sanctuary where footwear is strictly forbidden.
Alongside this physical ritual sits an equally enduring academic rule: students must meticulously write out their programming code in a paper notebook and have it approved by an instructor before they are allowed to touch a keyboard.
For decades, millions of Indian students have complied with these rules without questioning their origin. However, these habits are not arbitrary exercises in discipline. They are living historical artifacts, tracing their lineage back more than sixty years to the dawn of computing in India—an era when machines were massive, delicate, and exceedingly rare, and when one of the country’s very first educational computers had to complete its journey to campus on a wooden cart pulled by oxen.
Main Facts: The Legacy of Early Indian Computing
The transition of computer lab rules from logical engineering precautions to cultural traditions highlights a unique period in India’s technological development. The core facts surrounding this phenomenon include:
The Dust-Sensitivity of Early Hardware: Early mainframes and minicomputers used magnetic tape drives, open-disk packs, and delicate mechanical punch-card readers. Dust and static electricity were major hazards that could cause head crashes, read errors, or physical damage to expensive components. Removing footwear was a highly practical way to minimize the introduction of outdoor dirt and static-carrying dust into climate-controlled server rooms.
The Scarcity of Computing Resources: In the mid-to-late 20th century, computers were multi-million-dollar institutional assets. With hundreds of students vying for a few hours of terminal access, "live" debugging on a machine was an unaffordable luxury. Writing and verifying code on paper beforehand was a vital strategy to maximize limited terminal time.
Institutional Memory and Cultural Adaptation: As personal computers became cheaper and more robust in the 1990s and 2000s, the technical necessity for these rules disappeared. However, the practices had already solidified into academic culture, passed down by generations of instructors who equated computer labs with pristine, highly disciplined environments.
Chronology of Indian Academic Computing (1963–Present)
To understand how these traditions became so deeply entrenched, we must trace the history of computer science education in India from its physical and logistical beginnings.
+-----------------------------------------------------------------------------+
| TIMELINE |
+-----------------------------------------------------------------------------+
| |
| 1963: Arrival of IBM 1620 at IIT Kanpur via a bullock cart. |
| | |
| 1964: Computer becomes fully operational; "no shoes" policy implemented. |
| | |
| 1970s: The Punch-Card Era; students write programs on paper first. |
| | |
| 1980s: Arrival of microcomputers (MS-DOS); terminal time remains scarce. |
| | |
| 1990s: Turbo C++ dominates curricula; labs retain traditional rules. |
| | |
| Present: Modern PCs are dust-resistant, but traditional rituals persist. |
| |
+-----------------------------------------------------------------------------+
1963: The Monsoon and the Bullock Cart
In the summer of 1963, IIT Kanpur became a pioneer in Indian computer science education by acquiring an IBM 1620, a decimal-based computer popular among American universities. The acquisition was facilitated by the Kanpur Indo-American Programme (KIAP), a high-profile collaboration that linked the young IIT Kanpur with a consortium of nine elite American institutions, including the Massachusetts Institute of Technology (MIT), Princeton University, Purdue University, and the University of California, Berkeley.
The physical journey of the IBM 1620 to the campus was a major logistical challenge:
The Arrival: The machine arrived in India via a specially chartered aircraft, landing at the Chakeri Air Force Station in Kanpur.
The Muddy Obstacle: Loaded onto flatbed trucks, the computer was transported toward the developing IIT Kanpur campus. However, severe monsoon rains had washed out the dirt roads leading to the institute, leaving the trucks stuck in deep mud.
The Bullock Cart Rescue: As documented in Spark, the IIT Kanpur alumni magazine, project coordinators resorted to a traditional solution: a local wooden bullock cart pulled by a pair of oxen. The delicate, multi-million-rupee computer was transferred to the cart and carefully hauled through the final, muddy stretch of the journey.
The Installation: The challenges continued at the building site. The dedicated computer center was still under construction, with rainwater leaking through the ceiling. Furthermore, the building’s doorway was too narrow for the massive IBM 1620 cabinets, forcing workers to break down a portion of the brick wall to get the machine inside.
1964: Going Live
By February 1964, the IBM 1620 was fully assembled, calibrated, and running 24 hours a day. Because it was the only machine of its kind in the region, access was tightly controlled. The room was heavily air-conditioned—not for human comfort, but to keep the thousands of transistors and magnetic core memories from overheating. It was during this period that the "cleanroom" protocols, including the removal of shoes, were strictly implemented to protect the delicate system.
The 1970s to 1980s: The Era of Punch Cards and Mainframes
During this period, programming did not involve a real-time monitor and keyboard. Students wrote their code on paper templates, which were then translated into physical paper cards using keypunch machines.
A single misplaced character meant a ruined card and hours of lost progress. Consequently, instructors demanded that students verify their logic on paper before touching the keypunch machines.
The 1990s to Present: The Rise of Personal Computers
With the microcomputer revolution, schools across India set up dedicated computer labs running MS-DOS, and later, Windows. While these newer machines were far more resilient to dust and temperature fluctuations, the old habits did not fade.
The rapid expansion of IT education meant that old protocols were simply copied from university handbooks into high school lab manuals. The physical precaution of removing shoes transformed into a symbolic ritual of respect and care for expensive technology.
Supporting Data: The Vulnerability of Early Hardware
To understand why early computer administrators were so protective of their laboratories, it is helpful to look at the technical specifications and costs of the hardware of that era.
Metric / Feature
IBM 1620 (1960s)
Modern Desktop PC (2020s)
Physical Footprint
Required a dedicated, air-conditioned room
Sits easily on a small desk or lap
Weight
Approx. 540 to 1,200 kg (depending on modules)
Approx. 5 to 10 kg
Primary Memory
20,000 to 60,000 decimal digits (magnetic core)
8 to 32 Gigabytes (RAM)
Storage Medium
Punched cards, paper tape, magnetic disk packs
Solid State Drive (SSD) with no moving parts
Dust Sensitivity
Extremely High. Dust on punch cards caused read errors; dust on magnetic heads caused permanent drive damage.
Very Low. Fully sealed components; internal fans handle moderate dust.
Relative Cost
Equivalent to hundreds of thousands of USD
$300 to $1,000 USD
The Threat of Dust and Static
In early computing systems, read/write heads flew micro-inches above spinning magnetic disks. A single speck of dust, a stray hair, or even a particle of ash from a cigarette could wedge itself between the head and the platter, causing a "head crash" that physically scraped the magnetic coating off the disk, permanently destroying both the drive and the data.
Additionally, Indian schools faced a unique challenge: the dry, dusty summers of the Indo-Gangetic plains, followed by high-humidity monsoons. Footwear worn outside carried dry clay, soil, and organic matter. Bringing these shoes into a computer room would quickly introduce fine dust into the air-handling systems. Removing shoes was a simple, zero-cost preventive measure that significantly extended the life of these highly sensitive machines.
Expert Perspectives and Institutional Context
To understand why these rules persist today, we can look to computer science educators who have studied the history of technology in India.
The Preservation of Cleanliness Protocols
Mohammed Suhail Rehman, Assistant Instructional Professor in the Department of Computer Science at the University of Chicago, points out that the early days of Indian computing created a culture of extreme caution.
"The story of the first computer course in India at IIT Kanpur is well documented and illustrates the nature of how computer science education started in India," Rehman explains. "Back then, computers were not personal devices. They were incredibly expensive machines shared by entire institutions."
Because the machines were so rare, the spaces housing them were treated with a level of care bordering on the sacred. As computing education expanded from elite institutions like the IITs to state engineering colleges, and eventually to primary and secondary schools, the "no shoes" policy was passed down as a standard operational procedure, losing its technical context along the way.
The Economics of Batch Processing
Rehman also notes that the insistence on paper-based coding was born out of sheer resource scarcity:
"If you made a mistake, you basically wasted a punched card," Rehman says. "So you wanted to make sure your program was completely correct by hand before you tried it out on the machine."
Even in the late 1980s and 1990s, when personal computers replaced mainframes, Indian schools faced a massive supply-and-demand mismatch. A school might have had 100 students enrolled in a computer class but only five working PCs.
"Students had to use PCs in batches," Rehman notes. "So they had to be prepared with a working program on paper before trying it out on a computer. Computer time was valuable."
Implications: Cult or Pedagogy?
As modern computers have become highly durable, sealed, and ubiquitous, educators and technologists are re-evaluating these decades-old laboratory rules.
+-----------------------------------+
| ARE MODERN LAB RULES USEFUL? |
+-----------------------------------+
|
+-----------------------+-----------------------+
| |
[ PHYSICAL: "NO SHOES" ] [ COGNITIVE: "PAPER FIRST" ]
| |
* Obsolete technical basis. * High pedagogical value.
* Modern PCs resist dust. * Encourages deep planning.
* Creates unnecessary barriers. * Counters over-reliance on AI.
| |
V V
Recommendation: Recommendation:
PHASE OUT RETAIN & ADAPT
1. The Physical Environment: Time to Retain Footwear
From a technical standpoint, there is no longer any reason to ban shoes in a computer lab. Modern personal computers are designed to operate in standard home and office environments. They do not use open magnetic media, and their cooling systems are equipped with filters that can handle normal levels of indoor dust.
"Modern computers are not as sensitive as older devices," Rehman points out. "Computers have made their way into companies and offices, and no one really removes their shoes there anymore."
Furthermore, some critics argue that forcing students to remove their shoes can create an unwelcoming environment, emphasizing rigid obedience over practical learning.
2. The Cognitive Value of Paper Coding
While the "no shoes" rule is largely obsolete, the practice of writing code on paper before typing it remains highly relevant to modern pedagogy.
In an era dominated by instant-feedback compilers and generative AI assistants like ChatGPT and GitHub Copilot, students often fall into a habit of "guess-and-check" programming—writing random lines of code, running them, seeing an error, and letting the AI or compiler suggest a fix without actually understanding the underlying logic.
"There is some pedagogical benefit to writing code on pen and paper, especially when starting to learn programming," Rehman says.
Writing code by hand forces students to:
Dry-run their logic mentally: Students must trace the flow of variables and loops in their heads, building a stronger mental model of execution.
Develop syntax memory: Writing out commands by hand reinforces the precise syntax of a language, reducing reliance on auto-complete tools.
Slow down and plan: It encourages structural planning and algorithmic thinking rather than immediate, disorganized typing.
3. The Challenge of Technical Debt: The Turbo C++ Legacy
The persistence of these physical rules points to a broader challenge in Indian computer education: a reluctance to update aging curricula.
Rehman highlights a striking example of this stagnation: the continued use of Turbo C++, an Integrated Development Environment (IDE) released by Borland in 1990.
"What’s amazing is that many schools and universities have not transitioned away from Turbo C++," Rehman says.
Because Turbo C++ was designed for 16-bit MS-DOS systems, it cannot run natively on modern 64-bit Windows, macOS, or Linux operating systems. To use it today, schools must install DOSBox—an emulator designed for playing retro video games—just to run an obsolete compiler. This persistence stems from the same administrative inertia that keeps the "no shoes" signs posted on lab doors: a tendency to stick to familiar routines long after their practical utility has expired.
A Living History
The next time you are asked to leave your shoes at the door of an Indian computer lab, or are told to write out a C++ or Python program in a notebook before touching a keyboard, you are not just following an outdated rule. You are participating in a living history lesson.
These habits are direct links to a time when computing was a rare, high-stakes endeavor—an era when programs were punched into paper cards, computer time was precious, and one of India’s very first educational computers completed its historic journey on a wooden bullock cart through the monsoon mud of Kanpur.
