cbcs assignment keyboard key pressed

cbcs assignment keyboard event

cbcs assignment mouse event

cbcs assignment mouse click

25. Write a program that creates a Banner and then creates a thread to scrolls the message in the banner from left to right across the applet‘s window.(cbcs assignment banner java)

25. Write a program that creates a Banner and then creates a thread to scrolls the message in the banner from left to right across the applet‘s window.

cbcs assignment 26 java

26. Write a program to get the URL/location of code (i.e. java code) and document(i.e. html file).

Programming Fundamentals using C/C++

1. Introduction to C and C++ (3 Lectures)

History of C and C++,

 Overview of Procedural Programming and Object-Orientation Programming, 

Using main() function,

 Compiling and Executing Simple Programs in C++.

2. 

Data Types,

 Variables, 

Constants, 

Operators and Basic I/O (5 Lectures)

Declaring,

 Defining and Initializing Variables, 

Scope of Variables, 

Using Named Constants,

 Keywords, 

Data Types, 

Casting of Data Types, 

Operators (Arithmetic, Logical and Bitwise),

 Using Comments in programs,

 Character I/O (getc, getchar, putc, putcharetc), 

Formatted and Console I/O (printf(), scanf(), cin, cout), 

Using Basic Header Files (stdio.h, iostream.h, conio.hetc).

3. Expressions, Conditional Statements

 and Iterative Statements (5 Lectures)
Simple Expressions in C++ (including Unary Operator Expressions, Binary Operator Expressions), 

Understanding Operators Precedence in Expressions, 

Conditional Statements (if construct, switch-case construct), 

Understanding syntax and utility of Iterative Statements (while, do-while, and for loops), 

Use of break and continue in Loops,

 Using Nested Statements (Conditional as well as Iterative)

4. Functions and Arrays (10 Lectures)
Utility of functions,

 Call by Value,

 Call by Reference, 

Functions returning value, 

Void functions, Inline Functions,

 Return data type of functions, 

Functions parameters, 

Differentiating between Declaration and Definition of Functions, 

Command Line Arguments/Parameters in Functions, 

Functions with variable number of Arguments.

 Creating and Using One Dimensional Arrays

 ( Declaring and Defining an Array, Initializing an Array, Accessing individual elements in an Array, Manipulating array elements using loops),

 Use Various types of arrays (integer, float and character arrays / Strings) 

Two-dimensional Arrays (Declaring, Defining and Initializing Two Dimensional Array, Working with Rows and Columns),

 Introduction to Multi-dimensional arrays

5. Derived Data Types (Structures and Unions) (3 Lectures)
Understanding utility of structures and unions, 

Declaring, initializing and using simple structures and unions, 

Manipulating individual members of structures and unions, 

Array of Structures, Individual data members as structures, 

Passing and returning structures from functions, 

Structure with union as members,

Union with structures as members.

6. Pointers and References in C++ (7 Lectures)

Understanding a Pointer Variable,

 Simple use of Pointers (Declaring and Dereferencing Pointers to simple variables), 

Pointers to Pointers,

 Pointers to structures, 

Problems with Pointers, 

Passing pointers as function arguments, 

Returning a pointer from a function, 

using arrays as pointers, 

Passing arrays to functions.

 Pointers vs. References, 

Declaring and initializing references, 

Using references as function arguments 

and function return values

7. Memory Allocation in C++ (3 Lectures)

Differentiating between static and dynamic memory allocation, 

use of malloc,

 calloc and free functions, 

use of new and delete operators, 

storage of variables in static and dynamic memory allocation

8. File I/O, Preprocessor Directives (4 Lectures)
Opening and closing a file (use of fstream header file, ifstream, ofstream and fstream classes),

 Reading and writing Text Files, 

Using put(), get(), read() and write() functions, 

Random access in files, 

Understanding the Preprocessor Directives

 (#include, #define, #error, #if, #else, #elif, #endif, #ifdef, #ifndef and #undef), 

Macros

9. Using Classes in C++ (7 Lectures)
Principles of Object-Oriented Programming,

 Defining & Using Classes,

 Class Constructors,

 Constructor Overloading,

 Function overloading in classes,

 Class Variables &Functions,

 Objects as parameters,

 Specifying the Protected and Private Access,

 Copy Constructors, 

Overview of Template classes and their use.

10. Overview of Function Overloading and Operator Overloading (5 Lectures)

Need of Overloading functions and operators, 

Overloading functions by number and type of arguments,

 Looking at an operator as a function call, 

Overloading Operators (including assignment operators, unary operators)

11. Inheritance, Polymorphism and Exception Handling (8 Lectures)

Introduction to Inheritance (Multi-Level Inheritance, Multiple Inheritance), 

Polymorphism (Virtual Functions, Pure Virtual Functions),

 Basics Exceptional Handling (using catch and throw, multiple catch statements),

 Catching all exceptions, 

Restricting exceptions, 

Rethrowing exceptions.

Computer System Architecture

1. Introduction (8 lectures) Logic gates, boolean algebra, combinational circuits, circuit simplification, flip-flops and sequential circuits, decoders, multiplexers, registers, counters and memory units.
2. Data Representation and Basic Computer Arithmetic (10 lectures) Number systems, complements, fixed and floating point representation, character representation, addition, subtraction, magnitude comparison, multiplication and division algorithms for integers
3. Basic Computer Organization and Design (13 lectures) Computer registers, bus system, instruction set, timing and control, instruction cycle, memory reference, input -output and interrupt, Interconnection Structures, Bus Interconnection design of basic computer.
4. Central Processing Unit (15 lectures) Register organization, arithmetic and logical micro-operations, stack organization, micro programmed control. Instruction formats, addressing modes, instruction codes, machine language, assembly language, input output programming, RISC, CISC architectures, pipelining and parallel architecture.
5. Memory Organization
(6 lectures)
Cache memory, Associative memory, mapping.
6. Input-Output Organization (8 lectures)
Input / Output: External Devices, I/O Modules, Programmed I/O, Interrupt-Driven I/O, Direct Memory Access, I/O Channels.

Programming in Java

CMSACOR03T: Programming in Java Theory: 60 Lectures

1. Introduction to Java (4 Lectures) 

Java Architecture and Features, 

Understanding the semantic and syntax 

differences between C++ and Java,

 Compiling and Executing a Java Program, 

Variables, Constants, Keywords Data Types, 

Operators (Arithmetic, Logical and Bitwise) and Expressions, 

Comments, 

Doing Basic Program Output, 

Decision Making Constructs (conditional statements and loops) and Nesting, 

Java Methods (Defining, Scope, Passing and Returning Arguments, Type Conversion and Type and Checking, Built-in Java Class Methods),

2. Arrays, Strings and I/O (8 Lectures) 

Creating & Using Arrays (One Dimension and Multi-dimensional), 

Referencing Arrays Dynamically, 

Java Strings: 

The Java String class, 

Creating & Using String Objects,
Manipulating Strings, 

String Immutability & Equality,

 Passing Strings To & From Methods, 

String Buffer Classes. 

Simple I/O using System.out and the Scanner class, 

Byte and Character streams, 

Reading/Writing from console and files.

3. Object-Oriented Programming Overview (4 Lectures)

Principles of Object-Oriented Programming, Defining & Using Classes,

 Controlling Access to Class Members, 

Class Constructors, Method Overloading, 

Class Variables & Methods, 

Objects as parameters, 

final classes, 

Object class, 

Garbage Collection.

 4. Inheritance, Interfaces, Packages, Enumerations, Autoboxing and Metadata (14 lectures)

Inheritance: (Single Level and Multilevel, Method Overriding, 

Dynamic Method Dispatch, Abstract Classes), 

Interfaces and Packages, Extending interfaces and packages, 

Package and Class Visibility, Using Standard Java Packages (util, lang, io, net), 

Wrapper Classes, Autoboxing/Unboxing, 

Enumerations and Metadata.

5. Exception Handling, Threading, Networking and Database Connectivity (15 Lectures)

Exception types, uncaught exceptions, throw, built-in exceptions, Creating your own exceptions;

 Multi-threading: The Thread class and Runnable interface, creating single and multiple threads, 

Thread prioritization, synchronization and communication, suspending/resuming threads. 

Using java.net package, 

Overview of TCP/IP and Datagram programming. 

Accessing and manipulating databases using JDBC.

6. Applets and Event Handling (15 Lectures) 

Java Applets:Introduction to Applets, 

Writing Java Applets, 

Working with Graphics, 

Incorporating Images & Sounds. 

Event Handling Mechanisms,

Listener Interfaces, Adapter and Inner Classes. 

The design and Implementation of GUIs using the AWT controls,

 Swing components of Java Foundation Classes such as labels, buttons, textfields, layout managers, menus, events and listeners; 

Graphic objects for drawing figures such as lines, rectangles, ovals, using different fonts. 

Overview of servlets.

Discrete Structures

CMSACOR04T: Discrete Structures Theory: 75 Lectures AdditionalTutorial: 15 Lectures

1. Introduction: (20 Lectures) 

Sets - finite and Infinite sets, uncountably Infinite Sets;

 functions,relations, Properties of Binary Relations, Closure, Partial Ordering Relations;

 counting - Pigeonhole Principle, Permutation andCombination; 

Mathematical Induction, Principle of Inclusion and Exclusion.

2. Growth of Functions: (10 Lectures) Asymptotic Notations, 

Summation formulas and properties, 

Bounding Summations, 

approximation by Integrals

3. Recurrences: (12 Lectures) 

Recurrence Relations, generating functions, 

Linear RecurrenceRelations with constant coefficients and their solution, 

Substitution Method, Recurrence Trees, 

Master Theorem

4. Graph Theory (18 Lectures) 

Basic Terminology, Models and Types, 

multigraphs and weighted graphs,

 Graph Representation, Graph Isomorphism,

 Connectivity, 

Euler and Hamiltonian Paths and Circuits, 

Planar Graphs, Graph Coloring, 

Trees, Basic Terminology and properties of Trees, 

Introduction to Spanning Trees

5. Prepositional Logic (15 Lectures) 

Logical Connectives, Well-formed Formulas, Tautologies,

 Equivalences, Inference Theory