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

Data Structures

CMSACOR05T: Data Structures Theory: 60 Lectures 

1. Arrays (5 Lectures):

            Single and Multi-dimensional Arrays, 

            Sparse Matrices (Array and Linked Representation) 

2. Stacks (5 Lectures):

           Implementing single / multiple stack/s in an Array; 

           Prefix, Infix and Postfix expressions, 

           Utility and conversion of these expressions from one to another;

           Applications of stack; 

           Limitations of Array representation of stack

 3. Linked Lists (10 Lectures) :

          Singly linked list

          Doubly linked list

          Circular Lists (Array and Linked representation);

          Normal and Circular representation of Stack in Lists; 

          Self Organizing Lists; 

          Skip Lists 

4. Queues (5 Lectures) 

          Array and Linked representation of Queue, 

          De-queue, 

          Priority Queues 

5. Recursion (5 lectures):

         Developing Recursive Definition of Simple Problems and their implementation;

         Advantages and Limitations of Recursion; 

        Understanding what goes behind Recursion (Internal Stack Implementation)

6. Trees (20 Lectures):

        Introduction to Tree as a data structure;

        Binary Trees (Insertion, Deletion, Recursive and Iterative Traversals on Binary Search Trees);               Threaded Binary Trees (Insertion, Deletion, Traversals); 

        Height-Balanced Trees (Various operations on AVL Trees). 

7. Searching and Sorting (5 Lectures):

             Linear Search - CLICK HERE

             Binary Search  -  CLICK HERE

             Comparison of Linear and Binary Search

             Selection Sort - CLICK HERE

             Insertion Sort - CLICK HERE

             Shell Sort

             Comparison of Sorting Techniques 

8. Hashing (5 Lectures) Introduction to Hashing, Deleting from Hash Table, Efficiency of Rehash Methods, Hash Table Reordering, Resolving collusion by Open Addressing, Coalesced Hashing, Separate Chaining, Dynamic and Extendible Hashing, Choosing a Hash Function, Perfect Hashing Function

Operating Systems

CMSACOR06T: Operating Systems Theory: 60 Lectures
1. Introduction (10 Lectures)
Basic OS functions, resource abstraction, types of operating systems–multiprogramming systems, batch systems , time sharing systems; operating systems for personal computers & workstations, process control & real time systems. 2. Operating System Organization (6 Lectures) Processor and user modes, kernels, system calls and systemprograms. 3. Process Management ( 20Lectures) System view of the process and resources, process abstraction, processhierarchy, threads, threading issues, thread libraries; Process Scheduling, non-pre-emptive and pre-emptive scheduling algorithms; concurrent and processes, critical section, semaphores, methods for inter-process communication; deadlocks. 4.Memory Management (10 Lectures) Physical and virtual address space; memory allocation strategies -fixedand variable partitions, paging, segmentation, virtual memory 5.File and I/O Management (10 Lectures) Directory structure, file operations, file allocation methods, devicemanagement. 6.Protection and Security (4 Lectures) Policy mechanism, Authentication, Internal access Authorization.

Computer Networks

1. Introduction to Computer Networks (8 Lectures) Network definition; network topologies; network classifications; network protocol; layered network architecture; overview of OSI reference model; overview of TCP/IP protocol suite. 2. Data Communication Fundamentals and Techniques (10 Lectures) Analog and digital signal; data-ratelimits; digital to digital line encoding schemes; pulse code modulation; parallel and serial transmission; digital to analog modulation-; multiplexing techniques- FDM, TDM; transmission media.
3. Networks Switching Techniques and Access mechanisms (10 Lectures) Circuit switching; packet switching- connectionless datagram switching, connection-oriented virtual circuit switching; dial-up modems; digital subscriber line; cable TV for data transfer. 4. Data Link Layer Functions and Protocol (10 Lectures) Error detection and error correction techniques; data-link control- framing and flow control; error recovery protocols- stop and wait ARQ, go-back-n ARQ; Point to Point Protocol on Internet. 5. Multiple Access Protocol and Networks (5 Lectures) CSMA/CD protocols; Ethernet LANS; connecting LAN and back-bone networks- repeaters, hubs, switches, bridges, router and gateways; 6. Networks Layer Functions and Protocols (6 Lectures) Routing; routing algorithms; network layer protocolof Internet- IP protocol, Internet control protocols. 7. Transport Layer Functions and Protocols (6 Lectures) Transport services- error and flow control, Connection establishment and release- three way handshake; 8. Overview of Application layer protocol (5 Lectures) Overview of DNS protocol; overview of WWW &HTTP protocol.

Design and Analysis of Algorithms

CMSACOR08T: Design and Analysis of Algorithms Lab Theory: 60 Lectures 

1. Introduction (5 Lectures) 

Basic Design and Analysis techniques of Algorithms, 

orrectness of Algorithm.

 2. Algorithm Design Techniques (8 Lectures) 

Iterative techniques, 

Divide and Conquer, 

Dynamic Programming, 

Greedy Algorithms. 

3. Sorting and Searching Techniques (20 Lectures) 

Elementary sorting techniques–

Bubble Sort -   CLICK HERE

Insertion Sort -  CLICK HERE 

Merge Sort - CLICK HERE

Advanced Sorting techniques -:

 Heap Sort -  CLICK HERE 

Quick Sort -   CLICK HERE

Sorting in Linear Time -: 

Bucket Sort - 

Radix Sort - CLICK HERE

and Count Sort, 

Searching Techniques:  i) LINEAR_SEARCH -- CLICK

                                      ii)  BINARY_SEARCH --CLICK

Medians & Order Statistics, complexity analysis; 

4. Lower Bounding Techniques (5 Lectures)

 Decision Trees 

5. Balanced Trees (7 Lectures) 

Red-Black Trees  i ) INSERTION

                             

6. Advanced Analysis Technique (5 Lectures) 

Amortized analysis 

7. Graphs (5 Lectures) 

Graph Algorithms–

Breadth First Search - CLICK HERE

Depth First Search -  CLICK HERE

and its Applications, 

Minimum Spanning Trees. -  1. PRIMS - CLICK

                                               2. KRUSKAL - CLICK

 8. String Processing (5Lectures)

 String Matching,

KMP Technique

Software Engineering

1.Introduction (8 Lectures) The Evolving Role of Software, Software Characteristics, Changing Nature of Software, Software Engineering as a Layered Technology, Software Process Framework, Framework and Umbrella Activities, Process Models, Capability Maturity Model Integration (CMMI).
2.Requirement Analysis (10 Lectures) Software Requirement Analysis, Initiating Requirement Engineering Process, Requirement Analysis and Modeling Techniques, Flow Oriented Modeling, Need for SRS, Characteristics and Components of SRS.
3.Software Project Management
(8Lectures) Estimation in Project Planning Process, Project Scheduling.
4.Risk Management
(8 Lectures) Software Risks, Risk Identification, Risk Projection and Risk Refinement, RMMM Plan. 5.Quality Management
(8 Lectures) Quality Concepts, Software Quality Assurance, Software Reviews, Metrics for Process and Projects.
6.Design Engineering
(10 Lectures) Design Concepts, Architectural Design Elements, Software
Architecture, Data Design at the
Architectural Level and Component Level, Mapping of Data Flow into Software Architecture, Modeling Component Level Design. 7.Testing Strategies & Tactics (8 Lectures) Software Testing Fundamentals, Strategic Approachto Software Testing, Test Strategies for Conventional Software, Validation Testing, System testing, Black-Box Testing, White-Box Testing and their type, Basis Path Testing.

Database Management Systems

CMSACOR10T: Database Management Systems Theory: 60 Lectures 1. Introduction (6 Lectures) Characteristics of database approach, data models, database system architecture and data
independence. 2. Entity Relationship(ER) Modeling (8 Lectures) Entity types, relationships, constraints. 3. Relation data model (20 Lectures) Relational model concepts, relational constraints, relational algebra, SQLqueries 4. Database design (15 Lectures) Mapping ER/EER model to relational database, functional dependencies,Lossless decomposition, Normal forms (upto BCNF). 5. Transaction Processing (3 Lectures) ACID properties, concurrency control 6. File Structure and Indexing (8 Lectures) Operations on files, File of Unordered and ordered records, overview of File organizations, Indexing structures for files( Primary index, secondary index, clustering index), Multilevel indexing using B and B+ trees.

Internet Technologies

Java (5 lectures) Use of Objects, Array and ArrayList class JavaScript (15 lectures) Data types, operators, functions, control structures, events and event handling. JDBC (10 lectures) JDBC Fundamentals, Establishing Connectivity and working with connection interface, Working with statements, Creating and Executing SQL Statements, Working with Result Set Objects. JSP (20 lectures) Introduction to JavaServer Pages, HTTP and Servlet Basics, The Problem with Servlets, The Anatomy of a JSP Page, JSP Processing, JSP Application Design with MVC, Setting Up the JSP Environment, Implicit JSP Objects, Conditional Processing, Displaying Values, Using an expression to Set an Attribute, Declaring Variables and Methods, Error Handling and Debugging, Sharing Data Between JSP Pages, Requests, and Users, Database Access. Java Beans (10 lectures) Java Beans Fundamentals, JAR files, Introspection, Developing a simple Bean, Connecting to DB

Theory of Computation

CMSACOR12T: Theory of Computation Theory: 75 Lectures AdditionalTutorial: 15 Lectures
1. Languages
(10 Lectures)
Alphabets, string, language, Basic Operations on language, Concatenation, Kleene Star 2. Finite Automata and Regular Languages (25 Lectures) Regular Expressions, Transition Graphs, Deterministics and non-deterministic finite automata, NFA to DFA Conversion, Regular languages and their relationship with finite automata, Pumping lemma and closure properties of regular languages. 3. Context free languages (20 Lectures) Context free grammars, parse trees, ambiguities in grammars and languages, Pushdown automata (Deterministic and Non-deterministic), Pumping Lemma, Properties of context free languages, normal forms. 4. Turing Machines and Models of Computations (20 Lectures) RAM, Turing Machine as a model of computation, Universal Turing Machine, Language acceptability, decidability, halting problem, Recursively enumerable and recursive languages, unsolvability problems.

Artificial Intelligence

CMSACOR13T: Artificial Intelligence Theory: 60 Lectures 1. Introduction (06 Lectures) Introduction to Artificial Intelligence, Background and Applications, Turing Test and Rational Agent approaches to AI, Introduction to Intelligent Agents, their structure, behavior and environment.
2. Problem Solving and Searching Techniques (20 Lectures) Problem Characteristics, Production Systems, Control Strategies, Breadth First Search, Depth First Search, Hill climbing and its Variations, Heuristics Search Techniques: Best First Search, A* algorithm, Constraint Satisfaction Problem, Means-End Analysis, Introduction to Game Playing, Min-Max and Alpha-Beta pruning algorithms.
3. Knowledge Representation (20 Lectures) Introduction to First Order Predicate Logic, Resolution Principle, Unification, Semantic Nets, Conceptual Dependencies, Frames, and Scripts, Production Rules, Conceptual Graphs. Programming in Logic (PROLOG)
4. Dealing with Uncertainty and Inconsistencies (08 Lectures) Truth Maintenance System, Default Reasoning, Probabilistic Reasoning, Bayesian Probabilistic Inference, Possible World Representations.
5. Understanding Natural Languages (06 Lectures) Parsing Techniques, Context-Free and Transformational Grammars, Recursive and Augmented Transition Nets.

Computer Graphics

CMSACOR14T: Computer Graphics Theory: 75 Lectures
1. Introduction (5 Lectures) Basic elements of Computer graphics, Applications of Computer Graphics.
2. Graphics Hardware (8 Lectures) Architecture of Raster and Random scan display devices, input/output devices.
3. Fundamental Techniques in Graphics (22 Lectures) Raster scan line, circle and ellipse drawing, thick primitives, Polygon filling, line and polygon clipping algorithms, 2D and 3D Geometric Transformations, 2D and 3D Viewing Transformations (Projections- Parallel and Perspective), Vanishing points.
4. Geometric Modeling (10 Lectures)
Representing curves & Surfaces.
5.Visible Surface determination (8 Lectures) Hidden surface elimination.
6.Surface rendering (7 Lectures) Illumination and shading models. Basic color models and Computer Animation.

Microprocessor

CSMADSE01T:Microprocessor Theory: 60 Lectures Microprocessor architecture: Internal architecture, system bus architecture, memory and I/Ointerfaces. Microprocessor programming: Register Organization, instruction formats, assembly languageprogramming. Interfacing: Memory address decoding, cache memory and cache controllers, I/O interface,keyboard, display, timer, interrupt controller, DMA controller, video controllers, communication interfaces.

Data Mining

CSMADSE02T: Data Mining Theory: 60 lectures
Overview: Predictive and descriptive data mining techniques, supervised and unsupervisedlearning techniques, process of knowledge discovery in databases, pre-processing methods
Data Mining Techniques: Association Rule Mining, classification and regressiontechniques, clustering, Scalability and data management issues in data mining algorithms, measures of interestingness

Cloud Computing

Cloud Computing
Overview of Computing Paradigm ( 8 lectures)
Recent trends in Computing : Grid Computing, Cluster Computing, Distributed Computing, Utility Computing, Cloud Computing,
Introduction to Cloud Computing ( 7 lectures) Introduction to Cloud Computing, History of Cloud Computing, Cloud service providers, Benefits and limitations of Cloud Computing,
Cloud Computing Architecture ( 20 lectures) Comparison with traditional computing architecture (client/server), Services provided at various levels, Service Models- Infrastructure as a Service(IaaS), Platform as a Service(PaaS), Software as a Service(SaaS), How Cloud Computing Works, Deployment
Models- Public cloud, Private cloud, Hybrid cloud, Community cloud, Case study of NIST architecture.
Case Studies ( 13 lectures) Case study of Service model using Google App Engine, Microsoft Azure, Amazon EC2 , Eucalyptus. Service Management in Cloud Computing ( 7 lectures) Service Level Agreements(SLAs), Billing & Accounting, Comparing Scaling Hardware: Traditional vs. Cloud, Economics of scaling. Cloud Security ( 5 lectures) Infrastructure Security- Network level security, Host level security, Application level security, Data security and Storage- Data privacy and security Issues, Jurisdictional issues raised by Data location, Authentication in cloud computing.

Big Data

Big Data Theory: 60 lectures
UNDERSTANDING BIG DATA
What is big data – why big data –.Data!, Data Storage and Analysis, Comparison with Other Systems, Rational Database Management System , Grid Computing, Volunteer Computing, convergence of key trends – unstructured data – industry examples of big data – web analytics – big data and marketing – fraud and big data – risk and big data – credit risk management – big data and algorithmic trading – big data and healthcare – big data in medicine – advertising and big data – big data technologies – introduction to Hadoop – open source technologies – cloud and big data – mobile business intelligence – Crowd sourcing analytics – inter and trans firewall analytics.
NOSQL DATA MANAGEMENT
Introduction to NoSQL – aggregate data models – aggregates – key-value and document data models – relationships – graph databases – schema less databases – materialized views – distribution models – shading –– version – map reduce – partitioning and combining – composing map-reduce calculations.
BASICS OF HADOOP Data format – analyzing data with Hadoop – scaling out – Hadoop streaming – Hadoop pipes – design of Hadoop distributed file system (HDFS) – HDFS concepts – Java interface – data flow – Hadoop I/O – data integrity – compression – serialization – Avro – file-based data structures.
MAPREDUCE APPLICATIONS MapReduce workflows – unit tests with MRUnit – test data and local tests – anatomy of MapReduce job run – classic Map-reduce – YARN – failures in classic Map-reduce and YARN – job scheduling – shuffle and sort – task execution – MapReduce types – input formats – output formats
HADOOP RELATED TOOLS Hbase – data model and implementations – Hbase clients – Hbase examples –praxis. Cassandra – Cassandra data model – Cassandra examples – Cassandra clients –Hadoop integration. Pig – Grunt – pig data model – Pig Latin – developing and testing Pig Latin scripts. Hive – data types and file formats – HiveQL data definition – HiveQL data manipulation – HiveQL queries.

Digital Image Processing

CMSADSE05T: Digital Image Processing Lab Theory: 60 Lectures
1. Introduction (6 Lectures)
Light, Brightness adaption and discrimination, Pixels, coordinate conventions, Imaging Geometry, Perspective Projection, Spatial Domain Filtering, sampling and quantization.
2. Spatial Domain Filtering (7 Lectures) Intensity transformations, contrast stretching, histogram equalization, Correlation and convolution, Smoothing filters, sharpening filters, gradient and Laplacian.
3. Filtering in the Frequency domain (8 Lectures) Hotelling Transform, Fourier Transforms and properties, FFT (Decimation in Frequency and Decimation in Time Techniques), Convolution, Correlation, 2-D sampling, Discrete Cosine Transform, Frequency domain filtering.
4. Image Restoration (8 Lectures) Basic Framework, Interactive Restoration, Image deformation and geometric transformations, image morphing, Restoration techniques, Noise characterization, Noise restoration filters,
Adaptive filters, Linear, Position invariant degradations, Estimation of Degradation functions, Restoration from projections.
5. Image Compression (10 Lectures) Encoder-Decoder model, Types of redundancies, Lossy and Lossless compression, Entropy of an information source, Shannon's 1st Theorem, Huffman Coding, Arithmetic Coding, Golomb Coding, LZW coding, Transform Coding, Sub-image size selection, blocking artifacts, DCT implementation using FFT, Run length coding, FAX compression (CCITT Group-3 and Group-4), Symbol-based coding, JBIG-2, Bit-plane encoding, Bit-allocation, Zonal Coding, Threshold Coding, JPEG, Lossless predictive coding, Lossy predictive coding, Motion Compensation
6. Wavelet based Image Compression (5 Lectures) Expansion of functions, Multi-resolution analysis, Scaling functions, MRA refinement equation, Wavelet series expansion, Discrete Wavelet Transform (DWT), Continuous Wavelet Transform, Fast Wavelet Transform, 2-D wavelet Transform, JPEG-2000 encoding, Digital Image Watermarking.
7. Morphological Image Processing (7 Lectures) Basics, SE, Erosion, Dilation, Opening, Closing, Hit-or-Miss Transform, Boundary Detection, Hole filling, Connected components, convex hull, thinning, thickening, skeletons, pruning, Geodesic Dilation, Erosion, Reconstruction by dilation and erosion.
8. Image Segmentation (9 Lectures) Boundary detection based techniques, Point, line detection, Edge detection, Edge linking, local processing, regional processing, Hough transform, Thresholding, Iterative thresholding, Otsu's method, Moving averages, Multivariable thresholding, Region-based segmentation, Watershed algorithm, Use of motion in segmentation