Emerging Trends

Read this before anything else. This chapter is not in the CBSE 2025-26 exam syllabus for Computer Science (083). It is printed in your NCERT textbook as Chapter 3, but none of its topics appear in the unit-wise content list of the CBSE syllabus, so it carries no marks. It is worth reading for interest. If your board exam is close, your revision time is better spent on Units 1-3 — Computer Systems and Organisation, Computational Thinking and Programming - 1, and Society, Law and Ethics. Read this chapter when you have a free evening, not the night before the paper.

So why is it in the book at all? Because these six words — artificial intelligence, big data, IoT, cloud, grid, blockchain — are the vocabulary of every college brochure, internship advertisement and newspaper technology page. Knowing what each one actually means, and just as usefully what it does not mean, stops you from being impressed by empty claims. That is a real skill, it just is not a scoring one.

What does "emerging" actually mean? Not "newly invented". The mathematics behind neural networks, public-key cryptography and distributed computing is decades old. "Emerging" describes adoption: the idea existed, but the hardware was too expensive or too slow for anyone to bother. When the cost falls below some threshold, the idea suddenly appears everywhere and looks new.

The one engine behind most of this chapter. Four separate things got cheap at roughly the same time, and five of the six technologies here are a consequence of that:

• Sensing got cheap. A temperature sensor, a camera module or a GPS chip now costs less than a school textbook. So we started measuring things we never used to measure — and that is IoT.
• Storage got cheap. Once keeping data costs almost nothing, organisations stop deleting anything. That is big data.
• Computing became rentable. You no longer buy a server; you rent one by the hour and give it back. That is cloud, and pooling many owned machines instead is grid.
• Enough compute in one place made pattern-learning practical. Training a model on millions of examples stopped being a research luxury. That is the current wave of AI.

Blockchain is the odd one out: it did not come from cheapness, it came from a design question — can a group of strangers agree on a shared record without trusting any single one of them to keep it?

Worked example — check the "big" in big data yourself. Suppose a housing society in Pune fits smart water meters in 2500 flats and each meter reports once every 5 seconds. Before believing anyone's claim about "huge data", just count.

# One smart water meter in a Pune housing society sends a reading every 5 seconds.
readings_per_day = 24 * 60 * 60 // 5
print("Readings per meter per day :", readings_per_day)

meters = 2500
per_day = readings_per_day * meters
print("Readings per day, society  :", per_day)
print("Readings per year, society :", per_day * 365)

bytes_per_reading = 40
total = per_day * 365 * bytes_per_reading
print("Bytes per year             :", total)
print("Gigabytes per year         :", round(total / (1024 ** 3), 2))

Real output:

Readings per meter per day : 17280
Readings per day, society  : 43200000
Readings per year, society : 15768000000
Bytes per year             : 630720000000
Gigabytes per year         : 587.4

Read what those numbers say. One building, one boring measurement, produces about 4.32 crore readings a day and roughly 1576.8 crore a year. Even at a tiny 40 bytes per reading that is about 587 GB a year — more than a good many laptop disks can comfortably hold, from water meters. Now imagine a city. That is the honest reason big data exists: nobody set out to collect this much, it simply falls out of measuring often.

Notice also that // was used, not /. 86400 / 5 gives 17280.0, a float; 86400 // 5 gives 17280, an integer. You cannot take half a reading, so the integer is the honest type.

A habit worth keeping. When a product claims to use "AI", ask what data it learned from. When it claims "the cloud", ask whose machine and in which country. When it claims "blockchain", ask who is allowed to write to it. If nobody can answer, the word is decoration.

Artificial Intelligence (AI) is the broad aim of making a machine perform tasks that we would call intelligent when a person does them: recognising a face, understanding a spoken sentence in Hindi, planning a route, playing chess. It is a goal, not a single technique.

Why the old approach failed. The first attempts wrote the rules by hand. That works for chess-like problems where the rules are finite and written down. It collapses for perception. Try writing an if condition that decides whether a photograph contains a cow. Cows appear at every angle, in every light, partly hidden behind an auto-rickshaw. No human can list those conditions, so the machine has to work them out itself. That realisation is the whole reason machine learning took over.

Machine Learning (ML) is the approach where you supply many labelled examples and the program adjusts itself until its predictions on those examples are mostly right. You do not write the rule; you write the process that discovers the rule. The three usual families are:

• Supervised learning — every example comes with the correct answer attached. Spam or not spam. Fraudulent or genuine transaction.
• Unsupervised learning — no answers given; the program groups similar items. A shop discovering that its customers fall into three buying patterns.
• Reinforcement learning — the program acts, gets a reward or a penalty, and adjusts. Used for game playing and robot control.

Deep Learning (DL) is machine learning using artificial neural networks with many layers. Each layer transforms the data a little; early layers in an image network pick up edges, later layers pick up shapes, later still whole objects. It is called "deep" only because of the number of layers. Deep learning needs far more data and far more computing power than older ML methods, which is exactly why it became practical only recently.

The relationship is nested, and this nesting is the single most common question asked about the topic:

Branches you will hear named. Natural Language Processing (NLP) handles human language — translation between English and Marathi, chatbots, speech-to-text. Computer vision handles images — reading a number plate, checking a crop leaf for disease. Robotics combines sensing, decision and physical action; a robot is not automatically AI, and much factory automation is plain programmed motion. Immersive experience covers Virtual Reality (a fully computer-generated world seen through a headset) and Augmented Reality (computer-generated things drawn on top of the real world through a camera, like a phone app showing furniture in your room).

Worked example — a real, tiny classifier. This is the nearest-neighbour method: to label a new item, find the labelled example closest to it and copy that label. Each dish is described by two numbers, chilli in grams and sugar in grams.

import math

# Six dishes already labelled by a cook: (chilli in grams, sugar in grams, label)
samples = [(12, 2, "spicy"), (15, 1, "spicy"), (9, 3, "spicy"),
           (1, 30, "sweet"), (0, 45, "sweet"), (2, 38, "sweet")]

new_dish = (3, 33)          # an unlabelled dish
best_label = ""
best_dist = math.inf

for chilli, sugar, label in samples:
    d = math.dist(new_dish, (chilli, sugar))
    print("distance to", label, "sample", (chilli, sugar), "=", round(d, 2))
    if d < best_dist:
        best_dist = d
        best_label = label

print("Nearest neighbour says:", best_label)

Real output:

distance to spicy sample (12, 2) = 32.28
distance to spicy sample (15, 1) = 34.18
distance to spicy sample (9, 3) = 30.59
distance to sweet sample (1, 30) = 3.61
distance to sweet sample (0, 45) = 12.37
distance to sweet sample (2, 38) = 5.1
Nearest neighbour says: sweet

Nowhere in that program is there a rule saying "lots of sugar means sweet". The six labelled examples supplied the knowledge; the code only measured distance. That is machine learning in miniature. math.inf is used as the starting value for best_dist because any real distance is smaller than infinity, so the first comparison always succeeds.

Now the honest limitations, which matter more than the hype:

• It copies its training data, including the bias. If a bank's past loan decisions were unfair to some group, a model trained on them will reproduce that unfairness and look objective while doing it.
• It has no understanding. Our example does not know what sugar is. Change the units from grams to kilograms and the "distances" change meaning entirely.
• It is confident when wrong. The program above prints an answer for any input, including a dish with 0 g of both. Text-generating systems similarly produce fluent, well-formed statements that are simply false.
• It needs labelled data, and labelling is human work. Most of the cost of a real ML project is people patiently tagging examples.

Big data is data that is too large, arrives too fast, or is too mixed in form for the ordinary tools on one ordinary machine to handle. Note the definition is relative. A dataset that overwhelms a school laptop is routine for a bank. There is no fixed number of gigabytes at which data becomes "big", and anyone who quotes one is guessing.

The characteristics, usually listed as the five V's:

Forms of data. Structured data fits neat rows and columns with a fixed set of fields — a marks table. Semi-structured data has tags or markers but no fixed table shape — XML and JSON files. Unstructured data has no such organisation at all — photographs, audio recordings, free-text complaints. Most of the data an organisation holds is unstructured, which is precisely why it is hard to use.

Why ordinary tools break, and what replaces them. A single computer has a limited amount of RAM, one disk with a limited transfer speed, and a limited number of cores. Past a point, opening the file is itself impossible. The standard answer has two halves: split the data across many machines (distributed storage), and send the computation to wherever each piece is stored rather than dragging the data to one central computer (distributed processing). Moving the program is cheap; moving terabytes is not. Every big-data framework you will meet later is a variation on that one idea.

Data analytics is the work of turning this data into something a person can act on. It is usually described in four steps: descriptive (what happened), diagnostic (why it happened), predictive (what is likely next), and prescriptive (what should we do about it). Only the first is easy.

Worked example 1 — veracity, and why the average lies. Eleven flats in a building, one of which quietly runs a small print shop.

import statistics

# Monthly electricity bills (rupees) of 11 flats. One flat runs a small print shop.
bills = [820, 940, 760, 1100, 890, 1010, 780, 950, 870, 990, 26400]

print("mean   :", statistics.mean(bills))
print("median :", statistics.median(bills))
print("stdev  :", round(statistics.stdev(bills), 2))

without_shop = bills[:-1]
print("mean without the shop :", statistics.mean(without_shop))
print("median without the shop:", statistics.median(without_shop))

Real output:

mean   : 3228.181818181818
median : 940
stdev  : 7685.9
mean without the shop : 911
median without the shop: 915.0

The mean says the typical flat pays ₹3228. Not one flat pays anything close to that. A single outlier dragged the mean up by more than three times, while the median barely moved (940 to 915). The standard deviation of 7685.9 being larger than the mean is itself the warning bell: it says the values are nowhere near their own average. This is what veracity means in practice — the number was computed correctly and still misleads.

Worked example 2 — you often do not need all the data. Two lakh transaction amounts, then a random sample of just 500 of them.

import random, statistics

random.seed(2026)
population = []                     # pretend: one day of UPI amounts, 2 lakh rows
for i in range(200000):
    population.append(random.randint(10, 5000))

print("Full data  - rows  :", len(population))
print("Full data  - mean  :", round(statistics.mean(population), 2))
print("Full data  - median:", statistics.median(population))

sample = random.sample(population, 500)
print("500 sample - mean  :", round(statistics.mean(sample), 2))
print("500 sample - median:", statistics.median(sample))

Real output:

Full data  - rows  : 200000
Full data  - mean  : 2501.06
Full data  - median: 2501.0
500 sample - mean  : 2584.03
500 sample - median: 2700.0

A sample of 500 rows — a quarter of one percent of the data — estimated the mean as 2584 against a true 2501. That is close enough for many decisions, at 1/400th of the work. Good analysts reach for a sample first and the full dataset only when the question genuinely demands it. Note also that random.seed(2026) makes the whole run repeatable; without it you would get different numbers every time and could never check your own work.

Two cautions. More data does not fix bad data — collecting the wrong measurement a billion times gives you a very precise wrong answer. And large personal datasets carry real risk: records that look harmless alone can identify a person when combined, which is why data protection law cares about collection, not just leaks.

The Internet of Things (IoT) is the idea of connecting everyday physical objects — meters, vehicles, streetlights, farm equipment, wristbands — to a network so that they can send what they measure and, in some cases, receive instructions back. The "thing" is anything that is not normally thought of as a computer.

Every IoT system has the same four parts. Learn these four and you can describe any IoT product:

1. The thing and its sensors — the hardware that measures something physical and converts it into an electrical signal.
2. Connectivity — how the reading leaves the device: Wi-Fi, Bluetooth, a mobile network SIM, or a long-range low-power radio for devices in fields.
3. Processing and storage — where readings are collected, checked and kept, often a cloud service.
4. Action and interface — what happens as a result: an alert on a phone, a chart on a dashboard, or an actuator physically doing something.

Sensors versus actuators. A sensor turns a physical quantity into a signal. An actuator turns a signal into physical movement or change. The distinction is asked often and is easy to get right: sensors read the world, actuators change it.

You already use IoT daily. FASTag is an RFID tag read by an antenna at the toll plaza, which triggers a payment and lifts the barrier — sensor, network, processing, actuator, all four parts. A smart electricity meter reports consumption to the utility without a person visiting. A cold-chain box carrying vaccines logs its temperature the whole way so anyone can check the batch was never allowed to warm up.

Related terms. A Wireless Sensor Network (WSN) is a group of scattered sensor nodes that pass their readings to a gateway, often relaying through one another. An embedded system is a computer built into a larger device for one fixed job — a washing machine controller. A smart city is simply IoT applied at municipal scale: traffic signals that respond to actual queues, streetlights that dim when a road is empty, bins that report when they are full, water pipelines that detect leaks by pressure drop.

Edge versus cloud, and why it is a real decision. Should the device decide, or should it send everything to a server? A CCTV camera that streams full video all day burns bandwidth and money. If instead it decides on the device that nothing is happening and sends only a short clip when something moves, that is edge computing. Edge wins when you need an instant response, when bandwidth is scarce, or when the raw data is private and should not leave the building.

Worked example — a sensor loop with a threshold alert. Real firmware reads a hardware pin; here random.randint() stands in for the sensor so the program runs on any machine. The seed keeps the "readings" identical every run.

import random, statistics

random.seed(11)          # same "sensor" values on every run
readings = []
alerts = 0

for hour in range(12):
    aqi = random.randint(60, 260)      # pretend: AQI sensor on a Delhi terrace
    readings.append(aqi)
    if aqi > 200:
        alerts = alerts + 1
        print("hour", hour, "AQI", aqi, "-> ALERT: air quality Poor")

print("All readings :", readings)
print("Average AQI  :", round(statistics.mean(readings), 1))
print("Worst hour   :", readings.index(max(readings)), "with", max(readings))
print("Alerts raised:", alerts)

Real output:

hour 1 AQI 203 -> ALERT: air quality Poor
hour 2 AQI 259 -> ALERT: air quality Poor
hour 6 AQI 210 -> ALERT: air quality Poor
hour 11 AQI 221 -> ALERT: air quality Poor
All readings : [175, 203, 259, 179, 175, 190, 210, 108, 107, 191, 181, 221]
Average AQI  : 183.2
Worst hour   : 2 with 259
Alerts raised: 4

This tiny program is the shape of almost every IoT application: read, store, compare against a threshold, act, summarise. The threshold of 200 is not arbitrary — on India's National Air Quality Index the band 101-200 is Moderate, 201-300 is Poor and 301-400 is Very Poor, so every alert above is a Poor hour, not a Very Poor one. Notice that the average of 183.2 hides the problem completely: it sits inside the Moderate band, yet the air crossed into Poor four separate times. Reporting only the average would have hidden every bad hour. readings.index(max(readings)) gives the position of the largest value; if two hours tied, index() would return the first one.

The security problem is not a footnote. IoT devices are cheap, shipped with the same default password on every unit, often never updated, and expected to run for a decade. That combination has been used repeatedly to take over large numbers of cameras and routers and turn them into attack networks. A device that watches your front door and accepts admin/admin is a worse risk than no device at all. If you build one for a project, change the default credentials and do not expose it directly to the open internet.

Cloud computing means getting computing resources — machines, storage, databases, finished applications — over the internet, on demand, paying only for what you use. The usual list of essential characteristics is: on-demand self-service (you provision it yourself, no phone call), broad network access, resource pooling (one provider's hardware serves many customers), rapid elasticity (scale up for exam results day, scale down after), and measured service (usage is metered and billed).

Service models — what exactly you are renting:

The rule to remember: the more you rent, the less you control. IaaS gives the most freedom and the most work; SaaS gives the least of both.

Deployment models. A public cloud is shared infrastructure open to any paying customer. A private cloud is dedicated to one organisation, whether on its own premises or hosted for it — chosen when rules require the data to stay under direct control. A community cloud is shared by several organisations with common requirements, such as a group of hospitals. A hybrid cloud combines them: sensitive records in the private part, the public website in the public part.

Worked example — why renting can beat buying. A college result portal is idle for most of the year and then hammered for a few weeks.

# Cloud pricing is per-use. Compare buying a server vs renting one.
own_cost = 180000            # rupees, one-time, plus power/AC
rent_per_hour = 12           # rupees

hours_in_year = 365 * 24
print("Hours in a year        :", hours_in_year)
print("Renting all year       :", rent_per_hour * hours_in_year)

# A college result portal is really busy only 30 days a year, 10 hours a day.
busy_hours = 30 * 10
print("Renting only when busy :", rent_per_hour * busy_hours)
print("Break-even hours       :", own_cost // rent_per_hour)

Real output:

Hours in a year        : 8760
Renting all year       : 105120
Renting only when busy : 3600
Break-even hours       : 15000

Read the result carefully. Renting round the clock costs ₹1,05,120 a year, so over two years renting continuously is worse than buying — the break-even is 15000 hours, which is about 1.7 years of continuous use. But renting only during the 300 busy hours costs ₹3,600. Cloud is not automatically cheaper; it is cheaper when your load is bursty. For a steady 24×7 load, owning often wins. That is the honest version of the cloud sales pitch.

Grid computing pools many separate, often geographically scattered and differently-configured computers so they work together on one large problem, typically by splitting it into independent pieces. The classic use is scientific: volunteer projects where thousands of people donate their idle home computers to research calculations. Note the contrast with a supercomputer such as C-DAC's PARAM series — that is one tightly-coupled machine in one room, not a grid.

Blockchain is a record (a ledger) kept as a chain of blocks. Each block holds some data, its own hash, and the hash of the previous block. Many participants keep a full copy, and a consensus rule decides which new block everyone accepts. The result is tamper-evident storage: you cannot quietly edit an old entry, because doing so changes that block's hash, which was recorded inside the next block, and so on down the chain.

Worked example — build the chain, then try to cheat it. Real blockchains use SHA-256; this toy hash is deliberately simple so you can see the mechanism.

# A toy hash. Real blockchains use SHA-256; the idea is the same:
# any change in the text changes the number completely.
blocks = ["Aarav pays Priya 500",
          "Priya pays Rahul 200",
          "Rahul pays Sana 50"]

prev = 0
chain = []
for data in blocks:
    text = str(prev) + "|" + data
    h = 7
    for ch in text:
        h = (h * 31 + ord(ch)) % 1000003
    chain.append((prev, h, data))
    prev = h

for p, h, data in chain:
    print("prev =", p, " hash =", h, " :", data)

Real output:

prev = 0  hash = 571671  : Aarav pays Priya 500
prev = 571671  hash = 334703  : Priya pays Rahul 200
prev = 334703  hash = 857821  : Rahul pays Sana 50

Now someone edits the middle block, changing 200 to 2000:

# Someone edits block 2: "200" becomes "2000". Watch every later hash change.
tampered = ["Aarav pays Priya 500",
            "Priya pays Rahul 2000",
            "Rahul pays Sana 50"]

prev = 0
for data in tampered:
    text = str(prev) + "|" + data
    h = 7
    for ch in text:
        h = (h * 31 + ord(ch)) % 1000003
    print("prev =", prev, " hash =", h, " :", data)
    prev = h

Real output:

prev = 0  hash = 571671  : Aarav pays Priya 500
prev = 571671  hash = 375811  : Priya pays Rahul 2000
prev = 375811  hash = 323050  : Rahul pays Sana 50

Compare the two runs. Block 1 is untouched, so its hash is still 571671. But block 2's hash went from 334703 to 375811, and block 3 — whose text was never edited at all — went from 857821 to 323050, purely because the previous hash feeding into it changed. That is the entire trick. To hide the edit you would have to recompute every block after it, on every copy held by every participant, faster than the network adds new blocks.

Be precise about what blockchain does and does not give you:

• It makes changing stored records detectable. It does not check whether the data was true when it was written. If someone records a false land ownership entry on day one, the chain protects that falsehood perfectly.
• "Tamper-evident" is the correct word, not "tamper-proof".
• Proof-of-work consensus, used by some public blockchains, consumes a great deal of electricity by design — the cost is the security.
• Blockchains are slow and expensive compared with an ordinary database. If one organisation controls the data anyway, a database with good backups and audit logs is the sensible choice. Blockchain earns its cost only when the participants genuinely do not trust one another.