On this page
ISC computer science is two subjects in one: a mathematics of logic gates and Boolean expressions, and a programming course in Java that ends with linked lists and complexity analysis. The practical adds a twist few students expect: you write the algorithm and program by hand before you touch a computer. This post covers what CISCE lists for ISC 2027, how the practical runs, and two worked examples from Section B.
How are ISC 2027 computer science marks divided?
The CISCE ISC 2027 Computer Science syllabus gives Class XII two papers: Paper I, Theory, 3 hours and 70 marks; and Paper II, Practical, 3 hours and 30 marks. The theory is organised in three sections:
Section A: Boolean algebra and hardware. Propositional logic and well-formed formulae, laws of Boolean algebra, sum-of-products and product-of-sums forms, Karnaugh maps up to four variables, logic gates, half and full adders, encoders, decoders, multiplexers, and NAND and NOR as universal gates.
Section B: Java programming. Objects and constructors, Scanner and StringTokenizer input, wrapper classes and casting, methods and the this operator, arrays including row-major and column-major address calculation, bubble, selection and insertion sort, strings and StringBuffer (a mutable sequence of characters), and recursion.
Section C: inheritance, data structures and complexity. Inheritance, interfaces and polymorphism; stack, queue, circular queue and dequeue; infix to prefix and postfix; single linked lists; binary trees and traversals at concept level; and Big O notation.
The syllabus says the programming parts aim at "algorithmic problem solving and not merely rote learning of Java syntax." CISCE issues a syllabus for each examination year, so check yours.
How does the 30-mark practical work?
The practical paper gives three programming problems, of which you attempt one. It has two parts within three hours:
Planning session, up to 90 minutes. You write an algorithm and a handwritten Java program.
Examination session, 90 minutes. You type and run the program on seen and unseen inputs, show it to the Visiting Examiner, and attach a printout.
The syllabus warns that "large differences between the planned program and the printout will result in loss of marks." The 30 marks are split as programming assignments during the year (10 internal, 5 by the Visiting Examiner) and the exam itself (15: algorithm 3, program with documentation 7, printout 2, output 3). You are expected to complete at least twenty-five assignments in the year.
Worked example: array address calculation
A two-dimensional array A[10][20] (rows 0 to 9, columns 0 to 19) starts at base address 1000, and each element takes 2 bytes. Find the address of A[5][8].
Row-major order stores whole rows one after another. Address = B + W × (i × C + j) = 1000 + 2 × (5 × 20 + 8) = 1000 + 2 × 108 = 1216.
Column-major order stores whole columns. Address = B + W × (j × R + i) = 1000 + 2 × (8 × 10 + 5) = 1000 + 2 × 85 = 1170.
Common mistakes: swapping R and C; forgetting to subtract the lower bounds when indices do not start at 0; and multiplying by W only for part of the expression.
Worked example: tracing a recursive method
static int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}Trace gcd(84, 36):
gcd(84, 36): 84 % 36 = 12, so call gcd(36, 12).
gcd(36, 12): 36 % 12 = 0, so call gcd(12, 0).
gcd(12, 0): b is 0, the base case, so return 12.
The answer is 12, after three calls. We ran both examples to confirm the values. The syllabus stresses that "any recursion must have a base case"; without b == 0, this method would never stop. For more practice, see our posts on ISC Java recursion and, for Section A, Karnaugh maps for ISC.
Why practise by writing code from memory?
A review of ten study techniques by Dunlosky and colleagues (2013) rated practice testing and spaced practice as the most useful, ahead of rereading. For computer science, a practice test means writing an algorithm or a stack class on paper without notes, then running it. It is also exactly what the planning session asks of you.
A practice routine for the term
Daily, 20 minutes: trace one recursive method or one Boolean simplification by hand.
Weekly: one full practical problem: 60 minutes planning on paper, then type, run and compare.
Weekly: implement one data structure (stack, queue, linked list) with insert, delete and display.
Fortnightly: two Big O questions: count the loops and name the dominant term.
When a concept such as dynamic binding or a circular queue does not make sense from notes, the Fermi Concept Library covers every concept in computing with its own lesson.
This week, do one past practical problem with a strict 90-minute planning session before you open BlueJ.
