Computer science is the study of information: its structure, its representation, and its utilization. This includes the theory, analysis, design, efficiency, implementation, and application of computer programs (software) and computer equipment (hardware) for developing computerized information processing systems in response to users' needs.

A computer is a machine that manipulates data according to a list of instructions. The ability to store and execute lists of instructions called programs makes computers extremely versatile and distinguishes them from calculators.

A vocabulary and set of grammatical rules for instructing a computer to perform specific tasks. The term programming language usually refers to high-level languages, such as BASIC, C, C++, COBOL, FORTRAN, Ada, and Pascal. Each language has a unique set of keywords (words that it understands) and a special syntax for organizing program instructions.

C offers an elegant compromise between the efficiency of coding in assembly language and the convenience and portability of writing in a structured, high-level language. By keeping many of its commands and syntax analagous to those of common machine languages, and with several generations of optimising compilers behind it, C makes it easy to write fast code without necessarily sacrificing readability. But it still tempts you write code that only a machine can follow, which can be a problem when it comes time to debug it or make changes.

The C Character set, Identifiers and Keywords, Data Types, Constants, Variables and Arrays, Declarations, Expressions, Statements, Symbols and Constants.

Operations and Expressions:  Arithmetic Operations, Unary Operations, Relational and Logical Operations, Assignment Operations, The Conditional Operations, Library functions.

Data Input and Output:  Preliminaries, Single Character Input- The getchar Function, Single Character Output- The putchar Function, Entering Input Data-The scanf Function, More about the scan f function, Writing Output Data-The printf Function, More about the printf Function, The gets and puts Functions, Interactive (conversational) Programming.

Preparing and Running a Complete C Program:  Planning a C Programme, Writing a C Program, Entering the Programme into the computer, Compiling and Executing the Program, Error Diagnostics, Debugging Techniques..

Control Statements:  Preliminaries, Branching: The if –else Statement, Looping: The while Statement, More Looping: The do-while Statement, Still More Looping: The for Statement, Nested Control Structures, The switch Statement, The break Statement, The continue Statement,The Comma Operator, The goto Statement

Functions:  A Brief Overview, Defining a Function, Accessing a Function, Function Prototypes, Passing Argument to a Function, Recursion.

Program Structure:  Storage Classes, Automatic Variables, External (Global) Variables, Static Variables, Multifile Programs, More about Library Functions.

Arrays:  Defining an Array, Processing an Array, Passing Arrays to Function, Multidimensional Arrays, Arrays and Strings.

Pointers:  Fundamentals, Pointer Declaration, Passing Pointers to Functions, Pointers and One-Dimensional Arrays, Dynamic Memory Allocation, Operations in Pointers, Pointers and multidimensional Arrays, Arrays of Pointers, Passing Functions to Other Functions, More about Pointer Declarations.

Structures and Union :  Defining a Structure, Processing a Structure, User-Defined Data Types (typedef), Structures and Pointers, Passing Structures to Functions, Self-Referential Structures Unions.

Data Files:  Opening and Closing a Data File, Creating a Data File, Processing a Data File, Unformatted Data Files.

Low-Level Programming:  Register Variables, Bitwise Operations, Bit Fields.

Some Additional Features of C:  Enumerations, Command Line Parameters, More About Library Functions, Macros,The C Preprocessor.

C++ is probably the most widely-supported language today, and most commercial software is written in C++. C++ is regarded as a mid-level language, as it comprises a combination of both high-level and low-level language features.Bjarne Stroustrup developed C++ in 1979 at Bell Labs as an enhancement to the C programming language and named it "C with Classes". In 1983 it was renamed to C++.

C++ provides a collection of predefined classes, along with the capability of user-defined classes. The classes of C++ are data types, which can be instantiated any number of times. Class definitions specify data objects (called data members) and functions (called member function). Classes can name one or more parent classes, providing inheritance and multiple inheritance, respectively. Classes inherit the data members and member functions of the parent class that are specified to be inheritable. Therefore it is mainly used for: Software Engineering, Graphics.

Applications of C++, A 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:  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, Operators Overloading, Operators Precedence, Control Structures.

Functions:  The Main Functions, Function Prototyping, Call by Reference, Return by Reference, Inline Functions, Default Arguments, const Argument, Function Overloading, Friend and Virtual Functions, Math Library Functions.

Classes and Objects:  C Structures Revisited, Specifying a Class, Defining Member Functions, A C++ 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.

Constructors and Destructors:  Constructors, Parameterized Constructors, Multiple Constructors in a Class, Constructors with Default Argument, Dynamic Initialization of Objects, Copy Constructors, Dynamic Constructors, Constructing Two-Dimensional Arrays, const Objects, Destructors.

Operator Overloading and Type Conversation:  Defining Operator Overloading, Overloading Unary Operators, Overloading Binary Operators, Overloading Binary Operators Using Friends, Manipulation of Strings Using Operators, Rules for Overloading Operators, Type Conversations.

Inheritance: Extending Classes:  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:  Pointers to Objects, this Pointer, Pointers to Derived Classes, Virtual Functions, Pure Virtual Functions.

Managing Console I/O Operations:  C++ Streams, C++ Stream Classes, Unformatted I/O operations, Formatted Console I/O , Operations, Managing Output with Manipulators.

Working with Files:  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.

Templates:  Class Templates, Class Templates with Multiple Parameters, Function Templates, Function Templates with Multiple Parameters, Overloading of Template Functions, Member Function Templates, Non-Type Template Arguments.

Exception Handling:  Basis of Exception Handling, Exception Handling Mechanism, Throwing Mechanism, Catching Mechanism, Rethrowing an Exception, Specifying Exceptions.

Introduction to the Standard Template Library:  Components of STL, Containers, Algorithms, Iterators, Application of Container classes, Function Objects.

Manipulating Strings:  Creating String Objects, Manipulating String Objects, Relational Operations, String Characteristics, Accessing Characters in Strings, Comparing and Swapping.

New Features of ANSI C++ Standard:  New Data Types, New Operators, Class Implementation, Namespace Scope, Operator Keywords, New Keywords.

Object-Oriented Systems Development:  Procedure-Oriented Paradigms, Procedure-Oriented Development Tools, Object-Oriented Paradigm, Object-Oriented Notations and Graphs, Steps in Object-Oriented Analysis, Steps in Object-Oriented Design, Implementation, Prototyping Paradigm, Wrapping Up.

Java [slang for "coffee"] is kind of a streamlined version of C++, designed for portability. Its key advantage is that Java programs can be run on any operating system for which a Java "virtual environment" is available.

The Java programming Language evolved from a language named Oak. Oak was developed in the early nineties at Sun Microsystems as a platform-independent language aimed at allowing entertainment appliances such as video game consoles and VCRs to communicate. Oak was first slated to appear in television set-top boxes designed to provide video-on-demand services. Just as the deals with the set-top box manufacturers were falling through, the World Wide Web was coming to life. As Oak’s developers began to re cognize this trend, their focus shifted to the Internet and WebRunner, an Oak-enabled browser, was born. Oak’s name was changed to Java and WebRunner became the HotJava web browser

Compiled and Interpreted, Platform –independent and portable, Object-Oriented, Robust and secure, Distributed, Simple, small and familiar, Multithreaded and interactive, High Performance, Dynamic and extensible, How java differs from C and C++, Java and C, Java and C++, Java and internet, Java and World Wide Web, Web Browsers, Hotjava Netscape Navigator, Internet Explorer, Hardware and Software Requirements, Java Support Systems, Java Environment, Java development kit, Application Programming Interface.

Class declaration, Opening brace, The main line , The output line, More of java, Use of math functions, Comments, An Application with Two Classes, Java Program Structure, Documentation Section, Package statement, Import statements, Interface statements, Class definitions, Main method class, Java Tokens, Java character set, Keywords, Identifiers, Literals, Operators, Separators, Java Statements, Implementing a java Program, Creating the Program, Compiling the Program, Running the Program, Machine neutral, Java Virtual Machine, Command Line Arguments, Programming.

Constants, Variables, and Data Types:  Constants, Integer constants, Real constants, Single character constants, String constants, Backslash character constants, Variables, Data Types, Integer types, Floating point types, Character type, Boolean type, Declaration of Variables, Giving Values to Variables, Assignment statement, Read statement, Scope of Variables, Symbolic Constants, Modifiability, Understandability, Type Casting, Automatic conversion, Getting Values of Variables, Standard Default Values.

Arithmetic Operators:  Relational Operators, Logical Operators, Assignment Operators, Increment and Decrement Operators, Conditional Operators, Bitwise Operators, Special Operators, Instance operator, Dot operator, Arithmetic Expressions, Evaluation of Expressions, Precedence of Arithmetic Operators, Type Conversions in Expressions, Automatic type conversion, Casting a value, Operator Precedence and Associativity, Mathematical functions.

Decision Making and Branching:  Decision Making with if Statement, Simple if Statement, The if….else Statement, Nesting of if…else Statements, The else if Ladder, The switch Statement, The?: Operator.

Decision Making and Looping:  The while Statement, The do Statement, The for Statement, Additional features of for loop, Nesting of for loop, Jumps in Loops, Jumping out of a loop, Skipping a part of a loop, Labeled Loops.

Classes, Objects and Methods:  Defining a Class, Adding Variables, Adding Methods, Creating Objects, Accessing Class Members, Constructors, Methods Overloading, Static Members, Nesting of Methods, Inheritance: Extending a Class, Defining a subclass, Subclass constructors, Multilevel inheritance, Hierarchical inheritance, Overriding Methods, Final Variables and Methods, Finalizer Methods, Abstract Methods and Classes , Visibility Control, Public access, Friendly access, Protected access, Private access, Private protected access, Rules of , Thumb.

Arrays, Strings and Vectors:  Arrays, One-Dimensional Arrays, Creating an Array, Declaration of arrays, Creation of arrays, Initialization of arrays, Array length, Two-Dimensional Arrays, Variable size arrays, Strings, String arrays, String methods, StringfBuffer Classes, Vectors, Wrapper Classes.

Interfraces: Multiple Inheritance:  Defining Interfaces, Extending Interfaces, Implementing Interfaces, Accessing Interface Variables.

Packages: putting Classes Together:  Java API packages, Using System Packages, Naming Conventions, Creating Packages, Accessing Packages, Using a Package, Adding a Class to a Package, Hiding Classes.

Multithreaded Programming:  Creating Threads, Extending the Thread Class, Declaring the Class, Implementing the run () method, Starting new thread, Stopping and Blocking a Thread, Stopping a Thread, Blocking a Thread, Life Cycle of Thread, Newborn state, Runnable state, Running state, Blocked state, Dead state, Using Thread Methods, Thread Exceptions, Thread Priority, Synchronization, Implementing the ‘Runnable’ Interface.

Managing Errors and Exceptions:  Types of Errors, Compile-time errors, Run-time errors, Exceptions, Syntax of Exceptions Handling Code, Multiple Catch Statements, Using finally Statement, Throwing Our Own Exceptions, Using Exception for Debugging.

Applet Programming:  Local and remote applets , How Applets differ from applications, Preparing to write Applets, Building Applet Code, Applet Life Cycle, Initialization state, Running state, Idle or stopped state, Dead state, Display state, Creating a Executable Applet, Designing a Web Page, Comment Section, Head section, Body section, Applet tag, Adding Applet to HMTL File, Running the Applet, More about Applet Tag, Passing Parameter to Applets, Aligning the Display , More about HTML Tags, Displaying Numerical Values, Getting Input from the User, Program analysis.

GRAPHICS PROGRAMMING:  The Graphics Class, Lines and Rectangles, Circles and Ellipses, Drawing Arcs, Drawing Polygons, Line Graphs, Using Control Loops in Applets, Drawing Bar Charts.

Managing Input/Output Files in Java:  Concept of Streams, Stream Classes, Byte Stream Classes, Input stream classes, Outputstream classes, Character Stream Classes, Reader stream Classes, Write stream Classes, Using Streams, Other Useful I/O Classes, Using the File Classes, Input /Output Exceptions, Creation of Files, Reading/Writing Characters, Reading/writing Bytes, Handling Primitive Data Types, Concatenating and Buffering Files, Random Access files, Interactive Input and Output, Simple Input and Output, Graphical Input and Output, Other Stream Classes, Object streams, Piped streams, Pushback streams, Filtered streams.