computer science _868_

Document Sample
computer science _868_ Powered By Docstoc
					                                     COMPUTER SCIENCE (868)

                                             CLASS XI (Syllabus)

Aims (Conceptual)                                          Part II (70 marks): This part will be divided into
                                                           three Sections, A, B and C. Candidates are required to
1. To understand algorithmic problem solving using
                                                           answer three questions out of four from Section A and
   data abstractions, functional and procedural
                                                           two questions out of three in each of the sections B
   abstractions, and object based and object oriented
   abstractions.                                           and C. Each question in this part shall carry 10
                                                           marks.
2. To understand: a) how computers represent, store
   and process data by studying the architecture and
   machine language of a simple microprocessor and
                                                                               SECTION A
   the different levels of abstraction that mediate
   between the machine and the algorithmic problem         Basic Computer hardware and software:
   solving level and b) how they communicate with
   the outside world.                                      Numbers

3. To create awareness of ethical problems and             a) Representation of numbers in different bases and
   issues related to computing.                            interconversion between them (e.g. binary, octal,
                                                           decimal, hexadecimal). Addition and subtraction
Aims (Skills)                                              operations for numbers in different bases.

1. To devise algorithmic solutions to problems and         Encodings
   to be able to code, validate, document, execute         b) Binary encodings for integers and real numbers
   and debug the solution using the Java                   using a finite number of bits (sign-magnitude, twos
   programming system.                                     complement, mantissa-exponent notation). Basic
Important Notes:                                           operations on integers and floating point numbers.
                                                           Limitations of finite representations.
a) The syllabus must be read in conjunction with the
scope document which contains more details and             c) Characters and their encodings (e.g. ASCII,
explanatory material for items in the syllabus.            Unicode).

b) The problems and examples mentioned at various
places in the syllabus and scope documents are only
indicative in nature and definitely not exhaustive.

                                                           High level structure of computer
There will be two papers in the subject:
                                                           d) Block diagram of a computer system with details of
Paper I: Theory -                3 hours ….100 marks       i) function of each block and ii) interconnectivity and
Paper II: Practical -            3 hours ….100 marks       data and control flow between the various blocks.
                                                           Basic architecture of typical simple processor and
                PAPER I -THEORY                            its assembly language
Paper 1 shall be of 3 hours duration and be divided        e) Basic architecture of the 8085 microprocessor.
into two parts.                                            Instruction set, addresses, addressing modes, simple
                                                           machine language programs using the different
Part I (30 marks): This part will consist of               addressing modes, execution of machine language
compulsory short answer questions, testing                 programs, input and output.
knowledge, application and skills relating to the entire
syllabus.
                                                       1071
                                                       14
f) Assembly language of 8085, simple assembly                b) Analysis of some real world programming
language programs, assembly process and assembler.           examples in terms of objects and classes.
Propositional logic, hardware implementation,                Primitive values, wrapper classes, types and
arithmetic operations                                        casting
g) Propositional logic, well formed formulae, truth          c) Primitive values and types: int, short, long, float,
values and interpretation of well formed formulae,           double, boolean, char. Corresponding wrapper classes
truth tables.                                                for each primitive type. Class as type of the object.
                                                             Class as mechanism for user defined types. Changing
h) Logic and hardware, basic gates (AND, NOT, OR)
                                                             types through user defined casting and automatic type
and their universality, other gates (NAND, NOR,
                                                             coercion for some primitive types.
XOR); inverter, half adder, full adder.
                                                             Variables, expressions
Memory
                                                             d) Variables as names for values; expressions
i) Memory - construction of a memory bit using a flip-
                                                             (arithmetic and logical) and their evaluation
flop, D-flip-flop and its use in constructing registers.
                                                             (operators, associativity, precedence). Assignment
j) Memory organization and access; parity; memory            operation; difference between left hand side and right
hierarchy - cache, primary memory, secondary                 hand side of assignment.
memory.
                                                             Statements, scope
System and other software
                                                             e) Statements; conditional (if, if-then-else, switch-
k) Boot process. Operating system as resource                break, ?: ternary operator), looping (for, while-do, do-
manager, command processing, files, directories and          while, continue, break); grouping statements in
file system. Commonly available programs (editors,           blocks, scope and visibility of variables.
compilers, interpreters, word processors, spread sheets
                                                             Functions
etc.).
                                                             f) Functions/methods (as abstractions for complex
                                                             user defined operations on objects), functions as
                                                             mechanisms for side effects; formal arguments and
                                                             actual arguments in functions; different behaviour of
                                                             primitive and object arguments. Static functions and
                     SECTION B
                                                             variables. The this variable. Examples of algorithmic
The programming element in the syllabus is aimed at          problem solving using functions (various number
algorithmic problem solving and not merely rote              theoretic problems, finding roots of algebraic
learning of Java syntax. The Java version used should        equations).
be 1.5 or later. For programming, the students can use       Arrays, strings
any text editor and the javac and java programs or any
development environment: for example, BlueJ,                 g) Structured data types – arrays (single and multi-
Eclipse, NetBeans etc. BlueJ is strongly recommended         dimensional), strings. Example algorithms that use
for its simplicity, ease of use and because it is very       structured data types (e.g. searching, finding
well suited for an ‘objects first’ approach.                 maximum/minimum, sorting, solving systems of
                                                             linear equations, substring, concatenation, length,
Introduction to algorithmic problem solving using            access to char in string, etc.).
Java                                                         h) Basic concept of a virtual machine; Java virtual
Objects                                                      machine; compilation and execution of Java programs
                                                             (the javac and java programs).
a) Objects as data (attributes) + behaviour (methods or
functions); object as an instance of a class.                i) Compile time and run time errors; basic concept of
Constructors.                                                an exception, the Exception class, catch and throw.



                                                          1081
                                                          14
                    SECTION C                               i) Free software foundation and its position on
Elementary data structures          and     associated      software, open source software, various types of
algorithms, basic input/ouput,                              licensing (e.g. GPL, BSD).

a) Class as a contract; separating implementation from      j) Privacy, email etiquette, spam, security issues,
interface; encapsulation; private and public.               phising.

b) Interfaces in Java; implementing interfaces through      (Questions on social context of computing and ethical
a class; interfaces for user defined implementation of      issues should be short answer questions and should be
behaviour .                                                 asked only in Part I).

c) Basic data structures (stack, queue, dequeue);
implementation directly through classes; definition                      PAPER II - PRACTICAL
through an interface and multiple implementations
by implementing the interface. Basic algorithms using       This paper will be evaluated internally by the school.
the above data structures.                                  The evaluation shall consist of a 3-hour practical
d) Basic input/output using Scanner and Printer             examination at the end of the year and evaluation of
classes from JDK; files and their representation using      all assignments done throughout the year.
the File class, file input/output; input/output             The terminal examination of three hours duration shall
exceptions. Tokens in an input stream, concept of           consist of three programming problems from which a
whitespace, extracting tokens from an input stream          candidate has to attempt any one. In each problem a
(StringTokenizer class).                                    candidate will be required to write and execute a Java
e) Concept of recursion, simple recursive functions         program on seen (i.e. given in the paper) and unseen
(e.g. factorial, GCD, binary search, conversion of          (available only to the examiner) inputs. The program
representations of numbers between different bases).        should be sufficiently documented so that the
                                                            algorithm and the development process is clear from
f) Concrete computational complexity; concept of            reading the program.
input size; estimating complexity in terms of
functions; importance of dominant term; best, average       Teachers should maintain a record of all the
and worst case.                                             assignments done as part of the practical work through
                                                            the year and give it due credit at the time of
Implementation of algorithms to solve problems              cumulative evaluation at the end of the year.
The students are required to do lab assignments in the      Marks (out of a total of 100) will be distributed as
computer lab concurrently with the lectures.                given below:
Programming assignments should be done such that
                                                            Continuous Evaluation
each major topic is covered in at least one assignment.
Assignment problems should be designed so that they         Programming assignments in Java throughout the year
are non-trivial and make the student do algorithm                                                        20 marks
design, address correctness issues, implement and
execute the algorithm in Java and debug where               Terminal Evaluation
necessary. Some sample problems are given in the            Java solution to programming problem         - 60 marks
scope document.
                                                            (Marks should be given for choice of algorithm and
Social context of computing and ethical issues              implementation strategy, documentation, correct output
                                                            on known inputs mentioned in the question paper,
g) Intellectual property and corresponding laws and         correct output for unknown inputs available only to the
rights, software as intellectual property.                  examiner.)
h) Software copyright and patents and the difference        Viva-Voce (based on the programming problem chosen
between the two; trademarks; software licensing and         by the student)                         - 20 marks
piracy.


                                                         1091
                                                         14
(Viva-voce includes questions on the following aspects      correctness, alternative algorithms or implementations.
of the problem attempted by the student: the algorithm      Questions should be confined largely to the problem
and     implementation     strategy,   documentation,       the student has attempted.)

                                                    CLASS XII
There will be two papers in the subject:                    e) Applications of Boolean algebra and logic gates to
Paper I: Theory-         3 hours        …100 marks          half adders, full adders, encoders, decoders,
                                                            multiplexers, NAND, NOR as universal gates.
Paper II: Practical-     3 hours        …100 marks

                 PAPER I-THEORY                                                  SECTION B
Paper 1 shall be of 3 hours duration and be divided         The programming element in the syllabus (sections B
into two parts.                                             and C) is aimed at algorithmic problem solving and
Part I (30 marks): This part will consist of                not merely rote learning of Java syntax. The Java
compulsory short answer questions, testing                  version used should be 1.5 or later. For programming,
knowledge, application and skills relating to the entire    the students can use any text editor and the javac and
syllabus.                                                   java programs or any development environment: for
                                                            example, BlueJ, Eclipse, NetBeans etc. BlueJ is
Part II (70 marks): This part will be divided into          strongly recommended for its simplicity, ease of use
three Sections, A, B and C. Candidates are required to      and because it is very well suited for an ‘objects first’
answer three questions out of four from Section A and       approach.
two questions out of three in each of the sections B
and C. Each question in this part shall carry 10            Programming in Java (Review of class XI sections
marks.                                                      B and C)
                       SECTION A
                                                            Objects
Boolean Algebra
                                                            a) Objects as data (attributes) + behaviour (methods or
a) Propositional logic, well formed formulae, truth         functions); object as an instance of a class.
values and interpretation of well formed formulae           Constructors.
(wff), truth tables, satisfiable, unsatisfiable and valid
                                                            b) Analysis of some real world programming
formulae. Equivalence laws and their use in
                                                            examples in terms of objects and classes.
simplifying wffs.
                                                            Primitive values, wrapper classes, types and
b) Binary valued quantities; basic postulates of
                                                            casting
Boolean algebra; operations AND, OR and NOT;
truth tables.                                               c) Primitive values and types: int, short, long, float,
                                                            double, boolean, char. Corresponding wrapper classes
c) Basic theorems of Boolean algebra (e.g. Duality,
                                                            for each primitive type. Class as type of the object.
idempotence,         commutativity,       associativity,
                                                            Class as mechanism for user defined types. Changing
distributivity, operations with 0 and 1, complements,
                                                            types through user defined casting and automatic type
absorption, involution); De Morgan’s theorem and its
                                                            coercion for some primitive types.
applications; reducing Boolean expressions to sum of
products and product of sums forms; Karnaugh maps           Variables, expressions
(up to four variables).
                                                            d) Variables as names for values; expressions
                                                            (arithmetic and logical) and their evaluation
Computer Hardware
                                                            (operators, associativity, precedence). Assignment
d) Elementary logic gates (NOT, AND, OR, NAND,              operation; difference between left hand side and right
NOR, XOR, XNOR) and their use in circuits.                  hand side of assignment.
                                                            Statements, scope

                                                        1101
                                                        14
e) Statements; conditional (if, if-then-else, switch-        Inheritance and polymorphism
break, ?: ternary operator), looping (for, while-do, do-
                                                             a) Inheritance; base and derived classes; member
while, continue, break); grouping statements in
                                                             access in derived classes; redefinition of variables and
blocks, scope and visibility of variables.
                                                             functions in subclasses; abstract classes; class Object;
Functions                                                    protected visibility. Subclass polymorphism and
                                                             dynamic binding.
f) Functions/methods (as abstractions for complex
user defined operations on objects), functions as            Data structures
mechanisms for side effects; formal arguments and
                                                             b) Basic data structures (stack, queue, dequeue);
actual arguments in functions; different behaviour of
                                                             implementation directly through classes; definition
primitive and object arguments. Static functions and
                                                             through an interface and multiple implementations
variables. The this variable. Examples of algorithmic
                                                             by implementing the interface. Basic algorithms using
problem solving using functions (various number              the above data structures.
theoretic problems, finding roots of algebraic
equations).                                                  c) Recursive data structures: singly and doubly linked
                                                             lists, binary trees, tree traversals, binary search tree.
Arrays, strings
                                                             Algorithms using these data structures (merge sort and
g) Structured data types – arrays (single and multi-         quick sort, searching.
dimensional), strings. Example algorithms that use
                                                             Complexity and big O notation
structured data types (e.g. searching, finding
maximum/minimum, sorting, solving systems of                 d) Concrete computational complexity; concept of
linear equations, substring, concatenation, length,          input size; estimating complexity in terms of
access to char in string, etc.).                             functions; importance of dominant term; best, average
                                                             and worst case. Big O notation for computational
h) Basic concept of a virtual machine; Java virtual
                                                             complexity; analysis of complexity of example
machine; compilation and execution of Java programs
                                                             algorithms using the big O notation (e.g. Various
(the javac and java programs).
                                                             searching and sorting algorithms, algorithm for
i) Compile time and run time errors; basic concept of        solution of linear equations etc.).
an exception, the Exception class, catch and throw.
j) Class as a contract; separating implementation from
interface; encapsulation; private and public.
                                                             Implementation of algorithms to solve problems
k) Interfaces in Java; implementing interfaces through
a class; interfaces for user defined implementation of       The students are required to do lab assignments in the
behaviour .                                                  computer lab concurrently with the lectures.
l) Basic input/output using Scanner and Printer              Programming assignments should be done such that
classes from JDK; files and their representation using       each major topic is covered in at least one assignment.
the File class, file input/output; input/output              Assignment problems should be designed so that they
exceptions. Tokens in an input stream, concept of            are non-trivial and make the student do algorithm
whitespace, extracting tokens from an input stream           design, address correctness issues, implement and
(StringTokenizer class).                                     execute the algorithm in Java and debug where
                                                             necessary.
m) Concept of recursion, simple recursive functions
(e.g. factorial, GCD, binary search, conversion of                         PAPER II - PRACTICAL
representations of numbers between different bases).
                                                             This paper of three hours duration will be evaluated
                                                             by the teacher and a Visiting Examiner appointed
                    SECTION C                                locally and approved by the Council.
Inheritance, polymorphism,          data    structures,      The paper shall consist of three programming
computational complexity                                     problems from which a candidate has to attempt any

                                                          1111
                                                          14
one. In each problem a candidate will be required to      required.    Following are       the    recommended
write and execute a Java program on seen (present in      specifications as of now:
the question paper) and unseen (available only to the     The Facilities:
examiner) inputs. The program should be sufficiently
documented so that the algorithm, representation and         A lecture cum demonstration room with a
development process is clear from reading the                 MULTIMEDIA PROJECTOR/ an LCD and
program.                                                      O.H.P. attached to the computer.
Marks (out of a total of 100) should be distributed as       A white board with white board markers should
given below:                                                  be available.
                                                             A fully equipped Computer Laboratory that
Continuous Evaluation                                         allows one computer per student.
Candidates will be required to submit a work file
containing the practical work related to programming         Internet connection for accessing the World Wide
assignments done during the year.                             Web and email facility.
Programming assignments done throughout the year             The computers should have a minimum of 256
(Internal evaluation)                  - 10 marks             MB (512MB preferred) RAM and a PIII or higher
Programming assignments done throughout the year              processor. The basic requirement is that it should
(Visiting Examiner)                     - 10 marks            run the operating system and Java programming
                                                              system (Java compiler, Java runtime environment,
Terminal Evaluation                                           Java development environment) at acceptable
Solution to programming problem on the computer               speeds.
                                         60 marks
                                                             Good Quality printers.
(Marks should be given for choice of algorithm and
implementation strategy, documentation, correct output    Software:
on known inputs mentioned in the question paper,             Any suitable Operating System can be used.
correct output for unknown inputs available only to the
examiner.)                                                   JDK 1.5 or later.
Viva-voce                                   - 20 marks       Documentation for the JDK version being used.
(Viva-voce includes questions on the following               A suitable text editor. A development
aspects of the problem attempted by the student: the          environment with a debugger is preferred (e.g.
algorithm       and      implementation       strategy,       BlueJ, Eclipse, NetBeans). BlueJ is recommended
documentation, correctness, alternative algorithms or         for its ease of use and simplicity.
implementations. Questions should be confined
largely to the problem the student has attempted.)


                   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


                                                      1121
                                                      14