Programming Languages


The course fully covers the basics of programming in the “C” programming language and demonstrates fundamental programming techniques, customs and vocabulary including the most common library functions and the usage of the preprocessor. Learning objectives To familiarize the trainee with basic concepts of computer programming and developer tools. To present the syntax and semantics of the “C” language as well as data types offered by the language To allow the trainee to write their own programs using standard language infrastructure regardless of the hardware or software platform

Course outline
Introduction to compiling and software development
Basic scalar data types and their operators
Flow control
Complex data types: arrays, structures and pointers
Structuring the code: functions and modules
Preprocessing source code
The Project
Absolute basics
Languages: natural and artificial
Machine languages
High-level programming languages
Obtaining the machine code: compilation process
Recommended readings
Your first program
Variable – why?
Integer values in real life and in “C”, integer literals
Data types
Floating point values in real life and in “C”, float literals
Arithmetic operators
Priority and binding
Post- and pre -incrementation and –decrementation
Operators of type op=
TECHNOLOGIES Char type and ASCII code, char literals
Equivalence of int and char data
Comparison operators
Conditional execution and if keyword
printf() and scanf() functions: absolute basics
Flow control
Conditional execution continued: the “else” branch
More integer and float types
Conversions – why?
Typecast and its operators
Loops – while, do and for
Controlling the loop execution – break and continue
Logical and bitwise operators
Switch: different faces of ‘if’
Arrays (vectors) – why do you need them?
Sorting in real life and in a computer memory
Initiators: a simple way to set an array
Pointers: another kind of data in “C”
An address, a reference, a dereference and the sizeof operator
Simple pointer and pointer to nothing (NULL)
& operator Pointers arithmetic
Pointers vs. arrays: different forms of the same phenomenon
Using strings: basics
Basic functions dedicated to string manipulation
Memory management and structures
The meaning of array indexing
The usage of pointers: perils and disadvantages
Void type
Arrays of arrays and multidimensional arrays
Memory allocation and deallocation: malloc() and free() functions
Arrays of pointers vs. multidimensional arrays
Structures – why?
Declaring, using and initializing structures
Pointers to structures and arrays of structures
Basics of recursive data collections
Functions – why?
How to declare, define and invoke a function
Variables' scope, local variables and function parameters
Pointers, arrays and structures as function parameters
Function result and return statement
Void as a parameter, pointer and result
Parameterzing the main function
Parameterzing the main function
Header files and their role

Files and streams
Files vs. streams: where does the difference lie?
Header files needed for stream operations
FILE structure
Opening and closing a stream, open modes, errno variable
Reading and writing to/from a stream
Predefined streams: stdin, stdout and stderr
Stream manipulation: fgetc(), fputc(), fgets() and fputs() functions
Raw input/output: fread() and fwrite() functions
Preprocessor and complex declarations
Preprocessor – why?
#include: how to make use of a header file
#define: simple and parameterized macros
#undef directive
Predefined preprocessor symbols
Macro operators: # and ##
Conditional compilation: #if and #ifdef directives
Avoiding multiple compilations of the same header files
Scopes of declarations, storage classes
User defined types-why?
Pointers to functions
Analyzing and creating complex declarations



In this class, we will learn the basics about C++ programming language such as variables, data types, arrays, pointers, functions and classes etc.


At the end of the class, we expect people to have a good understanding about the concept of object-oriented programming using C++, be able to write and read basic C++ code.


No prior knowledge about C++ is required, but people are expected to have some basic knowledge about computers, some knowledge about one or two other programming languages such as Perl, PHP, Python or Java etc is preferred.

Course outline
What is C++?
Why C++?
C and C++
Exception Handling
Object Oriented Programming
Standard Template Library
The Project
Types and declarations
Types Booleans
Integer Types
Floating-Point Types
Data types
Pointers, Arrays and Structures
Pointers into Arrays
Pointers to void
Expressions and Statements
A Deck Calculator
Operator Summary
Statement Summary
Comments and Indentation
Function Declarations
Argument Passing
Value Return
Overloaded Function Names
Default Arguments
Pointer to Function
Namespaces and Exceptions
Source Files and Programs
Separate Compilation
Using Header Files
Access Control
Member functions
Static members
Memory allocation
Member initialization
Operator overloading
Operator Functions
A Complete Number Type
Conversion Operators
Large Objects
Essential Operators
Functions Calls
Increment and Decrement
A String Class

Derived class
Derived Classes
Abstract Classes
Design of Class Hierarchies
Class Hierarchies and Abstract Classes


Chapter: 1
C# Basic
Introduction to C#
Environment setup
Running C# program
The Project
Chapter: 2
Data types, Conversion
Data types in C#
Data type converting one into another type
Chapter: 3
Variables, Constants, Operators
Variable in C#, variable declaring rules
Types of variables
Types of operators in C#
Chapter: 4
Decision Making Loops
Decision making with if
Else if, switch, loops with for
While and do while
Chapter: 5
Methods, nullable, Encapsulation
Methods creation in C#
Nullable types
Encapsulating methods and classes
Chapter: 6
Arrays, Strings
Array Declaration
Inserting data into Array
Retrieving data from Array
Strings, String methods
Chapter: 7
Structures, Enums
Introduction to structures
Creating and accessing structure data
Creating user defined data types
With Enum
Chapter: 8
C# Classes, Inheritance
Introduction to OOP
C# Classes
Inheriting base class to child class
Chapter: 9
Introduction to polymorphism
Method overloading and
Method overriding
Chapter: 10
Operator Overloading, Interfaces
Operator Overloading method
Creating interfaces
Implementing interfaces in other classes


Chapter: 1
Introduction to .Net Framework
1. Features
2. Common language Runtime(CLR)
3. Framework Class Library(FCL)
The Project
Chapter: 2
Visual Studio .Net
1. IDE
2. Language Supported
3. Components
Chapter: 3
IDE(Integrated Development Environment)
1. Menu System
2. Toolbars
3. Code Designer
4. Solution Explorer
5. Object Browser
6. Toolbox
7. Class View Window
8. Properties Window
Chapter: 4
Events and methods of Form
List box
Combo Box
Radio Button
Chapter: 5
Methods, nullable, Encapsulation
Methods creation in C#
Nullable types
Encapsulating methods and classes
Chapter: 6
Check Box
Progress bar
Date Time Picker
Picture Box
HScroll bar
VScroll bar
Group Box
Chapter: 7
Data Types
Declaring variable and constants
Types of operators
Access Specifiers
Chapter: 8
Conditional Statements
1. If-Then
2. If-Then-Elseif..
3. Nested If
4. Select case
Chapter: 9
Looping Statements
1. Do-Loop
2. For Each – Next loop
3. While Loop
4. Do –Until
Chapter: 10
Menus and Tool bars
1. Menu Strip
2. Tool Strip
3. Status Strip
Chapter: 11
Built-in Dialog Boxes
1. Open File Dialog Box
2. Save File Dialog Box
3. Font Dialog Box
Chapter: 12
Functions and procedures
1. Built-in Functions(Mathematical functions, String Functions)
2. User-Defined Functions
3. How to Overloading and Overriding of user-defined functions


Getting Started with Java SE
What is Java?
Installing Java
The jdk Directory Structure
Sdk structures
OOPS Concept
Java Language
Java Virtual Machine
World Wide Web and Java
Java Platforms
The Project
First Java Programs
Writing your first Java program "Hello, World",
   your first small step towards learning Java
Program Structure
Output in Java
Variables and Expressions
Datatypes and Variables
Primitive Datatypes
Variable Names
Numeric Literals
Character Literals
String Literals
Introduction to Objects
Object Models
Classes and Objects
Abstract methods and Classes
Input in Java
InputWrapper Class
Data Types and Operators
Strong Typing
Integer Data Types
Floating Point
Conversions Between Types
Arithmetic Operators
Doing Math in Java
Errors in Integer Arithmetic
Control Flow
Booleans and Enumerations
Loops and Program Flow
Object-Oriented Programming
Classes and Objects
Fields and Methods
Access Control
Best Practices
Calling Methods
Defining Methods
Method Parameters
Method Overriding
Method Overloading
Characters and Strings
Char Data Type
Character Codes
ASCII and Unicode
String Class
String Input and Output
String Methods
Modular Programming
Monolithic Programs
Static Variables and Methods
Functional Modularity
Object Modularity
Top-Down and Bottom-Up Development
Pass-By-Value and Pass-By-Reference
Nested Classes
Exception Handling and More Flow Control
Exceptions Overview
Declaring Exceptions
Defining and Throwing Exceptions
Errors and Runtime Exceptions
Catching Exceptions
The finally Block
Exception Methods
Exception Methods
Input/Output Streams
Overview of Streams
Bytes vs. Characters
Converting Byte Streams to Character Streams
File Object
Binary Input and Output
Print Writer Class
Reading and Writing Objects
Basic and Filtered Streams
Core Collection Classes
The Collections Framework
The Set Interface
Set Implementation Classes
The List Interface
List Implementation Classes
The Queue Interface
Queue Implementation Classes
Implementing a Stack
The Map Interface
Map Implementation Classes
Collection Sorting and Tuning
New Features in JSE 6
Changing in I/O(JSE 6)
Using Java 6.0 Features with Collections
Sorting with Comparable
Sorting with Comparator
Sorting Lists and Arrays
Collections Utility Methods
Tuning Array List
Navigable Map and Navigable Set
Tuning Hash Map and Hash Set
Inner Classes
Inner Classes
Member Classes
Local Classes
Anonymous Classes
Instance Initializes
Static Nested Classes
Introduction to Threads
Overview of thread
Life Cycle of thread
Creating Threads
Inter-Thread Communication
Thread States
Runnable Threads
Coordinating Threads
Interrupting Threads
Runnable Interface
Thread Groups
The import Statement
Static Imports
CLASSPATH and Import
Defining Packages
Package Scope
Advanced Java Features
Reusable Software Components
Inheritance Hierarchies
Abstract Classes
Introduction to JDBC
Features of JDBC 3.0
Features of JDBC 4.0
New Features in JDBC 4.0
Difference between JDBC 3.0 and JDBC 4.0
JDBC Connectivity Model
Database Programming
Connecting to the Database
Creating a SQL Query
Getting the Results
Updating Database Data
JDBC SQL Programming
Error Checking and the SQLException Class
The SQLWarning Class
JDBC Driver Types
Using a Prepared Statement
Parameterized Statements
Stored Procedures
Transaction Management
Advance JDBC Programming
Overview of Database Driver Architecture
to JDBC Standard Extension API (javax.sql)
Connection Pooling
JDBC Programming with ORACLE, MYSQL, etc.
Batch Processing
Connecting to non-conventional databases
Database of Excel API
cashing (case study with HSDB,CSQL)
Working with Multiple Databases
Introduction to J2EE
J2EE Overview
Why J2EE?
J2EE Architecture
J2EE Containers
Java Server Technologies
The Project
Java Server Pages Technology (JSP)
Basic JSP Architecture
Life Cycle of JSP (Translation, compilation)
JSP Tags and Expressions
JSP Tags and Expressions
JSP with Database
JSP Implicit Objects
Tag Libraries
JSP Expression Language (EL)
Using Custom Tag
Web Application Basics
Architecture and challenges of Web Application
Introduction to servlet
Servlet life cycle
Developing and Deploying Servlets
Exploring Deployment Descriptor (web.xml)
Handling Request and Response
Initializing a Servlet
Accessing Database
Servlet Chaining
Session Tracking & Management
Dealing with cookies
Transferring Request
Accessing Web Context
Passing INIT and CONTEXT Parameter
Sharing information using scope object
Controlling concurrent access
User Authentication
Filtering Request and Response
Programming Filter
Filter Mapping
Servlet Listeners
SP Capabilities
Exception Handling
Session Management

JSP with Java Bean
RMI (Remote Method Invocation)
RMI overview
RMI architecture
Example demonstrating RMI
Enterprise JAVA Beans (EJB)
Enterprise Bean overview
Types of enterprise beans
Advantages of enterprise beans
The Life Cycles of Enterprise Beans
Working with Session Beans
Statefull vs. Stateless Session Beans
Working with Entity Beans
Message Driven Beans
JNDI (Java Naming and Directory Interface)
JNDI (Java Naming and Directory Interface)
Context operations
Using JNDI in J2EE applications
Struts Framework
What is Struts?
Struts Architecture
Struts classes - ActionForward, ActionForm
ActionServlet, Action classes
Understanding struts-config.xml
Understanding Action Mappings
Struts flow with an example application
Struts Tiles Framework
Struts Validation Framework
Internationalizing Struts Application
Struts with Message Resources
Awareness to Other J2EE Technologies
Java Mail
Web Services
Spring Framework
Design Pattern


Introduction Python is a popular, general-purpose, multi-paradigm, open-source, scripting language. It is designed to emphasize code readability – has a clean syntax with high level data types. It is suited for interactive work and quick prototyping, while being powerful enough to write large applications in.
Python has a large number of available and well-written modules for everything from abstract syntax trees to ZIP file manipulation. Its ecosystem features an extensive set of tools including a JIT compiler1 1 IDE’s2 .
In this half-day workshop, you will be introduced to basic Python language syntax and to its ecosystem.


After taking this course, you should be able to:

Use Python interactively
Use Python types, expressions, and None
Use string literals and string type
Use Python statements (if...elif..else, for, pass, continue, . . . )
Understand the difference between expressions and statements
Understand assignment semantics
Write and call a simple function
Utilize high-level data types such as lists and dictionaries
Understand the difference between mutable and immutable types
Write a simple class and access methods and attributes
Import and utilize a module
Read from and write to a text file
Understand interpreter and compilers: CPython, PyPy, Cython
See demonstration of IDE’s: IDLE, IPython, IPython Notebook, hosted environments
Understand the role of package managers: easy_install, pip
Understand what NumPy does and what SciPy is (are?)
Learn about resources for learning Python3
The Project

Training Mode

Weekends (Sat/Sun)
Only Sundays

How to Apply:

If you require any further information regarding our advanced Programming Course please contact our Programming training admission team.,    +91 (0)9566 860 890.