ISO 9001:2015 Certified MSME Registered 4.8 Rating ISC Board Aligned

School Curriculum Course

ISC Class 11 Computer
Science Syllabus in Howrah & Kolkata

Master the complete ISC Class 11 Computer Science syllabus — all 17 chapters across Section A (numbers, encodings, computer architecture & logic), Section B (algorithmic problem solving with Java) and Section C (data structures, recursion, complexity & ethics) — with full training for the 70-mark Theory paper and the 30-mark Practical paper.

Number Systems Logic Gates Java + BlueJ Arrays & Strings Data Structures

2/Week

Classes

12 Months

Duration

Units

10–15

Batch Size

Enroll Now Call: 9239412412

Course Details

What You Get

Everything a Class 11 student needs to ace ISC Computer Science — 17 chapters of structured learning from number systems and computer architecture through Java programming, data structures, recursion and computational complexity — fully aligned with the ISC Board syllabus.

Number Systems & Encodings

Chapters 1–2: base conversions (binary, octal, decimal, hexadecimal), addition & subtraction in any base, sign-magnitude, two's complement, floating point, ASCII & Unicode — with overflow, underflow and precision limits.

Computer Architecture & Logic

Chapters 3–7: the block diagram of a computer, the Simple Hypothetical Computer (SHC), propositional logic, gates & adders, the memory hierarchy, and system software with the full boot process.

Java Programming

Chapters 8–13: algorithmic problem solving, objects & classes, constructors, primitive types & wrapper classes, variables, expressions, statements, scope and functions — taught the 'objects first' way with BlueJ.

Arrays, Strings & JVM

Chapter 14: single & multi-dimensional arrays, sorting (bubble, selection, insertion) & searching, the String class, the Java Virtual Machine, and compile-time vs run-time errors with exceptions.

Data Structures & Recursion

Chapter 15: encapsulation & interfaces, stacks, queues and deques, file I/O with the Scanner & File classes, StringTokenizer, recursion and computational complexity (best/average/worst case).

Theory + Practical Exam Prep

Paper I (70 marks) & Paper II (30 marks) pattern training — 20+ lab assignments in a graded work file, planning & examination session practice, viva-voce and board-pattern worksheets.

Complete Syllabus

ISC Class 11 Computer Science Syllabus

All 17 chapters of the official ISC Class 11 syllabus — Section A (Basic Computer Hardware & Software), Section B (Algorithmic Problem Solving with Java) and Section C (Data Structures, Algorithms & Ethics) — with extra notes, examples and exam pointers added to every chapter.

Section A — Basic Computer Hardware & Software

How computers represent, store and process data — number systems and binary encodings, the block diagram of a computer, the architecture of a simple processor, propositional logic and gates, the memory hierarchy, and system software including the boot process.

Chapters 1–7 Paper I · Section A Hardware + Logic

Data Representation · Chapters 1 & 2

Numbers Representation of numbers in different bases — binary, octal, decimal and hexadecimal — and interconversion between them; addition and subtraction operations for numbers in different bases. Extra focus: the positional system of representing numbers and the concept of a base; conversion algorithms expressed in English/pseudo code (these become great examples of functions in a class when programming starts); how carry works — the analogy with decimal addition that later makes binary adders easy to understand.

Binary Encodings for Integers & Real Numbers Encoding integers and real numbers using a finite number of bits — sign-magnitude, two's complement and mantissa-exponent notation; basic operations on integers and floating point numbers; limitations of finite representations. Extra focus: signed vs unsigned numbers, least and most significant bits; why sign-magnitude fails (two representations of 0, addition needs an extra step) and why two's complement wins; normalized scientific notation, the binary point and the trade-off between mantissa and exponent size; single & double precision; overflow, underflow and lack of associativity demonstrated through actual programs.

Character Encodings — ASCII & Unicode Characters and their encodings using ASCII and Unicode. Extra focus: the limitations of the ASCII code in representing characters of other languages; Unicode representation for the local language — since Java uses Unicode, strings in the local language can be used and displayed (if fonts are available); a simple table lookup for local-language equivalents of Latin character strings can be done; more details at www.unicode.org.

Computer Organization · Chapters 3–7

High Level Structure of a Computer Block diagram of a computer system with details of (i) the function of each block and (ii) inter-connectivity, data flow and control flow between the blocks. Extra focus: developing the diagram by successive refinement of blocks — ALU, RAM, cache, the buses (modern computers have multiple buses), the disk and its controller, and input/output ports (serial, parallel, USB, network, modem, line-in, line-out) with the devices that attach to them — keyboard, mouse, monitor, CD-ROM, DVD, audio input/output devices, printer and more.

Basic Architecture of a Simple Processor & Its Instruction Set The Simple Hypothetical Computer (SHC) — the basic structure of a processor: registers, a basic instruction set, the structure of an instruction, the program counter, and addressing modes (immediate, direct, register, register-indirect). Extra focus: writing simple programs in the SHC instruction set such as finding the maximum/minimum of a set of numbers — a miniature model that mirrors exactly how a real CPU works.

Propositional Logic, Hardware Implementation, Arithmetic Operations (a) Propositional variables; the common logical connectives — ~ (not/negation), ∧ (and/conjunction), ∨ (or/disjunction), ⇒ (implication), ⇔ (equivalence); definition of a well-formed formula (wff); representing simple word problems as wffs; truth values and interpretation of a wff; truth tables; satisfiable, unsatisfiable and valid formulae. (b) Logic and hardware — basic gates (AND, NOT, OR) and their universality; other gates (NAND, NOR, XOR); the inverter, half adder and full adder. Extra focus: how the logic of (a) is realized in hardware as gates; gates combined to implement the basic arithmetic operations — tying up directly with two's complement integer arithmetic from Chapter 2; a chain of full adders is exactly how binary addition is performed inside the ALU.

Memory Memory organization and access; parity; the memory hierarchy — cache, primary memory, secondary memory. Extra focus: the access-time differences between the different kinds of memory; size differences; locality of reference and why cache memory exploits it to make computers dramatically faster.

System & Other Software The boot process step-by-step from power on till the prompt; the operating system as a resource manager — managing processor, memory and I/O — and command processing; files, directories and the file system; commonly available programs (editors, compilers, interpreters, word processors, spreadsheets etc.). Extra focus: what "managing resources" actually means; the logical structure of data storage on disk using logical disks, hierarchical directories and files; distinguishing interpreters from compilers — in particular the javac and java programs.

Section B (Part 1) — Objects & Java Fundamentals

Algorithmic problem solving with Java — the problem-solving cycle, objects as data + behaviour, classes and constructors, primitive types and wrapper classes, variables, expressions, type coercion and casting. Java 1.5 or later; BlueJ strongly recommended for its 'objects first' simplicity.

Chapters 8–11 Paper I · Section B Java 1.5+ · BlueJ

Introduction to Algorithmic Problem Solving Using Java The complete problem-solving cycle: devising algorithmic solutions to problems and coding, validating, documenting, executing and debugging them using the Java programming system. Extra focus: the programming element here is aimed at algorithmic problem solving and not rote learning of Java syntax; students may use any text editor with javac and java, or a development environment such as BlueJ, Eclipse or NetBeans — BlueJ (www.bluej.org) and Greenfoot (www.greenfoot.org) are strongly recommended for an 'objects first' approach; topics 9–13 get introduced almost simultaneously once classes and their definitions are introduced.

Objects (a) Objects as data (attributes) + behaviour (methods or functions); an object as an instance of a class; constructors. (b) Analysis of some real-world programming examples in terms of objects and classes. Extra focus: the difference between an object and a class made very clear; the constructor as a special kind of function; the new operator; multiple constructors with different argument structures; how a constructor returns a reference to the object; simple examples like a calculator, date or number treated as objects that behave in well-defined ways with the interface providing access to behaviour; changing behaviour by adding new functions, deleting old ones or modifying existing ones.

Primitive Values, Wrapper Classes, Types & Casting Primitive values and types — int, short, long, float, double, boolean, char — and the corresponding wrapper class for each primitive type. Extra focus: class as the type of an object and class as the mechanism for user-defined types; ideally everything should be a class and primitive types exist purely for efficiency reasons; changing types through user-defined casting and automatic type coercion for some primitive types (e.g. mixed type expressions) — and why casting in general is not a good idea and should be avoided if possible.

Variables & Expressions Variables as names for values; expressions (arithmetic and logical) and their evaluation — operators, associativity, precedence; the assignment operation and the difference between the left-hand side and right-hand side of an assignment. Extra focus: variables denote values and are already defined as attributes in classes; variable types constrain the values they can denote; the crucial difference between variables denoting primitive values and object values — variables denoting objects are references to those objects; in i = i + 2, the variable on the LHS denotes the memory location while the same variable on the RHS denotes the contents of that location.

Section B (Part 2) — Statements, Scope & Functions

Control flow in Java — conditionals, loops, blocks and scope — followed by functions/methods: arguments, side effects, static members, the this variable and the main method, with classic number-theory and equation-solving problems.

Chapters 12–13 Paper I · Section B Loop Mastery

Statements & Scope Conditional statements — if, if-then-else, switch-break and the ?: ternary operator; looping — for, while-do, do-while, continue and break; grouping statements in blocks; scope and visibility of variables. Extra focus: detailed semantics of conditional and looping statements; the exact difference between || and | and between && and &; fall-through behaviour in switch; many small pattern-printing examples (highly instructive for loops); use for when the number of iterations is known in advance, otherwise while-do or do-while; expressing one loop construct using the others — for(init; test; inc) stmt; is equivalent to init; while(test){stmt; inc} and to the do-while form; nesting of blocks; variables with block scope, function scope and class scope; visibility rules when same-named variables are defined in different scopes.

Functions Functions/methods as abstractions for complex user-defined operations on objects; functions as mechanisms for side effects; formal arguments and actual arguments; the different behaviour of primitive and object arguments. Extra focus: functions are like complex operations where the object is implicitly the first argument; the variable this denotes the current object; functions may return values or cause side effects (typically functions that only cause side effects return void — e.g. set functions); Java passes arguments by value — changes made inside functions persist after the call for object values but not primitive values; static definitions as class variables and class functions visible and shared by all instances, and why they are needed; introducing the main method — needed to begin execution; algorithmic problem solving using functions — various number theoretic problems and finding roots of algebraic equations.

Section B (Part 3) — Arrays, Strings & the JVM

Structured data types — arrays and strings — with searching, sorting and matrix algorithms; the String class; the concept of a virtual machine and how Java compiles and executes; and errors, exceptions, catch and throw.

Chapter 14 Sorting & Searching JVM & Exceptions

14a

Arrays & Strings — Structured Data Types Single and multi-dimensional arrays, and strings; example algorithms that use structured data types — searching, finding maximum/minimum, sorting techniques, solving systems of linear equations, substring, concatenation, length, access to char in string etc. Extra focus: storing many data elements of the same type requires structured data types — access in arrays is constant time and does not depend on the number of elements; sorting techniques — bubble, selection and insertion; structured data types can be defined by classes — the Java library String class and its basic operations: accessing individual characters, substring operations, concatenation, replacement and indexOf.

14b

Basic Concept of a Virtual Machine — the JVM The Java Virtual Machine; compilation and execution of Java programs (the javac and java programs). Extra focus: the JVM is a machine but built as a program and not through hardware — that is why it is called a virtual machine; to run, JVM machine language programs require an interpreter (the java program); the advantage — such JVM machine language programs (.class files) are portable and can run on any machine that has the java program.

14c

Compile Time & Run Time Errors; Exceptions Differentiating between compile time and run time errors; the basic concept of an exception; the Exception class; catch and throw. Extra focus: run time errors crash the program, but recovery is possible through exceptions; how an exception object is created and passed up until a matching catch is found — behaviour very different from a value returned by a deeply nested function call; subclasses of Exception are discussed in Class XII after inheritance.

Section C — Data Structures, Algorithms & Ethical Issues

Classes as contracts and interfaces; stacks, queues and deques with their behavioural rules; basic input/output with Scanner, Printer and File classes; recursion; computational complexity; lab implementation of algorithms; and the social context of computing with its ethical debates.

Chapters 15–17 Paper I · Section C Practicals + Lab

15a

Class as a Contract — Encapsulation Class as the basic reusable unit; its function prototypes (the interface) work as a visible contract with the outside world since others will use these functions in their programs. Extra focus: separating implementation from interface; this leads to encapsulation — hiding implementation information — which in turn leads to the use of private and public for realizing encapsulation.

15b

Interfaces in Java Motivation for interfaces: often when creating reusable classes, some parts of the exact implementation can only be provided by the final end user — for example, in a class that sorts records of different types, the exact comparison operation can only be given by the user, who alone knows which field(s) to compare on and whether sorting is ascending or descending. Extra focus: implementing interfaces through a class; interfaces for user-defined implementation of behaviour; the difference between the Java language construct interface and the word 'interface' often used to describe the set of function prototypes of a class.

15c

Stack, Queue & Dequeue Basic data structures (stack, queue, dequeue); implementation directly through classes; definition through an interface with multiple implementations; basic algorithms and programs using them. Extra focus: a data structure is a data collection with well defined operations and behaviour — the behaviour can be expressed formally (e.g. LIFO: if s.push(o) and then o1 = pop(), then o ≡ o1; popping an empty stack gives ERROR); any implementation must guarantee these rules hold. Algorithms — for stack: parentheses matching, Tower of Hanoi, nested function calls and solving a maze; for queue: scheduling processes, printers and jobs in a machine shop.

15d

Basic Input/Output — Scanner, Printer, File & StringTokenizer Basic input/output using the Scanner and Printer classes from the JDK; files and their representation using the File class; file input/output; input/output exceptions. Extra focus: the Scanner class for input of various types of data (int, float, char etc.) from the standard input stream or a file input stream; the File class models file objects in the underlying system in an OS-independent manner; tokens in an input stream — a delimited continuous stream of characters meaningful to the application (e.g. words in a sentence with blank as delimiter); whitespace and user-defined delimiters; extracting tokens from a string with the StringTokenizer class.

15e

Recursion The concept of recursion and simple recursive functions — factorial, GCD, binary search, conversion of representations of numbers between different bases. Extra focus: many problems are solved elegantly by composing solutions to 'smaller' versions of the same problem with a known base case; recursion is motivated by recursive definitions converted directly into programs; any recursion must have a base case — remove it and the computation loops forever (demonstrated by running the program!); classic definitions — factorial(0)=1, factorial(n)=n×factorial(n−1); gcd(m,n); fib(0)=fib(1)=1, fib(n)=fib(n−1)+fib(n−2); the Tower of Hanoi as the showpiece where recursion is simple and elegant while non-recursive solutions are complex; using a stack to keep track of function calls, and even to solve Tower of Hanoi non-recursively.

15f

Concrete Computational Complexity Concept of input size; estimating complexity in terms of functions; importance of the dominant term; best, average and worst case. Extra focus: algorithms are compared on space and time — time is usually more important; actual run time is a poor basis (it depends on the computer's speed, RAM, OS and compiler quality), so we approximate the number of operations as a function of input size; loops decide complexity — bubble sort's two nested loops give time proportional to n(n−1) in the worst case, linear search gives n; best/worst/average cases (average is harder — it depends on data distribution, e.g. uniformly distributed elements take ~n/2 comparisons); comparisons are made for large input sizes so the dominant term matters — for a·n² + b·n + c, only n² counts for large n.

Implementation of Algorithms to Solve Problems Lab assignments in the computer lab run concurrently with the lectures; programming assignments are designed so that each major topic is covered in at least one assignment. Extra focus: assignment problems are non-trivial and make the student do algorithm design, address correctness issues, implement and execute the algorithm in Java and debug where necessary; students complete a minimum of twenty assignments for the year — recorded in the work file and given credit in the internal practical evaluation.

Social Context of Computing & Ethical Issues (a) Intellectual property and corresponding laws and rights; software as intellectual property. (b) Software copyright and patents and the difference between the two; trademarks; software licensing and piracy. (c) The Free Software Foundation and its position on software; open source software; various types of licensing (e.g. GPL, BSD). (d) Privacy, email etiquette, spam, security issues, phishing. Extra focus: these social and ethical issues are discussed and debated in class — students learn that these are complex issues with multiple points of view and no single 'correct' or 'right' view.

ISC Exam Pattern

Paper I — Theory · 70 Marks · 3 Hours

Part I — 20 Marks · Compulsory Short Answers

Part II — 50 Marks · Sections A + B + C

Sections A & B — 2 of 3 Qs × 10 Marks

Section C — 2 of 3 Qs × 5 Marks

Paper II — Practical · 30 Marks · 3 Hours

Planning Session — 90 min · Algorithm + Handwritten Java

Exam Session — 90 min · Seen & Unseen Inputs

Internal Assignments — 10 Marks (20 Programs)

Terminal Program 15 + Viva 5 Marks

Learning Outcomes

What You'll Achieve

By the end of this course, a Class 11 student moves from "knowing Java syntax" to genuinely understanding the science of computing — and being exam-ready for both papers.

Master Number Systems & Encodings

Confidently convert between binary, octal, decimal and hexadecimal, perform arithmetic in any base, and understand two's complement and floating point — including overflow, underflow and precision limits.

Understand the Machine

Explain the block diagram of a computer, how the ALU, memory, buses and I/O ports interact, and how a simple processor executes instructions using different addressing modes.

Think in Logic

Build truth tables, validate well-formed formulae, and understand how AND, OR, NOT, NAND, NOR and XOR gates combine into inverters, half adders and full adders.

Program in Java

Devise algorithmic solutions and code, validate, document, execute and debug them in Java — objects, constructors, control flow, functions, arrays and strings.

Solve with Data Structures

Implement stacks, queues and deques through classes and interfaces, handle file I/O, and apply recursion and complexity analysis to pick the most efficient algorithm.

Score in Theory + Practical

Targeted preparation for Paper I (70 marks) and Paper II (30 marks) — chapter-wise worksheets, 20+ lab assignments in a work file, board-pattern programs and viva training.

Ideal Students

Who Should Join

This course is built for students entering Class 11 under the ISC board who want structured, board-focused Computer Science teaching from day one.

ISC Class 11 Students

Students of any stream — Science, Commerce or Humanities — who have chosen Computer Science as a subject and want clear, structured teaching of every chapter in Sections A, B and C.

ICSE Class 10 Graduates

Students stepping up from ICSE Computer Applications who already know basic Java and now want to go deeper — into how computers actually work, data structures, recursion and complexity.

Board Exam Achievers

Students aiming for top marks in both the 70-mark theory paper and the 30-mark practical — including the 20-assignment work file, the planning & examination sessions and the viva-voce.

Common Questions

Frequently Asked Questions

What is the fee for the ISC Class 11 Computer Science course at PBA Institute?

The fee is ₹800 per month for the Batch Class, which runs 2 classes a week with a batch size of 10–15 students.

Is this course aligned with the ISC Class 11 syllabus?

Yes. The course strictly follows the official ISC Class 11 Computer Science syllabus — all 17 chapters across Section A (Basic Computer Hardware & Software), Section B (algorithmic problem solving with Java) and Section C (data structures, algorithms, implementation and ethics) — fully preparing students for the 70-mark theory paper and the 30-mark practical paper.

How is the practical paper (Paper II) prepared?

Students practise the exact board pattern: a 90-minute Planning Session (algorithm + handwritten Java program) followed by a 90-minute Examination Session (keying-in and executing the program on seen and unseen inputs). We maintain a year-long work file of 20+ programming assignments plus viva-voce training — matching the 10 (internal) + 15 (program) + 5 (viva) marks split.

What new topics does ISC Class 11 cover compared to ICSE Class 10?

ISC Class 11 goes far beyond Java syntax — number systems and base conversions, binary encodings (two's complement, floating point), computer architecture and the Simple Hypothetical Computer, propositional logic and gates (half and full adders), memory hierarchy, the JVM and exceptions, stacks, queues and deques, recursion, computational complexity, and the social context of computing and ethical issues.

Which tools and environments are used?

Java 1.5 or later with the javac and java programs; BlueJ is strongly recommended for its simplicity and 'objects first' approach — Eclipse, NetBeans or any text editor also work. We help with complete JDK and BlueJ installation on students' laptops.

Are classes available online and offline?

Yes — students can attend at our Howrah centre or join online, taught in Bengali, Hindi and English, Monday to Saturday 8am–8pm.

Ready to Ace ISC Class 11 Computer Science?

Seats are limited to 10–15 students per batch so every student gets personal attention in theory, programming and practicals. Enroll today and start your journey from Class 10 Java to real Computer Science.