Big Data Masters Program Training Course

Syllabus of Core Java Course

• Features of Java
• Simple
• Secure
• Portable
• Robust
• Multithreading
• Platform-Independent
• Distributed.
• Dynamic
• New Features of Java 8
• Introducing Java Environment
• Java Development Kit
• Java Platforms
• Java Virtual Machine
• Java API
• Java Programs
• Installing Java
• What about CLASSPATH?
• Java’s Reserve Words
• Starting a Java program
• Line 1—public class App
• Line 2—public static void main(String[] args)
• Line 3—System.out.println(“Hello from Java!”);
• Compiling Code 15
• Compiling Code: Using Command-Line Options
• Cross-Compilation Options
• Compiling Code: Checking for Deprecated Methods
• Running Code
• Running Code: Using Command-Line Options
• Commenting Your Code
• Importing Java Packages and Classes
• Finding Java Class with CLASSPATH
• Summary

• Variables
• Data Typing
• Arrays
• Strings
• What Data Types are Available?
• Creating Integer Literals
• Creating Floating-Point Literals
• Creating Boolean Literals
• Creating Character Literals
• Creating String Literals
• Creating Binary Literals
• Using Underscores in Numeric Literals
• Declaring Integer Variables
• Declaring Floating-Point Variables
• Declaring Character Variables
• Declaring Boolean Variables
• Initializing Variables Dynamically
• Conversion between Data Types
• Automatic Conversions
• Casting to New Data Types
• Declaring One-Dimensional
• Creating One-Dimensional Arrays
• Initializing One-Dimensional Arrays
• Declaring Multi-Dimensional Arrays
• Creating Multi-Dimensional Arrays
• Initializing Multi-Dimensional Arrays
• Creating Irregular Multi-Dimensional Arrays
• Getting an the Length of an Array
• Understanding General Form of Static Import
• Importing Static Members
• The String Class
• Getting String Length
• Concatenating Strings
• Getting Characters and Substrings
• Searching For and Replacing Strings
• Changing Case in Strings
• Checking for Empty String
• Formatting Numbers in Strings
• The StringBuffer Class
• Creating StringBuffers
• Getting and Setting StringBuffer Lengths and Capacities
• Setting Characters in String Buffers
• Appending and Inserting Using StringBuffers
• Deleting Text in StringBuffers
• Replacing Text in String Buffer
• Using the Wrapper Class
• Autoboxing and Unboxing of Primitive Types
• Learning the Fundamentals of Varargs Methods
• Overloading Varargs Methods
• Learning the Ambiguity in Varargs Methods
• Using Non-Reifiable Formal Parameters

• Operators
• Conditionals
• Loops
• Operator Precedence
• Incrementing and Decrementing (++ and --)
• Unary NOT (~ And !)
• Multiplication and Division (* and /)
• Modulus (%)
• Addition and Subtraction (+ and -)
• Shift Operators (>>, >>>, and <<)
• Relational Operators (>, >=, <, <=, ==, and !=)
• Bitwise and Bitwise Logical AND, XOR, and OR (&, ^, and /)
• Logical (&& and ||)
• The if-then-else Operator
• Assignment Operators (= and [operator]=)
• Using the Math
• Changes in the Math Class
• Class StrictMath
• Comparing Strings
• The if Statement
• The else Statement
• Nested if
• The if-else Ladders
• The switch Statement
• Using Strings in switch Statement
• The while Loop
• The do-while Loop
• The for Loop
• The for-each Loop
• Supporting for-each in Your Own Class
• A (Poor) Solution
• Significance of for-
• Nested Loops
• Using the break Statement
• Using the continue Statement
• Using the return Statement
• Summary

• The Control Overview of a Class
• Working with Objects
• Working with Methods
• Defining Default Methods
• Working with Constructors
• Using Default Constructor
• Using Parameterized Constructors
• Exploring Packages
• Studying the Types of Packages
• Importing Packages
• Using Access Specifiers
• Working with Streams API
• Stream API Overview
• Collection and Stream
• Commonly Used Functional Interfaces in Stream
• Java.util.Optional
• Aggregate Operations
• Working with Time API

• Understanding Encapsulation
• Understanding Abstraction
• Understanding Inheritance
• Understanding the final Keyword
• Preventing Inheritance
• Declaring Constant
• Preventing Method Overriding
• Implementing Interfaces
• Working with Lambda Expressions
• Method References
• Using Lambda Expressions
• Implementing Abstract Classes and Methods
• Difference between Abstract Classes and Interfaces
• Implementing Polymorphism
• Understanding the Static Polymorphism
• Understanding the Dynamic Polymorphism
• Summary

• Streams, Readers and Writers
• Essentials in NIO
• Buffers
• Channels
• Charsets and Selectors
• Enhancements in NIO with Java 8
• The Path Interface
• The Files Class
• The Paths Class
• The File Attribute Interfaces
• The FileSystem Class
• The FileSystems Class
• The FileStore Class
• Prospects of NIO
• Working with Streams
• The InputStream Class
• The OutputStream Class
• The ByteArrayInputStream Class
• The ByteArrayOutputStream Class
• The BufferedInputStream Class
• The BufferedOutputStream Class
• The FileInputStream Class
• The FileOutputStream Class
• Working with the Reader Class
• Working with the Writer Class
• Accepting Input from the Keyboard with the InputStreamReader Class
• Working with the OutputStreamWriter Class
• Working with Files
• Using the File Class
• Using the FileReader Class
• Using the FileWriter Class
• Working with the RandomAccessFile Class
• Working with Character Arrays
• Using the CharArrayReader Class
• Using the CharArrayWriter Class
• Working with Buffers
• Using the BufferedReader Class
• Using the BufferedWriter Class
• Working with the PushbackReader Class
• Working with the PrintWriter Class
• Working with the StreamTokenizer Class
• Implementing the Serializable Interface
• Working with the Console Class
• Working with the Clipboard
• Working with the Printer
• Printing with the Formatter Class
• Using the System.out.printf() Method
• Using the String.format() Method
• Formatting Dates Using the String.format() Method
• Using the Java.util.Formatter Class
• Scanning Input with the Scanner class
• Summary

• Overview of Exceptions
• Exception Handling Techniques
• Rethrowing Catched Exception with Improved Type Checking
• Built-in Exceptions
• User-Defined Exceptions
• Summary

• Using Threads in Java
• Life Cycle of a Thread
• Synchronization of Threads
• Multithreaded Custom Class Loader
• Getting the Main Thread
• Naming a Thread
• Pausing a Thread
• Creating a Thread with the Runnable Interface
• Creating a Thread with the Thread Class
• Creating Multiple Threads
• Joining Threads
• Checking if a Thread Is Alive
• Setting Thread Priority and Stopping Threads
• Synchronizing
• Communicating between Threads
• Suspending and Resuming Threads
• Creating Graphics Animation with Threads
• Eliminating Flicker in Graphics Animation Created Using Threads
• Suspending and Resuming Graphics Animation
• Using Double Buffering
• Simplifying Producer-Consumer with the Queue Interface
• Implementing Concurrent Programming
• Simplifying Servers Using the Concurrency Utilities
• Knowing Various Concurrency Utilities
• Learning about the Java.util.concurrent Package
• Learning about the Java.util.concurrent.locks Package
• Learning about the Java.util.concurrent.atomic Package
• Summary

• The Collection Interfaces
• The Collection Classes
• The Map Interfaces
• The Map Classes
• Collections Framework Enhancements in Java SE 8
• Using the Collection Interface
• The Queue Interface
• The List Interface
• The Set Interface
• The SortedSet Interface
• Using the Collection Classes
• Using the Comparator Interface
• Using the Iterator Interface
• Using the ListIterator Interface
• Using the AbstractMap Class
• Using the HashMap Class
• Using the TreeMap Class
• Using the Arrays Class
• Learning the Fundamentals of Enumerations
• The Legacy Classes and Interfaces
• Using the Aggregate Operations
• Using the Java.util.function Package
• Summary

• Packages and Interfaces
• JAR Files
• The Java API Package
• The Java.lang Package
• Basics of Annotation
• Other Built-In Annotations
• Creating a Package
• Creating Packages that have Subpackages
• Creating an Interface
• Implementing an Interface
• Extending an Interface
• Using Interfaces for Callbacks
• Performing Operations on a JAR File
• Marker Annotations
• Single Member Annotations
• Summary

• What is Java Bean?
• Advantages of Java Bean
• Introspection
• Persistence
• Customizers
• Understanding Java Beans
• Designing Programs Using Java Beans
• Creating Applets that Use Java Beans
• Creating a Java Bean
• Creating a Bean Manifest File
• Creating a Bean JAR File
• Creating a New Bean
• Adding Controls to Beans
• Giving a Bean Properties
• Design Patterns for Properties
• Using Simple Properties
• Designing Patterns for Events
• Learning Methods and Design Patterns
• Creating Bound Properties
• Giving a Bean Methods
• Giving a Bean an Icon
• Creating a BeanInfo Class
• Setting Bound and Constrained Properties
• Implementing Persistence
• Using the Java Beans API
• Learning the Basics of an Event
• Using the Java Beans Conventions
• Using the Remote Notification and Distributed Notification
• Using Beans with JSP
• Summary

• Basics of Networking
• Sockets in Java
• Client-Server Networking
• Proxy Servers
• Internet Addressing
• Domain Name Service
• Inet4Addresses and Inet6Addresses
• The URL Class
• The URI Class
• URI Syntax and Components
• TCP/IP and Datagram
• Blackboard Assignment Retrieval Transaction
• Understanding Networking Interfaces and Classes in the Java.net Package
• Understanding the InetAddresses
• Caching InetAddress
• Creating and Using Sockets
• Creating TCP Clients and Servers
• Understanding the Whois Example
• Submitting an HTML Form from a Java Program
• Handling URL
• Using the URLConnection Objects
• Working with Datagrams
• Datagrams Server and Client
• Working with BART
• Learning about the Java.security Package
• Summary

• Introducing Events
• Introducing Event Handling
• Working with the Types of Servlet Events
• Developing the onlineshop Web Application
• Introducing Wrappers
• Working with Wrappers
• Summary

• Introducing JSP Technology
• Listing Advantages of JSP over Java Servlet
• Exploring the Architecture of a JSP Page
• Describing the Life Cycle of a JSP Page
• Working with JSP Basic Tags and Implicit Objects
• Working with Action Tags in JSP
• Exploring EL
• Using Custom Tag Library with EL Functions

• Exploring the Need of Filters
• Exploring the Working of Filters
• Exploring Filter API
• Configuring a Filter
• Creating a Web Application Using Filters
• Using Initializing Parameter in Filters
• Manipulating Responses
• Discussing Issues in Using Threads with Filters
• Summary

• Describing the Java EE Application Architecture
• Introducing a Design Pattern
• Discussing the Role of Design Patterns
• Exploring Types of Patterns
• Summary

• Section A: Exploring SOA and Java Web Services
• Overview of SOA
• Describing the SOA Environment
• Overview of JWS
• Role of WSDL, SOAP and Java/XML Mapping in SOA
• Section B: Understanding Web Service Specifications to Implement SOA
• Exploring the JAX-WS 2.2 Specification
• Exploring the JAXB 2.2 Specification
• Exploring the WSEE 1.3 Specification
• Exploring the WS-Metadata 2.2 Specification
• Describing the SAAJ 1.3 Specification
• Working with SAAJ and DOM APIs
• Describing the JAXR Specification
• JAXR Architecture
• Exploring the StAX 1.0 Specification
• Exploring the WebSocket 1.0 Specification
• Describing the JAX-RS 2.0 Specification
• Exploring the JASON-P 1.0 Specification
• Section C: Using the Web Service Specifications
• Using the JAX-WS 2.2 Specification
• Using the JAXB 2.2 Specification
• Using the WSEE and WS-Metadata Specifications
• Implementing the SAAJ Specification
• Implementing the JAXR Specification
• Implementing the StAX Specification

Syllabus of SQL Training Course

• What is PHP?
• The history of PHP
• Why choose PHP?
• Installation overview

• Embedding PHP code on a page
• Outputting dynamic text
• The operational trail
• Inserting code comments

• Variables
• Strings
• String functions
• Numbers part one: Integers
• Numbers part two: Floating points
• Arrays
• Associative arrays
• Array functions
• Booleans
• NULL and empty
• Type juggling and casting
• Constants

• If statements
• Else and elseif statements
• Logical operators
• Switch statements

• While loops
• For loops
• Foreach loops
• Continue
• Break
• Understanding array pointers

• Defining functions
• Function arguments
• Returning values from a function
• Multiple return values
• Scope and global variables
• Setting default argument values

• Common problems
• Warnings and errors
• Debugging and troubleshooting

• Links and URLs
• Using GET values
• Encoding GET values
• Encoding for HTML
• Including and requiring files
• Modifying headers
• Page redirection
• Output buffering

• Building forms
• Detecting form submissions
• Single-page form processing
• Validating form values
• Problems with validation logic
• Displaying validation errors
• Custom validation functions
• Single-page form with validations

• Working with cookies
• Setting cookie values
• Reading cookie values
• Unsetting cookie values
• Working with sessions

• MySQL introduction
• Creating a database
• Creating a database table
• CRUD in MySQL
• Populating a MySQL database
• Relational database tables
• Populating the relational table

• Database APIs in PHP
• Connecting to MySQL with PHP
• Retrieving data from MySQL
• Working with retrieved data
• Creating records with PHP
• Updating and deleting records with PHP
• SQL injection
• Escaping strings for MySQL
• Introducing prepared statements

• Blueprinting the application
• Building the CMS database
• Establishing your work area
• Creating and styling the first page
• Making page assets reusable
• Connecting the application to the database

• Adding pages to the navigation subjects
• Refactoring the navigation
• Selecting pages from the navigation
• Highlighting the current page
• Moving the navigation to a function

• Finding a subject in the database
• Refactoring the page selection
• Creating a new subject form
• Processing form values and adding subjects
• Passing data in the session
• Validating form values
• Creating an edit subject form
• Using single-page submission
• Deleting a subject
• Cleaning up
• Assignment: Pages CRUD
• Assignment results: Pages CRUD

• The public appearance
• Using a context for conditional code
• Adding a default subject behaviour
• The public content area
• Protecting page visibility

• User authentication overview
• Admin CRUD
• Encrypting passwords
• Salting passwords
• Adding password encryption to CMS
• New PHP password functions
• Creating a login system
• Checking for authorization
• Creating a logout page

• Using variable variables
• Applying more array functions
• Building dates and times: Epoch/Unix
• Formatting dates and times: Strings and SQL
• Setting server and request variables
• Establishing global and static variable scope
• Making a reference assignment
• Using references as function arguments
• Using references as function return values

• Introducing the concept and basics of OOP
• Defining classes
• Defining class methods
• Instantiating a class
• Referencing an instance
• Defining class properties

• Understanding class inheritance
• Setting access modifiers
• Using setters and getters
• Working with the static modifier
• Reviewing the scope resolution operator
• Referencing the Parent class
• Using constructors and destructors
• Cloning objects
• Comparing objects

• File system basics
• Understanding file permissions
• Setting file permissions
• PHP permissions
• Accessing files
• Writing to files
• Deleting files
• Moving the file pointer
• Reading files
• Examining file details
• Working with directories
• Viewing directory content

• Configuring PHP for email
• Sending email with mail()
• Using headers
• Reviewing SMTP
• Using PHPMailer

Syllabus of Linux Administrator Training Course

• Run Levels
• /etc/rc.d Files
• Customization of Run Levels
• cron and anacron
• at and batch

• Console Logon
• Controlling Console Login
• Virtual Consoles
• Serial Login
• Remote Login
• ssh Login

• Kernel Versions
• Kernel Source Files
• Kernel Patch Files
• Kernel Configuration
• Kernel Building
• Testing a New Kernel

• Partition Types
• Filesystem Types
• Mounting
• Automount
• File Types
• File Security

• Boot Files
• User Files
• Administrator Files
• Configuration Files
• Log Files

• Process Info
• Kernel Config Info
• Hardware Info
• Changing /proc Info
• Sysctl

• Key /bin Commands
• Key /sbin Commands
• History
• man and info
• vi
• Using Shell Scripts

• Users and Groups
• Home Directories
• Password Files
• PAM
• Quotas
• NIS Intro

• tar Files
• Patch Files
• RPM

• Types of Devices
• /dev Namespace
• Modules

• Types of Network Devices
• Monitoring Network Devices
• Controlling Network Services
• xinted
• iptables

• DHCP
• DNS
• SSH

• FTP
• NFS
• Samba

• Sendmail
• Apache
• Squid Proxy Server

• X Servers and X Clients
• XFree86
• X Fonts
• GTK and KDE

Syllabus of Hadoop Course

• High Availability
• Scaling
• Advantages and Challenges

• What is Big data
• Big Data opportunities,Challenges
• Characteristics of Big data

• Hadoop Distributed File System
• Comparing Hadoop & SQL
• Industries using Hadoop
• Data Locality
• Hadoop Architecture
• Map Reduce & HDFS
• Using the Hadoop single node image (Clone)

• HDFS Design & Concepts
• Blocks, Name nodes and Data nodes
• HDFS High-Availability and HDFS Federation
• Hadoop DFS The Command-Line Interface
• Basic File System Operations
• Anatomy of File Read,File Write
• Block Placement Policy and Modes
• More detailed explanation about Configuration files
• Metadata, FS image, Edit log, Secondary Name Node and Safe Mode
• How to add New Data Node dynamically,decommission a Data Node dynamically (Without stopping cluster)
• FSCK Utility. (Block report)
• How to override default configuration at system level and Programming level
• HDFS Federation
• ZOOKEEPER Leader Election Algorithm
• Exercise and small use case on HDFS

• Map Reduce Functional Programming Basics
• Map and Reduce Basics
• How Map Reduce Works
• Anatomy of a Map Reduce Job Run
• Legacy Architecture ->Job Submission, Job Initialization, Task Assignment, Task Execution, Progress and Status Updates
• Job Completion, Failures
• Shuffling and Sorting
• Splits, Record reader, Partition, Types of partitions & Combiner
• Optimization Techniques -> Speculative Execution, JVM Reuse and No. Slots
• Types of Schedulers and Counters
• Comparisons between Old and New API at code and Architecture Level
• Getting the data from RDBMS into HDFS using Custom data types
• Distributed Cache and Hadoop Streaming (Python, Ruby and R)
• YARN
• Sequential Files and Map Files
• Enabling Compression Codec’s
• Map side Join with distributed Cache
• Types of I/O Formats: Multiple outputs, NLINEinputformat
• Handling small files using CombineFileInputFormat

• Hands on “Word Count” in Map Reduce in standalone and Pseudo distribution Mode
• Sorting files using Hadoop Configuration API discussion
• Emulating “grep” for searching inside a file in Hadoop
• DBInput Format
• Job Dependency API discussion
• Input Format API discussion,Split API discussion
• Custom Data type creation in Hadoop

• ACID in RDBMS and BASE in NoSQL
• CAP Theorem and Types of Consistency
• Types of NoSQL Databases in detail
• Columnar Databases in Detail (HBASE and CASSANDRA)
• TTL, Bloom Filters and Compensation

• HBase Installation, Concepts
• HBase Data Model and Comparison between RDBMS and NOSQL
• Master & Region Servers
• HBase Operations (DDL and DML) through Shell and Programming and HBase Architecture
• Catalog Tables
• Block Cache and sharding
• SPLITS
• DATA Modeling (Sequential, Salted, Promoted and Random Keys)
• Java API’s and Rest Interface
• Client Side Buffering and Process 1 million records using Client side Buffering
• HBase Counters
• Enabling Replication and HBase RAW Scans
• HBase Filters
• Bulk Loading and Co processors (Endpoints and Observers with programs)
• Real world use case consisting of HDFS,MR and HBASE

• Hive Installation, Introduction and Architecture
• Hive Services, Hive Shell, Hive Server and Hive Web Interface (HWI)
• Meta store, Hive QL
• OLTP vs. OLAP
• Working with Tables
• Primitive data types and complex data types
• Working with Partitions
• User Defined Functions
• Hive Bucketed Tables and Sampling
• External partitioned tables, Map the data to the partition in the table, Writing the output of one query to another table, Multiple inserts
• Dynamic Partition
• Differences between ORDER BY, DISTRIBUTE BY and SORT BY
• Bucketing and Sorted Bucketing with Dynamic partition
• RC File
• INDEXES and VIEWS
• MAPSIDE JOINS
• Compression on hive tables and Migrating Hive tables
• Dynamic substation of Hive and Different ways of running Hive
• How to enable Update in HIVE
• Log Analysis on Hive
• Access HBASE tables using Hive
• Hands on Exercises

• Pig Installation
• Execution Types
• Grunt Shell
• Pig Latin
• Data Processing
• Schema on read
• Primitive data types and complex data types
• Tuple schema, BAG Schema and MAP Schema
• Loading and Storing
• Filtering, Grouping and Joining
• Debugging commands (Illustrate and Explain)
• Validations,Type casting in PIG
• Working with Functions
• User Defined Functions
• Types of JOINS in pig and Replicated Join in detail
• SPLITS and Multiquery execution
• Error Handling, FLATTEN and ORDER BY
• Parameter Substitution
• Nested For Each
• User Defined Functions, Dynamic Invokers and Macros
• How to access HBASE using PIG, Load and Write JSON DATA using PIG
• Piggy Bank
• Hands on Exercises

• Sqoop Installation
• Import Data.(Full table, Only Subset, Target Directory, protecting Password, file format other than CSV, Compressing, Control Parallelism, All tables Import)
• Incremental Import(Import only New data, Last Imported data, storing Password in Metastore, Sharing Metastore between Sqoop Clients)
• Free Form Query Import
• Export data to RDBMS,HIVE and HBASE
• Hands on Exercises

• HCatalog Installation
• Introduction to HCatalog
• About Hcatalog with PIG,HIVE and MR
• Hands on Exercises

• Flume Installation
• Introduction to Flume
• Flume Agents: Sources, Channels and Sinks
• Log User information using Java program in to HDFS using LOG4J and Avro Source, Tail Source
• Log User information using Java program in to HBASE using LOG4J and Avro Source, Tail Source
• Flume Commands
• Use case of Flume: Flume the data from twitter in to HDFS and HBASE. Do some analysis using HIVE and PIG

• HUE.(Hortonworks and Cloudera)

• Workflow (Action, Start, Action, End, Kill, Join and Fork), Schedulers, Coordinators and Bundles.,to show how to schedule Sqoop Job, Hive, MR and PIG
• Real world Use case which will find the top websites used by users of certain ages and will be scheduled to run for every one hour
• Zoo Keeper
• HBASE Integration with HIVE and PIG
• Phoenix
• Proof of concept (POC)

• Spark Overview
• Linking with Spark, Initializing Spark
• Using the Shell
• Resilient Distributed Datasets (RDDs)
• Parallelized Collections
• External Datasets
• RDD Operations
• Basics, Passing Functions to Spark
• Working with Key-Value Pairs
• Transformations
• Actions
• RDD Persistence
• Which Storage Level to Choose?
• Removing Data
• Shared Variables
• Broadcast Variables
• Accumulators
• Deploying to a Cluster
• Unit Testing
• Migrating from pre-1.0 Versions of Spark
• Where to Go from Here

Syllabus of Apache Spark with Scala Course

Module 1: Introduction

• 1. Overview of Hadoop 
• 2. Architecture of  HDFS  & YARN
• 3. Overview of Spark version 2.2.0
• 4. Spark Architecture
• 5. Spark  Components 
• 6. Comparison of  Spark &  Hadoop
• 7. Installation of Spark v 2.2.0 on Linux 64 bit

Module 2: Spark Core

• 1. Exploring the Spark shell 
• 2. Creating Spark Context
• 3. Operations on Resilient Distributed Dataset – RDD
• 4. Transformations & Actions 
• 5. Loading Data and Saving Data

Module 3: Spark SQL & Hive SQL

• 1. Introduction to SQL  Operations
• 2. SQL Context
• 3. Data Frame
• 4. Working with Hive
• 5. Loading Partitioned Tables
• 6. Processing  CSV, Json ,Parquet files

Module 4: Scala Programming

• 1. Introduction to Scala
• 2. Feature of Scala
• 3. Scala vs Java Comparison
• 4. Data types
• 5. Data Structure
• 6. Arrays
• 7. Literals
• 8. Logical Operators
• 9. Mutable & Immutable variables
• 10. Type interface

Module 5: Scala Functions

• 1. Oops  vs Functions
• 2. Anonymous 
• 3. Recursive 
• 4. Call-by-name
• 5. Currying
• 6. Conditional statement

Module 6: Scala Collections

• 1. List
• 2. Map
• 3. Sets
• 4. Options
• 5. Tuples
• 6. Mutable collection
• 7. Immutable collection
• 8. Iterating
• 9. Filtering and counting 
• 10. Group By
• 11. Flat Map
• 12. Word count
• 13. File Access

Module 7: Scala Object Oriented Programming

• 1. Classes ,Objects & Properties
• 2. Inheritance

Module 8: Spark Submit

• 1. Maven  build tool implementation
• 2. Build Libraries
• 3. Create  Jar files 
• 4. Spark-Submit

Module 9: Spark Streaming

• 1. Overview  of Spark Streaming
• 2. Architecture of Spark Streaming 
• 3. File streaming
• 4. Twitter Streaming

Module 10: Kafka Streaming

• 1. Overview  of Kafka Streaming
• 2. Architecture of Kafka Streaming 
• 3. Kafka Installation
• 4. Topic
• 5. Producer
• 6. Consumer
• 7. File streaming
• 8. Twitter Streaming

Module 11: Spark Mlib

• 1. Overview  of Machine Learning Algorithm
• 2. Linear Regression
• 3. Logistic Regression

Module 12: Spark GraphX

• 1. GraphX overview
• 2. Vertices
• 3. Edges
• 4. Triplets
• 5. Page Rank
• 6. Pregel

Module 13: Performance Tuning

• 1. On-Off-heap memory tuning
• 2. Kryo Serialization
• 3. Broadcast Variable
• 4. Accumulator Variable
• 5. DAG Scheduler
• 6. Data Locality
• 7. Check Pointing
• 8. Speculative Execution
• 9. Garbage Collection