SYLLABUS

M.Sc. – I.T. Ist Year

 CONTENT

M.Sc.IT Ist Year

Paper I Computer Organization & Architecture

Paper II Data Communications and Computer Networking

Paper III Programming in C and Data Structure

Paper IV Object Oriented Programming in C++

Paper V Advanced DBMS, Oracle

Paper VI Visual Basic

Paper VII Discrete Mathematics

 M.Sc. IT – Ist Year
Paper - I
COMPUTER ORGANISATION & ARCHITECTURE
UNIT-I
Digital Logic Circuits : Digital Computers, Logic Gates, Boolean Algebra, Map
Simplification, Combinational Circuits, Flip-Flops, Sequential Circuits.
Digital Components : Integrated Circuits, Decoders, Multiplexers, Registers, Shift
Registers, Binary Counters.
Data Representation : Data Types, Complements, Fixed-Point Representation,
Floating-Point Representation, Other Binary Codes, Error Detection Codes.
UNIT-II
Register Transfer and Microoperations : Register Transfer Language, Register Transfer,
Bus and Memory Transfers, Arithmetic Microoperations, Logic Microoperations, Shift
Microoperations, Arithmetic Logic Shift Unit.
Basic Computer Organisation and Design : Instruction Codes, Computer Registers,
Computer Instructions, Timing and Control, Instruction Cycle, Memory-Reference
Instructions, Input-Output and Interrupt, Complete Computer Description, Design of Basic
Computer, Design of Accumulator Logic.
UNIT-III
Programming the Basic Computer : Introduction, Machine Language, Assembly
Language, The Assembler, Program Loops, Programming Arithmetic and Logic,
Subroutines, Input-Output Programming.
Microprogrammed Control : Control Memory, Address Sequencing, Microprogram
Example, Design of Control Unit.
UNIT-IV
Central Processing Unit : Introduction, General Register Organisation, Stack,
Organisation, Instruction Formats, Addressing Modes, Data Transfer and Manipulation,
Program Control, Reduced Instruction Set Computer (RISC).
Pipeline and Vector Processing : Parallel Processing, Pipelining, Arithmetic Pipeline,
Instruction Pipeline, RISC Pipeline, Vector Processing, Array Processors.
Computer Arithmetic : Introduction, Addition and Subtraction, Multiplication Algorithms,
Division Algorithms, Floating-Point Arithmetic Operations, Decimal Arithmetic Unit, Decimal
Arithmetic Operations.
Input-Output Organisation : Peripheral Devices, Input-Output Interface, Asynchronous
Data Transfer, Modes of Transfer, Priority Interrupt, Direct Memory Access (DMA),
Input-Output Processor (IOP), Serial Communication.
UNIT-V
Memory Organisation : Memory Hierarchy, Main Memory, Auxiliary Memory, Associative
Memory, Cache Memory, Virtual Memory, Memory Management Hardware.
Multiprocessors : Characteristics of Multiprocessors, Interconnection Structures,
Interprocessor Arbitration, Interprocessor Communication and Synchronization, Cache
Coherence.
 Paper-II
Data Communication and Computer Networking
UNIT-I
Introduction: Uses of Computer Networks, Network Hardware, Network Software,
Reference Models, Example Networks, Network Standardization, Metric Units.
UNIT-II
Sthe Physical Layer: The Theoretical Basis for Data Communication, Guided Transmission
Media, Wireless Transmission, The Public Switched Telephone Network, The Mobile
Telephone System, Cable Television.
UNIT-III
The Data Link Layer: The Data Link Layer Design Issues, Detection and Correction,
Elementary Data Link Protocols, Sliding Window Protocols, Protocol Verification, Example
Data Link Protocols
UNIT-IV
Medium Access Control Sublayer: Channel Allocation Problem, Multiple Access
Protocols, Ethernet, Wireless Lans, Broadband Wireless, Bluetooth, Data Link Layer
Switching.
The Network Layer: Network Layer Design Issues, Routing Algorithms, Congestion Control
Algorithms, Quality of Service, Internetworking, The Network Layer In The Internet.
The Transport Layer: The Transport Service, Elements of Transport Protocols, Simple
Transport Protocol, The Internet Transport Protocols : Udp The Internet Transport Protocols
: TCP, Performance Issues
UNIT-V
The Application Layer: Dns- The Domain Name System, Electronic Mail, The World Wide
Web, Multimedia
Network Security: Cryptography, Symmetric-Key Algorithms, Public-Key Algorithms, Digital
Signatures, Management of Public Keys, Communication Security, Authentication Protocols,
E-Mail Security, Web Security, Social Issues.
Paper-III
Programming in C and Data Structure
UNIT-I
Introduction: Introduction to Algorithm, Abstract Data type and Data Structure, Analysis of
Algorithm, Asymptotic of Notation, verification of algorithm.
Arrays: Introduction, ordered list & arrays, 2- dimensional array, Representation of
polynomials, sparse, matrix representation, representation of multidimensional array.
UNIT-II
Linked Lists: Introduction, Implementation of linked list, Data type Structure using pointer
data types, Doubly linked list, circular list, array representation of linked lists, Dynamic
Memory Management, shared & recursive lists.
Stacks And Queues : Introduction, array representation, linked list representation of stacks
and queues, application of stack, application of queue.
UNIT-III
Strings: Introduction, strings as an ADT, representation of string, string searching
algorithms.
Recursion: Introduction, simple recursion and recursion free, divide and conquer, tower of
Hanoi, permutation generation, removal of recursion.
UNIT-IV
Trees: Introduction, Definition, Binary Tree, Array representation, Binary Tree Traversal,
properties of Binary Tree, Binary Search Tree.
Advanced Trees: Introduction, AVL Tree, insertion, deletion from an AVL Tree, B-Trees,
Definition, Searching a B-tree, insertion deletion from B-Tree, priorty queues, heaps,
construction of Heaps.
UNIT-V
Searching And Sorting: Introduction, sequential search linear search, binary search,
internal sorting, sorting methods, shuttle sort, straight insertion sort shell sort, simple
selection sort, straight selection sort bubble sort, quick sort, merge sort, heap sort, hashing,
hash function.
Elementary Graphs: Introduction, definition, representation, traversal of graphs, shortest
path.
Paper-IV
Object Oriented Programming in C++
UNIT-I
Principles of Object-Oriented Programming : Software Crises, Software Evolution, A
Look at Procedure-Oriented Programming, Object-Oriented Programming Paradigm, Basic
Concepts of Object-Oriented Programming, Benefits of OOP, Object-Oriented Languages,
Applications of OOP
Beginning With C”++: What is C++ ?, Applications of C++ Simple C++ Program, More
C++ Statements, An Example with Class, Structure of C++ Program, Creating the Source
File, Compiling and Linking
Tokens, Expressions and Control Structures: Introduction, Tokens, Keywords,
Identifiers and Constants, Basic Data Types, User-Defined Data Types, Derived Data
Types, Symbolic Constants, Type Compatibility, Declaration of Variables, Dynamic
Initialization of Variables, Reference Variables, Operators in C++, Scope Resolution
Operator, Member Dereferencing Operators, Memory Management Operators,
Manipulators, Type Cast Operator, Expressions and Their Types, Special Assignment
Expressions, Implicit Conversions, Operator Overloading, Operator Precedence, Control
Structures.
UNIT-II
Functions In C++: Introduction, The Main Function, Function Prototyping, Call by
Reference, Return by Reference, Inline Functions, Default Arguments, const Arguments,
Function Overloading, Friend and Virtual Functions, Math Library Functions.
Classes and Objects: Introduction, C Structures Revisited, Specifying a Class. Defining
Member Functions, AC++ Program with Class, Making an Outside Function Inline, Nesting
of Member Functions, Private Member Functions, Arrays within a Class Memory Allocation
for Objects, Static Data Members, Static Member Functions, Arrays of Objects, Objects as
Function Arguments, Friendly Functions, Returning Objects, const Member Functions,
Pointers to Members, Local Classes
UNIT-III
Constructors and Destructors: Introduction, Constructors, Parameterized Constructors,
Multiple Constructors in a Class, Constructors with Default Arguments, Dynamic Initialization
of Objects, Copy Constructor, Dynamic Constructors, constructing Two-Dimensional Arrays,
const Objects, Destructors.
Operator Overloading and Type Conversions: Introduction, Defining Operator
Overloading, Overloading Unary Operators, Overloading Binary Operators, Overloading
Binary Operators Using Friends, Manipulation of Strings Using Operators, Rules for
Overloading Operators, Type Conversions.
UNIT-IV
Inheritance: Extending Classes: Introduction, Defining Derived Classes, Single
Inheritance, Making a Private Member Inheritable, Multilevel Inheritance, Multiple
Inheritance, Hierarchical Inheritance, Hybrid Inheritance, Virtual Base Classes, Abstract
Classes, Constructors in Derived Classes, Member Classes: Nesting of Classes
Pointers, Virtual Functions and Polymorphism: Introduction, Pointers to Objects, this
Pointer, Pointers to Derived Classes, Virtual Functions, Pure Virtual Functions.
Managing Console I/O Operations: Introduction, C++ Streams, C++ Stream Classes,
Unformatted I/O Operations, Formatted Console I/O Operations, Managing Output with
manipulators
UNIT-V
Working With Files: Introduction, Classes for File Stream Operations, Opening and
Closing a File, Detecting End-of File, More about Open(): File Modes, File Pointers and their
Manipulations, Sequential Input and Output Operations, Updating a File: Random Access,
Error Handling During File Operations, Command-Line Arguments.
Paper-V
Advanced DBMS ORACLE
UNIT-I
Introduction: Database System Applications, Database System versus File Systems, View
of Data, Data Models, Database Languages, Database Users and Administrators,
Transaction Management, Database System Structure, Application Architectures, History of
Database Systems
Data Models : Entity- Relationship Model, Basic Concepts, Constraints, Keys, Design
Issues, Entity-Relationship Diagram, Weak Entity Sets, Extended E-R Features, Design of
an E-R Database Schema, Reduction of an E-R Schema to Tables, The Unified Modeling
language UML
Relational Model: Structure of Relational Database, The Relational Algebra, Extended
Relational-Algebra Operations, Modification of the Database, Views, The Tuple Relational
Calculus, The Domain Relational Calculus.
Relational Databases: Background, Basic Structure, Set Operations, Aggregate Functions,
Null Values, Nested Subqueries, Views, Complex Queries, Modifications of the Database,
Jointed Relations, Data-Definition Language, Embedded SQL, Other SQL Features
UNIT-II
Other Relational Languages: Query-by-Example, Datalog, User Interfaces and Tools
Integrity and Security : Domain Constraints, Referential Integrity, Assertions, Triggers,
Security and Authorization, Authorization in SQL, Encryption and Authentication
Relational-Database Design: First Normal Form, Pitfalls in Relational-Database Design,
Functional Dependencies, Decomposition, Desirable Properties of Decomposition,
Boyce-Codd Normal Form, Third Normal Form, Fourth Normal Form, More Normal Forms,
Overall Database Design Process
Object-Based Databases: Object-oriented Databases: Need for Complex Data Types, The
Object-Oriented Data Model, Object-Oriented Languages, Persistent Programming
Languages, Persistent C++ System, Persistent Java Systems
UNIT-III
Object-Relational Databases: Nested Relations, Complex Types, Inheritance, Reference
Types, Querying with Complex Types, Functions and Procedures, Object-Oriented versus,
Object-Relational
XML Background, Structure of XML Data, XML Document Schema, Querying and
Transformation, The Application Program Interface, Storage of XML Data, XML Applications
Data Storage and Querying: Storage and File Structure, Overview of Physical Storage
Media, Magnetic Disks, RAID, Tertiary Storage, Storage Access, File Organization,
Organization of Records in Files, Data-Dictionary Storage, Storage for Object-Oriented
Databases.
UNIT-IV
Indexing and Hashing : Basic Concepts, Ordered Indices, B+Tree Index Files, B-Tree
Index Files, Static Hashing, Dynamic Hashing, Comparison of Ordered Indexing and
Hashing, Index Definition in SQL, Multiple-key Access
Query Processing: Overview, Measures of Query Cost, Selection Operation, Sorting, Join
Operation, Other Operations, Evaluation of Expressions
Query Optimization: Overview, Estimating Statistics of Expression Result, Transformation
of Relational Expressions, Choice of Evaluation Plans, Materialized Views
Transaction Management: Transactions, Transaction Concept, Transaction State,
Implementation of Atomicity and Durability, Concurrent Executions, Serializability,
Recoverability, Implementation of Isolation, Transaction Definition in SQL, Testing of
Serializability
UNIT-V
Concurrency Control: Lock-Based Protocols, Timestamp-Based Protocol,
Validation-Based Protocols, Multiple Granularity, Multiversion Schemes, Deadlock Handling,
Insert and Delete Operations, Weak Levels of Consistency, Concurrency in Index Structures
Recovery System: Failure Classification, Storage Structure, Recovery and Atomicity,
Log-Based Recovery, Shadow Paging, Recovery with Concurrent Transactions, Buffer
management, Failure with Loss of Nonvolatile Storage, Advanced Recovery Techniques,
Remote Backup System
Database System Architecture:
Database System Architectures: Centralized and Client-Server Architectures, Server
System Architectures, Parallel Systems, Distributed Systems, Network Types
Distributed Databases: Homogeneous and Heterogeneous Databases, Distributed Data
Storage, Distributed Transactions, Commit Protocols, Concurrency Control in Distributed
Databases, Availability, Distributed Query Processing, Heterogeneous Distributed
Databases, Directory System
Parallel Databases: Introduction, I/O parallelism, Interquery Parallelism, Intraquery
Parallelism, Intraoperation Parallelism, Interoperation Parallelism, Design of Parallel
Systems.
Paper-VI
Visual Basic
UNIT-I
Getting Started with Visual Basic6: Visual Basic Development Overview Designing and
building the User, Interface, Writing Code That Responds to Events, Creating and Calling
Other Procedures as Needed, Testing and Debugging, Converting to Runtime Version,
Preparing a Distributable Set of Files, Creating Your First Visual Basic program, A simple
Project, Creating the Project, Adding Controls to the Form, setting Control Properties,
Writing Event-Driven Code, Testing and Debugging the Sample Application, Converting
Sample Application to Runtime
Understanding Visual Basic Projects: Using Different Types of Projects, Understanding
the Project Explorer Window, Working with Multiple Projects, Setting Project Options,
Visual Basic Code Basics: Understanding Visual Basic Procedures, Using the Visual Basic
Editor, Using Keyboard and Mouse, Understanding Editor Options, Controlling Program
Flow
UNIT-II
Using Visual Basic Variables: Taking a Look at an Example, Understanding Visual Basic
Data, Declaring Variables, Comparing Implicit and Explicit, Providing Names for your, Using
a Naming Convention, Understanding Variable Scope and, Converting Between Data Types,
Working with Arrays, Understanding the Variant Data, Passing Variables to Procedures,
Using Constants, User-Defined Data Types
Designing the User Interface: Understanding the Visual Basic, Form, Getting the Look and
Feel of Windows, Creating your First Form, Adding New Forms, Understanding form
Properties, form Appearance Properties, Form Control Properties, Form size and
Positioning Properties, More Form Properties, Other Form Properties, Referencing Form
Properties, Setting Properties in Code, Positioning the Form with Methods, Using Form
Drawing Methods, Showing and Hiding Forms, Loading Forms, Unloading Forms,
Understanding Form Events, Form Maintenance Events, Form Mouse Events, Form
Keyboard Events, Making the Most Built-In Dialog Boxes, Understanding MDI Applications,
Wrapping up Forms
UNIT-III
Putting Your Forms to Work with Controls: Getting to Know the Toolbox, Getting to
Know the Visual Basic Tools, Customizing the Toolbox, adding Controls to Forms, Using the
Alignment Grid, Multiselecting Controls, Form Layout Functions, Control Properties,
Displaying a Check Box, Providing Mutually Exclusive, Using the Frame Control, Entering
Text, Drawing Shapes and Displaying Pictures, Selecting Files, Colors, Fonts, Printers, and
Help, Generating Timed Events, Passing a Control as an Argument, Determining the Type
of Control, Using the Controls Collection, Setting Tab Order, Binding Controls, Dragging and
Dropping, Handling Keyboard Events, Handling Mouse Events
Mastering Menus and Toolbars: Understanding menus, Using the Menu Editor, Menu
Arrays, Applying Menu Conventions, Using Pop-up Menus, Configuring Menus at Runtime,
Understanding Toolbars, Finding the Perfect Icons, adding Toolbars to Your Application,
Customizing the Toolbar, Configuring the Toolbar at Runtime, Handling Toolbar Events,
Running the Menu and Toolbar Demo Program
UNIT-IV
Using the Visual Basic Debugging Tools: Finding Errors, Using the Module Options,
Traditional Debugging Techniques, Using the Visual Basic Debugging Tools, Using the
Debug Toolbar, Suspending Execution with Breakpoints, Stepping Through Code,
Controlling Program Flow, Getting to Know the Debugging Windows, Using the Call Stack
Handling Runtime Errors: Recognizing Runtime Errors, Trapping Errors in Visual Basic
Applications, using the Err Object, Using the Err Number Property Desplaying More Helpful,
Information, Knowing Which Errors to Trap, Using the resume Statement, Using on Error Go
To, Handling Errors Locally, Logging Errors
Reading and Writing Text Files: Understanding Text Files, Downloading the Data,
Reviewing Database Terminology, Looking at Text File Formats, Understanding Data
Access, Methods, Opening Text Files, Reading Fixed- Width Text Files, Taking a Closer
Look at File Commands, Creating Text Files, Outputting Fixed-Width Data to a File, Looking
at Other File Operations, Deleting Files, Listing the Contents of a Folder, Detecting the End
of a File, Copying a File, Determining the size of a Closed File, Determining the Size of an
Open File, Getting a File’s Attributes, Setting a File’s Attributes
UNIT-V
Mastering the Visual Basic Data Control: Introducing the Data Control, Using the Data
Control, Understanding the Data Control Properties, Knowing the Current Record, Using
Data-Bound Controls, Mainpulating the Data Control at Runtime, Programmed Access
Using Events, navigating the Data Control in Code
Creating Queries in Visual Basic: Defining SQL, Using the SELECT Statement, Accessing
Multiple Tables, Adding Calculated Fields, Specifying the Filter Criteria, Aggregating the
Data, Grouping the Data, Using SQL Statements with the Data Control.
 Paper-VII
Discrete Mathematics
UNIT-I
Set Theory : Introduction, Sets and Elements, Universal Set and Empty Set, Subsets, Venn
Diagram, Set Operations, Algebra of Sets and Duality, Finite Sets, Counting Principle,
Classes of Sets, Power Sets, Partitions, Mathematical Induction.
Relations : Introduction, Product Sets, Relations, Pictorial Representations of Relations,
Compostition of Relations, Types of Relations, Closure Properties, Equivalence Relations,
Partial Ordering Relations, n-ary Relations.
Functions and Algorithms: Introduction, Functions, One-to-One Onto and Invertible
Functions, Mathematical Funcations, Exponential and Logarithmic Functions, Sequences,
Indexed Classes of Sets, Recursively Defined Functions, cardinality, Algorithms and
Functions, Complexity of Algorithms.
Logic and Propositional Calculus : Introduction, Propositions and Compound
Propostions, Basic Logical Operations, Propositions and Truth Tables, Tautologies and
Contradictions, Logical Equivalence, Algebra of Propositions, Conditinal and Biconditional
Statements, Arguments, Logical Implication, Propositional Functions, Quantifiers, Negation
of Quantified Statements.
UNIT-II
Vectors and Matrices : Introduction, Vectors, Matrices, Matrix Additions and Scalar
Multiplication, Matrix Multiplication, Transpose, Square Matrices Invertible (Nonsingular)
Matrices, Inverses, Determinants, Elementary Row Operations, Gaussian Elimination,
Boolean (Zero-One) Matrices.
Counting: Introduction, Basic Counting Principles, Factorial Notation Binomial Coefficients.
Permutations, Combinations, The Pigeonhole Principle, The Inclusion-Exclusion Principle,
Ordered and Unordered Partitions.
Probability Theory : Introduction, Sample Space and Events, Finite Probability Spaces,
Conditional Probability, Independent Events, Independent Repeated Trials, Binomial
Distribution, Random Variables.
UNIT-III
Graph Theory: Introduction, Data Structures, Graphas and Multigraphs, Subgraphs,
Isomorphic and Homeomorphic Graphs, Paths, Connectivity, The Bridges of Konigsberg,
Traversable Multigraphs, Labeled and Weighted Graphs, Complete, Regular and Bipartite
Graphs, Tree Graphs, Planar Graphs, Graph Colorings, Representing Graphs in Computer
Memory, Graph Algorithms.
Directed Graphs: Introduction, Directed Graphs, Basic Definitions, Rooted Trees,
Sequential Representation of Directed Graphs, Warshall's Algorithm, Shortest Paths, Linked
Representation of Directed Graphs, Graph Algorithms Depth-First and Breadth-First
Searches, Directed Cycle-Free Graphs, Topological Sort, Pruning Algorithm for Shortest
Path.
Binary Trees : Introduction Binary Trees, Complete and extended Binary Trees,
Representing Binary Trees in Memory, Traversing Binary Trees, Binary Search trees,
Priority Queues, Heaps, Path Lengths, Huffmans's Algorithm, General (Ordered Rooted)
Trees Revisited.
UNIT-IV
Properties of the integers : Introduction, Order and Inequqlities, Absolute value,
Mathematical Induction, Division Algorithm, Divisibilty, Primes, Greatest Common Divisor,
Euclidean Algoritm, Fundamental Theorem of Arithmetic, Congruence Relation, Congruence
Equation.
Algerbaic Systems : Introduction, Operations Semigroups, Groups, Subgroups, Normal
Subgroups, and Homomorphism, Rings, Integral Domains, and Filelds, Polynomials over a
Field.
UNIT-V
Languages, Grammars Machines : Introduction, Alphabet, Words, Free Semigroup,
Languages, Regular Expresssions, Regular Languages, Finite State Automata, Grammars,
Finite State Machines, Godel Numbers, Turing Machines, Computable, Functions.
Ordered sets and Lattices : Introduction, Ordered sets, Hasse Diagrams of Partially
Ordered Sets, Consistent Enumeration, Supremum and Infimum, Isomorphic (Similar)
Ordered Sets, Well-ordered Sets, Lattices, Bounded Lattices, Distributive Lattices,
Complements, Complemented Lattices.
Boolean Algebra : Introduction, Basic Definitions, Duality, Basic Theorems, Boolean
Algebras as Lattices, Representation Theorem, Sum-of-Products Form for Sets,
Sum-of-Products, Form for Boolean Algebras, Minimal Boolean Expressions, Prime
Implicants, Logic Gates and Circuits, Truth Tables, Boolean Functions, Krnaugh Maps.
-------------------------------