ISC Class 12 Syllabus 2028 Computer Science

ISC
INDIAN SCHOOL CERTIFICATE
EXAMINATION

YEAR 2028

COMPUTER SCIENCE
(868)

Developed by:
Research, Development and Curriculum Division (RDCD)
CISCE

January 2026
____________________________________________________________________________________________

© Copyright, Council for the Indian School Certificate Examinations
All rights reserved. The copyright to this publication and any part thereof solely vests in the Council for the Indian
School Certificate Examinations. This publication and no part thereof may be reproduced, transmitted, distributed or
stored in any manner whatsoever, without the prior written approval of the Council for the Indian School Certificate
Examinations.

Council for the Indian School Certificate Examinations (CISCE)

MISSION STATEMENT

The Council for the Indian School Certificate
Examinations is committed to serving the nation's
children, through high quality educational
endeavours, empowering them to contribute towards
a humane, just and pluralistic society, promoting
introspective living, by creating exciting learning
opportunities, with a commitment to excellence.

ETHOS OF CISCE

Trust and fair play.
Minimum monitoring.
Allowing schools to evolve their own niche.
Catering to the needs of the children.
Giving freedom to experiment with new ideas
and practices.
Diversity and plurality - the basic strength for
evolution of ideas.
Schools to motivate pupils towards the
cultivation of:
Excellence - The Indian and Global
experience.
Values - Spiritual and cultural - to be the bedrock
of the educational experience.
Schools to have an 'Indian Ethos', strong roots in
the national psyche and be sensitive to national
aspirations.

COMPUTER SCIENCE (868)

Aims (Conceptual)
(1) To understand algorithmic problem solving using data abstractions, functional and procedural abstractions,
and object based and object-oriented abstractions.
(2) To understand:
(a) how computers represent, store and process data at different levels of abstraction that mediate between
the machine and the algorithmic problem solving level and
(b) how they communicate with the outside world.
(3) To create awareness of ethical issues related to computing and to promote safe, ethical behavior.
(4) To make students aware of future trends in computing.
Aims (Skills)
To devise algorithmic solutions to problems and to be able to code, validate, document, execute and debug the
solution using the Java and python programming system to align with the future trend.

1

CLASS XII
There will be two papers in the subject:
Paper I: Theory………..3 hours….70 marks
Paper II: Practical……3 hours….30 marks

Distribution of marks for the theory paper:
S.No. Topic Marks
Section A – Hardware
1. Boolean Algebra
2. Computer Hardware 25 Marks
Section B - Java
3. Methods – Object as a parameter and return data type
4. Arrays (Single and double dimensional), String handling
5. Recursion
6. Inheritance and Interface 30 Marks
Section C - Python & Conceptual aspects
7. Programming in Python
8. Data Structures 15 Marks
9. Complexity and Big O notation
Total 70 Marks

PAPER I (THEORY) : 70 MARKS
SECTION A - HARDWARE

1. Boolean Algebra
(a) Propositional logic, well formed formulae, truth values and interpretation of well formed formulae (wff),
truth tables, satisfiable, unsatisfiable and valid formulae. Equivalence laws and their use in simplifying
wffs.
Propositional variables; the common logical connectives (~ (not)(negation), ∧ (and)(conjunction), ∨
(or)(disjunction), ⇒ (implication), ⇔ (biconditional); definition of a well-formed formula
(wff);
`representation of simple word problems as wff (this can be used for motivation); the values true and
false; interpretation of a wff; truth tables; satisfiable, unsatisfiable and valid formulae.
Equivalence laws: commutativity of ∧, ∨; associativity of ∧, ∨; distributivity; De Morgan’s laws; law of
implication (p ⇒ q ≡ ~p ∨ q); law of biconditional ((p ⇔ q) ≡ (p ⇒ q) ∧ (q ⇒ p)); identity (p ≡ p);
law of negation (~ (~p) ≡ p); law of excluded middle (p ∨~p ≡ true); law of contradiction (p∧~p ≡ false);
tautology and contingency simplification rules for ∧, ∨. Converse, inverse and contra positive. Chain
rule, Modus ponens.
(b) Binary valued quantities; basic postulates of Boolean algebra; operations AND, OR and NOT; truth
tables.

9

(c) Basic theorems of Boolean algebra (e.g. duality, idempotence, commutativity, associativity,
distributivity, operations with 0 and 1, complements, absorption, involution); De Morgan’s theorem and
its applications; reducing Boolean expressions to sum of products and product of sums forms; Karnaugh
maps (up to four variables).
Verify the laws of Boolean algebra using truth tables. Inputs, outputs for circuits like half and full
adders, majority circuit etc., SOP and POS representation; Maxterms & Minterms, Canonical and
Cardinal representation, reduction using Karnaugh maps and Boolean algebra.

2. Computer Hardware
(a) Elementary logic gates (NOT, AND, OR, NAND, NOR, XOR, XNOR) and their use, performance,
expression, truth table and symbol.
(b) Applications of Boolean algebra and logic gates to half adders, full adders, encoders, decoders,
multiplexers, half subtractors, full subtractors, NAND, NOR as universal gates.
Show the correspondence between Boolean methods and the corresponding switching circuits or gates.
Show that NAND and NOR gates are universal by converting some circuits to purely NAND or NOR
gates.

SECTION B - JAVA

The programming element in the syllabus (Sections B and C) is aimed at algorithmic problem solving and not
merely rote learning of Java and Python syntax. The Java version used should be 6.0 or later and Python version
3.13 and above.
Recapitulation of Class XI Sections B - Programming in Java
(i) Introduction to object oriented programming using Java (ii) Objects (iii) Primitive values, Wrapper classes,
Types and casting (iv) Variables, Expressions (v) Statements, Scope (vi) Methods and constructors (vii) Arrays
,Strings
While recapitulating, ensure that higher order problems are solved using these constructs.

3. Methods - Object as parameter and return data type
Methods (as abstractions for complex user defined operations on objects), formal arguments and actual
arguments in methods; different behaviour of primitive and object arguments. Static method and variables.
The this Operator – as a reference of the current object. Passing objects /arrays as parameters to a method and
returning an object / array.

4. Arrays (Single and Double dimensional), String handling
(a) Structured data types – arrays (single and multi- dimensional), address calculations. Algorithms that use
structured data types (e.g. searching, finding maximum/minimum, sorting techniques, solving systems of
linear equations)
Storing many data elements of the same type requires structured data types – like arrays. Access in arrays
is constant time and does not depend on the number of elements. Address calculation (row major and
column major), Sorting techniques (bubble, selection, insertion).
(b) String handling - substring, concatenation, length, access to char in string, etc.
Structured data types can be defined by classes – String. Introduce the Java library String class and the
basic operations on strings (accessing individual characters, various substring operations,
concatenation, replacement, index of operations). The class StringBuffer should be introduced for those
applications that involve heavy manipulation of strings.

10

5. Recursion
Concept of recursion, simple recursive methods (e.g. factorial, GCD, binary search, conversion of
representations of numbers between different bases).
Many problems can be solved very elegantly by observing that the solution can be composed of solutions to
‘smaller’ versions of the same problem with the base version having a known
simple solution. Recursion can be initially motivated by using recursive equations to define certain methods.
These definitions are fairly obvious and are easy to understand. The definitions can be directly converted to
a program. Emphasize that any recursion must have a base case. Otherwise, the computation can go into an
infinite loop.
The tower of Hanoi is a very good example of how recursion gives a very simple and elegant solution where
as non-recursive solutions are quite complex.

6. Inheritance and Interfaces
(a) Inheritance; super and derived classes; member access in derived classes; redefinition of variables and
methods in subclasses; abstract classes; class Object; protected visibility. Subclass polymorphism and
dynamic binding.
Emphasize inheritance as a mechanism to reuse a class by extending it. Inheritance should not normally
be used just to reuse some methods defined in a class but only when there is a genuine specialization (or
subclass) relationship between objects of the super class and that of the derived class.
(b) Interfaces in Java (Only Conceptual)
Emphasize the difference between the Java language construct interface and the word interface often used
to describe the set of method prototypes of a class.

SECTION C - PYTHON AND CONCEPTUAL ASPECTS

7. Programming in Python
(a) Recapitulation of Class XI Section C
(i) Data types (ii) Data Processing in Python (iii) Operators and expressions (iv) Flow of control
While recapitulating, ensure that higher order problems are solved using these constructs.
(b) Strings: introduction, string operations (concatenation, repetition, membership and slicing), traversing a
string using loops, built-in functions/methods–len(), capitalize(), title(), lower(), upper(), count(), find(),
index(), endswith(), startswith(), isalnum(), isalpha(), isdigit(), islower(), isupper(), isspace(),lstrip(),
rstrip(), strip(), replace(), join(), partition(), split()
(c) Lists: introduction, indexing, list operations (concatenation, repetition, membership and slicing),
traversing a list using loops, built-in functions/methods–len(), list(), append(), extend(), insert(), count(),
index(), remove(), pop(), reverse(), sort(), sorted(), min(), max(), sum(); nested lists, suggested programs:
finding the maximum, minimum, mean of numeric values stored in a list; linear search on list of numbers
and counting the frequency of elements in a list.
(d) Tuples: introduction, indexing, tuple operations (concatenation, repetition, membership and slicing);
built-in functions/methods – len(), tuple(), count(), index(), sorted(), min(), max(), sum(); tuple
assignment, nested tuple; suggested programs: finding the minimum, maximum, mean of values stored in
a tuple; linear search on a tuple of numbers, counting the frequency of elements in a tuple.

8. Data structures – Binary trees [ Conceptual ]
Binary trees: apart from the definition the following concepts should be covered: root, internal nodes,
external nodes (leaves), height (tree, node), depth (tree, node), level, size, degree, siblings, sub tree,
traversals (pre, post and in-order).

11

9. Complexity and Big O notation
Concrete computational complexity; concept of input size; estimating complexity in terms of methods;
importance of dominant term; constants, best, average and worst case.
Big O notation for computational complexity; analysis of complexity of example algorithms using the big O
notation (e.g. Various searching and sorting algorithms, algorithm for solution of linear equations, etc.).

PAPER II (PRACTICAL) : 30 MARKS
This paper of three hours’ duration will be evaluated by the Visiting Examiner appointed locally and approved by
CISCE.
The paper shall consist of three programming problems from which a candidate has to attempt any one. The
practical consists of the two parts:
1. Planning Session
2. Examination Session
The total time to be spent on the Planning session and the Examination session is three hours. A maximum of
90 minutes is permitted for the Planning session and 90 minutes for the Examination session.
Candidates are to be permitted to proceed to the Examination Session only after the 90 minutes of the
Planning Session are over.
Planning Session
The candidates will be required to prepare an algorithm and a hand written Java program to solve the problem.

Examination Session
The program handed in at the end of the Planning session shall be returned to the candidates. The candidates will
be required to key-in and execute the Java program on seen and unseen inputs individually on the computer and
show execution to the Visiting Examiner. A printout of the program listing including output results should be
attached to the answer script containing the algorithm and handwritten program. This should be returned to the
examiner. The program should be sufficiently documented so that the algorithm, representation and development
process is clear from reading the program. Large differences between the planned program and the printout will
result in loss of marks.
Teachers should maintain a record of all assignments completed as part of the practical work throughout the year
and give them due credit during the cumulative evaluation at the end of the year. Students are expected to complete
a minimum of twenty-five assignments (20 programs in Java and 5 programs in Python) during the year. The
assignments may be submitted to the school in handwritten or typed form (hard copy or soft copy), or as
PowerPoint presentations (PPTs).
TOPIC WISE BREAKUP OF ASSIGNMENTS
Java – minimum of 20 programs
• Five programs based on Methods – Object as a parameter and return data type
• Three programs based on Single dimensional arrays
• Five programs based on Double dimensional arrays
• Four programs based on String handling
• Three programs based on Inheritance
Note: All programs should be based on classes and objects.

Python – minimum of 5 programs
• One program based on Strings

12

• Two programs based on the concept of Lists
• Two programs based on the concept of Tuples

EVALUATION:
Marks (out of a total of 30) should be distributed as given below:
Continuous Evaluation
Candidates will be required to submit a work file containing the practical work related to programming
assignments done during the year.
Programming assignments done throughout the year (Internal Evaluation) 10 marks

Programming assignments done 5 marks
throughout the year (Visiting Examiner)
Terminal Evaluation

Solution to Java programming problem on the computer 15 Marks

Marks should be given for choice of algorithm and implementation strategy, documentation, correct output on
known inputs mentioned in the question paper, correct output for unknown inputs available only to the examiner.
NOTE:
Algorithm should be expressed clearly using any standard scheme such as a pseudo code.

EQUIPMENT
There should be enough computers to provide for a teaching schedule where at least three-fourths of the time
available is used for programming.
Schools should have equipment/platforms such that all the software required for practical work runs properly, i.e.
it should run at acceptable speeds.
Since hardware and software evolve and change very rapidly, the schools may have to upgrade them as required.
Following are the recommended specifications as of now:
The Facilities:
• A lecture cum demonstration room with a MULTIMEDIA PROJECTOR/ an LCD and O.H.P. attached to
the computer.
• A white/green board with markers should be available.
• A fully equipped Computer Laboratory that allows one computer per student.
• Local area network (LAN) with high speed internet facility.
• The computers should have a minimum of 2 GB RAM and a dual core processor. The basic requirement
is that it should run the operating system, Java and Python programming system at acceptable speeds.
• Good Quality printers.

Software:
• Any suitable Operating System can be used.
• JDK 6 or later and Python 3.13 or later.
• A suitable text editor for Java and Python.

13

SAMPLE TABLE FOR PRACTICAL WORK
Assessment of Assessment of the Practical Examination TOTAL MARKS
Practical File (To be evaluated by the Visiting Examiner only) (Total Marks are to
Unique be added and
Identification Internal Visiting Algorithm Java Program with Hard Output entered by the
S. No. Number (Unique Evaluation Examiner internal Copy Visiting Examiner)
ID) of the 10 Marks 5 Marks Documentation (printout)
candidate 3 Marks 7 Marks 2 Marks 3 Marks 30 Marks

1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

Name of the Visiting Examiner: _________________________ Signature:____________________________

Date_________________________________

14