Java Full Stack Developer 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 Hibernate Training Course

• Need for Hibernate
• Hibernate and ORM (Object-Relation Mapping)

• Required JAR Files
• Hibernate configuration File
• Hibernate properties File
• Hibernate XML File
• SQL Dialects

• Id and Primary Key
• Id Generation Methods
• Transaction
• POJOs (Plain Old Java Objects) and the Data Layer
• Hibernate Over Entity Beans
• Understanding Hibernate Architecture
• Configuration
• SessionFactory
• Session
• Query
• Criteria
• Hibernate Configuration
• Hibernate Mappings
• Persistent Classes
• Working with Hibernate to perform
• CRUD Operations
• Configuring Mappings Using Annotations.

• Component Mapping
• Inheritance Mappings
• Table Per Class Hierarchy
• Table Per Sub Class
• Table Per Concrete Class
• Association Mappings
• One -to-One
• One -to-Many
• Many -to-One
• Many -to-Many

• Select clause
• From clause
• Where clause
• Aggregate functions
• Expressions
• Sorting
• Grouping
• Sub queries

• Creating Criteria
• Narrowing the Result
• Ordering the Result

• Using SQL Query
• Named SQL Query
• Using Stored Procedure for Querying
• Creating Custom SQL for CRUD

• Using HQL, criteria API, native sql
• Hibernate Transaction
• Hibernate and JDBC
• Hibernate second level caching

• Spring Hibernate Integration
• Data source creation
• Hibernate DAO implementation using

• Design Web Application using hibernate
• Hibernate in web application(case studies)
• Project Guidance

Syllabus of Spring Training Course

• Introduction
• Content still to come

• Which Version Of Java?
• Installing JDK 11 on Windows
• Installing and Configuring IntelliJ IDEA on Windows
• Installing JDK 11 on a Mac
• Installing and Configuring IntelliJ IDEA on a Mac
• Installing JDK 11 on a Linux Machine
• Installing and Configuring IntelliJ IDEA on a Linux Machine

• Your Programming Careers Questions Answered
• Access to Programming Career Q&A
• Spring 5 Feature Overview
• Maven and Other Tools
• Creating a Maven Project
• Importing Maven Projects
• Maven Lifecycle Plugin and Goals
• Fix our Maven Project

• What is Logging?
• Using Logging with Logback
• Logback Configuration

• Project Overview
• Create Multi Module Project
• Project Setup
• Using a Spring Container
• Implementing the Game
• Constructor Based Dependency Injection
• Setter Based Dependency Injection
• Setter or Constructor
• Using Bean Lifecycle Callbacks
• XML or Annotation Configuration
• Autowiring Beans
• Beans as Components
• Using Java Annotation Configuration
• Message Generator Challenge
• Implementing MessageGenerator Logic
• Console Module Setup Challenge
• Application Events
• Finish Game Logic
• Using Qualifiers
• Creating Custom Annotations
• Using Properties
• minNumber Challenge
• Code Cleanup and Constructor Injection
• Code Cleanup Challenge

• Lombok Introduction
• Setup Lombok
• Using Lombok
• Lombok Challenge

• Spring MVC Introduction
• Creating todo List Project
• Project Setup Challenge
• Setup Maven War Plugin
• Setup Maven Cargo Plugin and Tomcat
• Setup Dispatcher Servlet
• Simple Controller
• View Resolver and View
• Spring MVC Request Processing
• Model and Model Attributes
• Simple Service Challenge
• Request Parameters
• Project Requirements
• To Do Item Class
• To Do Data Class
• Creating the Todo Item Controller
• Creating View and Basic JSTL tags
• Todo Item Service Challenge
• Implementing the Add Item Feature
• Implementing Post Redirect Get Pattern
• Home View and Navigation
• Delete Item Challenge
• Implement Edit Item Feature
• View Item Challenge

• Introduction to Spring Boot 2
• Using Spring Initializr
• Understanding Spring Boot Project Structure
• Simple Spring Boot Application

• Add Spring Boot to an Existing Project
• Spring Boot Web Module
• Thymeleaf Introduction
• Setup Thymeleaf and Initial Template
• Spring Boot Developer Tools
• Game Service Challenge
• Play Thymeleaf Template
• Thymeleaf Preprocessing
• Thymeleaf Template Challenge
• Thymeleaf Fragments
• Thymeleaf Fragment Challenge
• Thymeleaf Decoupled Template Logic
• Thymeleaf Decoupled Template Logic Challenge
• Bug Fixes
• Spring Internationalization
• Thmyeleaf Internationalization Challenge
• Message Generator Internationalization Main Message
• Message Generator Internationalization Result Message
• Request Interception
• Locale Change Interceptor
• Thymeleaf Recap

• What is Gradle?
• Creating a Gradle Spring Boot Project
• Gradle Build Lifecycle Projects and Tasks
• Understanding the Gradle Scripts
• Running Gradle Tasks
• Simple Spring Gradle Application

• Creating a Spring Boot Project Challenge
• Configure Gradle Multi-module Project
• Configure Sub Modules
• Testing our Project
• More Content

• Install JDK for Windows
• Install Eclipse for Windows
• Install Tomcat for Windows
• Configure Tomcat Within Eclipse for Windows
• Install JDK for Mac
• Install Eclipse for Mac
• Install Tomcat for Mac
• Configure Tomcat Within Eclipse for Mac
• Install JDK for Linux
• Install Eclipse for Linux
• Install and Configure Tomcat for Linux

• Introduction to JEE
• Exploring Java EE basics: Drilling into the Concepts
• Exploring Java EE basics: Building the Servlet
• Exploring Java EE basics: Creating a JSP and running the App
• Exploring Java EE basics: Adding a Service layer to the mix
• Exploring Java EE basics: Adding JSTL Library Support
• Exploring Java EE basics: JSTL in JSP
• Exploring Java EE basics: Drilling into the Concepts

• Overview of Spring Tooling
• Install Spring IDE
• Installing Maven
• Creating a Maven Project
• Understanding the Project Object Model

• Why Spring
• Overview of the Spring Framework
• Spring Framework vs JEE
• Introducing the Spring IoC containSpring IoC container: Accessing metadata from the file Spring IoC container: Accessing metadata from theSpring IoC Container Challenge
• Setting Constructor Arguments using the Spring bean config file
• Setting Properties using the Spring bean config file
• Setter based Dependency Injection in Spring
• Setter based Dependency Injection in Spring continued
• Spring Setter based Dependency Injection in Spring : Running the App
• Constructor based Dependency Injection in Spring
• Spring Constructor based Dependency Injection : Running the App

• Creating Spring MVC Project Infrastructure
• Adding dependencies in an alternative way in a Spring MVC Project
• Adding Spring MVC Dispatcher Servlet
• Building the Spring Controller - "C" part of MVC
• Context and MVC Configuration
• Autowiring collaborating objects in Spring
• Bringing View Resolver in the mix and running the App

• Bean scopes for a Spring Bean
• Spring bean scopes: Singleton and Prototype
• Spring bean scopes, Request and Session: creating the project and Java classes
• Spring bean scopes, Request and Session: creating the config file and Controller
• Spring bean scopes, Request and Session: Running the App
• Customize Spring Bean with Callbacks
• Standard Naming for Spring Bean Callbacks
• Spring Bean instantiation using Static Factory and Instance Factory methods
• Spring Bean Definition with C Namespace
• Spring Bean Definition with P Namespace

• Pros and Cons of Spring Configuration : Annotations vs XML
• Autowiring Spring Beans: creating project infrastructure
• Autowiring Spring Beans: using setters, constructors and fields
• Spring Beans as Components: Cutting down on xml config
• Handling Properties in Spring: using XML config
• Handling Properties in Spring: mixing XML with Annotations
• Handling Properties in Spring using pure Annotations: creating infrastructure
• Handling Properties in Spring using pure Annotations: building and running

• Install MySQL for Windows
• Install MySQL on Mac
• Install MySQL on Linux
• MySQL Workbench Basics : Environment and table creation
• MySQL Workbench Basics : Insert and Export

• Introduction to Spring JDBC
• CRUD with Spring JDBC Template: Project Setup
• CRUD with Spring JDBC Template: Creating DAO Layer
• CRUD with Spring JDBC Template: XML config & Property file
• CRUD with Spring JDBC Template: More with DAOs
• CRUD with Spring JDBC Template: DAO and Test Harness
• CRUD with Spring JDBC Template: Building App and executing Test Harness
• CRUD with Spring JDBC Template: Expanding DAO Layer further
• Spring JDBC Exceptions : an Overview
• Spring Named Parameters Template: Understanding the API
• Spring Named Parameters Template: Building the DAO
• Spring Named Parameters Template : Components and Testing

• Spring Java Config: Creating the project infrastructure
• Spring Java Config: Creating the Java and Web Configuration
• Spring Java Config: Running the App
• Fix minor error in WebMvcConfig
• JNDI Datasource: Building the Spring Service and Controller
• JNDI Datasource: Conceptual Overview and Configuration
• JNDI Datasource: Building views and Running the App
• Spring MVC Architecture Going Deeper
• Spring Handler Mapping Customization: Creating the infrastructure
• Spring Handler Mapping Customization: Seeing the effect of customization
• Spring Interceptors: an Introduction
• Spring Interceptors: Integrating and building views with CSS inline styling
• Spring Interceptors: Continuing building the views with CSS Internal styling
• Spring Interceptors: Continue building views with mixed styling
• Spring Interceptors: Running the app with a closing summary
• Introducing Logging
• Logging: Working with SLF4J, a powerful logging API
• Logging: LOG4J implementation and introducing Logger, Appender and Layout
• Logging: Continuing with log4j and getting to know Conversion Patterns
• Logging: Configuring log4j.properties and wrapping up
• Spring Interceptors: Invoking all the Interceptor methods
• Spring Interceptors: Running the app and wrapping up!

• Section Overview
• RequestMapping and RequestParams In-depth : Introduction & test harness
• RequestMapping and RequestParams In-depth : Class level mapping
• RequestMapping and RequestParams In-depth : Wrapping up first test
• RequestMapping and RequestParams In-depth : method attribute & fallback
• RequestMapping and RequestParams In-depth : defaultAttribute and default naming
• RequestMapping and RequestParams In-depth : resolving ambiguous request mapping
• RequestMapping and RequestParams In-depth : multiple request mapping
• Model Attributes on Methods in-depth: Adding multiple attributes
• Model Attributes on Methods in-depth: working with 'name' attribute
• Model Attributes on Methods in-depth: working with 'value' attribute
• Model Attributes on Methods in-depth: working with ModelAndView API
• Model Attributes on Methods in-depth: Introducing Spring Form Tag and Elements
• Model Attributes on Methods in-depth: Exploring ModelAndView API
• Model Attributes on Methods in-depth: Default data binding
• Model Attributes on Methods in-depth: Implicit resolution of logical view name
• Session Attributes: Creating the project infrastructure
• Session Attributes: Bringing in the Controller
• Session Attributes: Adding the JSPs
• Session Attributes: Cranking the Java configuration
• Session Attributes: Testing our application
• Session Attribute & Request Attribute: an Introduction
• Session Attribute & Request Attribute: Applying to Interceptor and Controller
• Session Attributes, Session Attribute & Request Attribute: Testing all

• Spring Form Tags: An Overview
• Spring Form Tags: Creating project infrastructure - part 1
• Spring Form Tags: Creating project infrastructure - part 2
• Spring Form Tags: SELECT tags - part 1
• Spring Form Tags: SELECT tags - part 2
• Spring Form Tags: SELECT tags - part 3
• Spring Form Tags: CHECKBOX tags - part 1
• Spring Form Tags: CHECKBOX tags - part 2
• Spring Form Tags: CHECKBOX tags - part 3
• Spring Form Tags: CHECKBOXES tags
• Spring Form Tags: RADIOBUTTON & RADIOBUTTONS tags
• Spring Form Validation: an Introduction
• Spring Form Validation: Creating the project Infrastructure
• Spring Form Validation: Creating the JSPs
• Spring Form Validation: Running the first validation test
• Spring Form Validation: Working with @Size and @Notblank validations
• Spring Form Validation: Introducing Custom Validation Constraints
• Spring Form Validation: Creating our first Custom Validation Constraint
• Spring Form Validation: Regular Expression Validation
• Spring Form Validation: Using Apache Commons API Validator
• Spring Form Validation: Class Level Validation
• Spring Form Validation: Final Changes and Test

• IntelliJ Spring Config and Test Import
• Import Non Web Based Project
• Build Spring MVC Demo
• Controller Service and JSP
• Welcome Service and Add Beans

• Install and setup
• Which version of Java should you use?
• How To Install The Java Development Kit (JDK) For Windows
• Download and Install IntelliJ (FREE and PAID version) for Windows
• How To Install The Java Development Kit (JDK) For Mac OS X
• Download and Install IntelliJ (FREE and PAID version) on a Mac
• How To Install The Java Development Kit (JDK) For Ubuntu Linux
• Install and Configure IntelliJ (FREE and PAID version) for Ubuntu Linux

Syllabus of DevOps Course

• What is Cloud Computing
• How Cloud Computing are helpful
• Cloud's role in DevOps orchestration
• What is AWS
• Use cases in AWS
• Companies using AWS and Market tends
• Different Services offered in AWS
• Use case: - Highly available fault tolerant systems
• Understanding availability zone
• region
• Creating your own account in AWS
• Creating a VPC
• subnet
• network gets way
• Running your own EC2 instance
• Connecting in EC2 and installing https in EC2
• S3
• Over viewS3
• SNS. Cloud watch
• Understanding the Serverless (Lambda)

• What is the market trend of DevOps
• Which back ground people can switch to DevOps
• Some typical tool stack for DevOps Jobs
• How to get maximum from the course
• Client-Server and Distributed Version control system
• Git
• Advantages of Git over SVN
• Git User trends
• Different Git tools (Git Desktop. Kraken)
• Git Installation and Configuration
• Setting up Git Bash and Git UI
• Creating first repository: Local
• Git commands: add
• commit
• push
• status
• history
• Branch why what? Understanding Master
• Creating a Branch
• Merging a Branch
• Resolving Merge conflicts
• checking the difference
• Understanding the tags: Modifying
• undoing
• deleting and discarding
• What
• Use Case of Unit Testing
• Different kind of Unit Testing
• What is JUnit
• Writing a Simple JUnit Test
• Test NG introduction
• Write a Unit Testing Case in your Favorite language.
• Linux Administration
• A Linux Introduction
• Open Source Philosophy
• Distributions
• Embedded Systems
• Command Line Basics
• Basic Shell
• Command Line Syntax – ls
• Command Line Syntax – $PATH, Case Sensitivity
• Command Line Syntax – Basic Commands
• Command Line Syntax – uname
• Command Line Syntax – Command History, Command Completion
• Command Line Syntax – cd and pwd
• Shell Configuration Files
• Variables – Environment / System Variables
• Variables – User Defined
• Globbing
• Quoting
• Formatting Commands
• Working with Options
• Using the Command Line to Get Help
• Man
• Info
• locate, find, whereis, and using /usr/share/doc/
• Exercise: Man Page Walkthrough
• Exercise: Basic Command Line
• Using Directories and Listing Files
• The Linux File System
• Files, Directories
• Hidden Files and Directories
• Home
• Absolute and Relative Paths
• Exercise: Maneuvering the Linux File System
• Creating, Moving and Deleting Files
• Files and Directories
• Case Sensitivity
• Simple Globbing and Quoting
• The Power of the Command Line
• Archiving Files on the Command Line
• Files, Directories
• Archives, Compression
• Searching and Extracting Data from Files
• Commands (Revisited)
• Command Line Pipes
• I/O Redirection
• Regular Expressions
• Exercise: Practicing with Pipes and Grep
• Turning Commands into a Script
• Basic Text Editing
• Basic Shell Scripting
• Basic Shell Scripting, Continued
• Exercise: Using the vi Text Editor
• Available
• The Linux Operating System
• Choosing an Operating System
• Windows, Mac, and Linux Differences
• Distribution Life Cycle Management
• Understanding Computer Hardware
• Hardware
• Where Data is Stored
• Kernel
• Processes
• syslog, klog, dmesg
• /lib, /usr/lib, /etc, /var/log
• Your Computer on the Network
• Internet, Network, Routers
• Domain Name Service and the Default Gateway (Network Router)
• Network Configuration
• Security and File Permissions
• Basic Security and Identifying User Types
• Root and Standard Users
• System Users
• Creating Users and Groups
• User IDs
• User Commands
• Group Commands
• Exercise: Managing User Accounts
• Exercise: Creating User Groups
• Managing File Permissions and Ownership
• File/Directory Permissions and Owners
• Special Directories and Files
• Symbolic Links
• System files, Special Files, and Sticky Bits
• Use Case in Maven
• Ant vs Maven
• Maven installation and Configuration What is Maven Central
• Dependency Management why and How
• Introduction to POM
• Build lifecycle
• Maven repositories Maven plugins
• Using a POM file to run unit testing (Jenkins)
• Multi-module POM
• dependency hierarchy
• Artifactory management
• Maven Release and Snapshot
• Assignment- Create a Maven Hello world Java Project
• Run the Unit testing and and create the artifact for that
• Use Case (How Artifactories are managed)
• Artifact Lifecycle
• Basic use of Sonatype Nexus
• Artifactory Live demo
• Use Case WebServer Deployment in DevOps
• Architecture
• Different types of Webserver
• Proxy servers
• Mail Server
• Installation of Tomcat
• Manual Deployment
• Deploying a Web application using Maven
• Idea about Automated Deployment using Continuous Integration
• Create a Tomcat Server and Deploy the application manually
• Create a Tomcat Server and Deploy the Application Using Maven
• Benefits of Code Profiling tool
• Use case of Code Profiling tool
• Different kind of Code quality tools
• Over view of Sonar
• Installation of SonarQube
• Installation fo Code Analyser
• Sonar profiles
• Running Sonar for a project
• Configuring SonarQube for one Sample java project.

• Why Jenkins?
• What is Continuous Integration and Continuous Deployment (Use Case1)
• Jenkins installation and Configuration
• Running Jenkins as windows service
• Deploying Jenkins in Tomcat Server
• Jenkins Global Configuration
• Building your first Hello world job
• Jenkins User Management
• Jenkins Plugin management
• Jenkins SCM configuration (Git SVN)
• Understanding the Jenkins workspace
• Build
• pre build and post build job
• Jenkins Unit testing
• Automation testing
• Mail notification
• Jenkins Reporting
• Matrix and trend
• Jenkins remote executor
• Master Slave configuration in Jenkins
• Jenkins Most used plugin
• Advanced Reference
• Jenkins pipeline plugin
• Groovy scripting
• Scriptler
• Jenkins Parameterized build
• Environment inject plugin
• Use of Jenkins environment variables
• Deploying a specific revision
• Customizing the Jenkins UI
• Project based Matrix plugin
• Parallel Execution
• Configuring Jenkins Hub and Node in the cloud (AWS)
• Configuring a Selenium Desktop node with a Linux Server (AWS)
• Case Study
• Real time implementation of Automated role back
• Multi branch Deployment.
• What is Virtual Machine
• Why we need it
• What is Container
• Difference between Containers and Virtual Machine

• Docker Installation and Configuration
• Major Docker Components
• Container Management Running Containers
• Docker file
• Working with Registries
• Docker Port Forwarding
• What is Configuration Management
• Configuration Management Challenges
• Configuration Management in DevOps Ecosystem
• Some tools
• Trends
• What is Container and Containerization
• Different types of Containers
• DOCKER: What why how ?
• Use Case 1 (Why Docker)
• Docker installation
• Docker VS Vagrant
• Docker Run commands
• Advanced Docker
• run commands
• Docker volume persistence
• Overview of Docker Compose
• Docker Hub
• Creating your own image
• Advanced reference
• Create a Docker container to run Jenkins
• Create a Docker container to run a CI/CD pipeline
• Use case 1 (Why puppet)
• Puppet installation and configuration
• Resource implementation
• Managing files and executing programs
• Testing your code Using Puppet Languages
• Variables Numbers and Strings
• Facts
• control flow
• Regex
• Loops
• Resource Processing
• Advanced Course
• Puppet Modules
• Define QA environment
• Changing Base Module path
• Separation of Data from Code
• Introduction to Hiera
• Hiera Backend creation in Puppet
• Variables and Function lookups
• Using Puppet modules
• Puppet Forge-Server- GitHub repo.

• What is Ansible
• Advantages of Ansible
• Environment Provisioning
• Configuration Deployment
• Installation of Ansible (AWS)
• Modules
• Playbooks and Writing a Playbook
• What is Monitoring
• Why we need monitoring
• Different tools of monitoring
• What is Nagios
• Nagios Architecture
• Different components of Nagios
• A typical Nagios Dashboard
• Installation and Configuration

Syllabus of HTML & CSS Course

• New in HTML5
• New DOCTYPE and Character Set
• New and Depreciated Elements
• Semantic Markup
• Simplifying Selection using the Selectors API
• JavaScript Logging and Debugging
• Window.JSON
• DOM Level

• Currently available features
• Browser Support
• Detective native availability of features
• Working with emulation
• Create a web page that verifies the availability of new HTML5 features.

• HTML5 Page Structure
• HTML5 DOCTYPE
• HTML5 markup structural elements
• Semantic elements
• Create a web page that make usage of new structural and semantic elements like main, section, aside, article, header, footer and other semantic elements.

• HTML Forms VsXForms
• Functional Forms
• New Form Attributes and Functions
• Placeholder Attribute
• Autocomplete Attribute
• Autofocus Attribute
• List Attribute and datalist Element
• Min and Max attributes
• ValueAsNumber attribute
• Required Attribute
• Checking Forms with Validation
• Validation Feedback
• Develop a product entry form which uses HTML5 form elements and validation attributes.

• The Audio and Video Elements
• Understanding Audio and Video
• Working with Audio and Video Containers
• Understanding Audio and Video Codecs
• Create a web page that displays multiple video and audio using HTML5 video and audio elements.

• Overview of Canvas Vs. SVG
• Canvas coordinates
• Context
• Pixel Data
• Working with Canvas APIs
• Drawing Operations
• Canvas Transforms
• Understanding and Working with SVG
• Create a web page that makes use of basic Canvas API and also displays svg graphics and drawings.

• Overview of HTML5 Web Storage
• Browser Support for HTML4 Web Storage
• Using the HTML5 Web Storage
• Checking for Browser Support
• Setting and Retrieving Values
• Plugging Data Leaks
• Create a web page that sites and gets data Run HTML5 web storage.

• Introducing CSS3
• CSS3 Colors, Gradients and Multiple Backgrounds
• Rounded Corners and Border-Radius
• CSS3 Transforms
• Transitions
• Animations & 2D Transformations
• Web Fonts with @font-face
• CSS3 Multicolumn Layouts
• Develop a web page that enhances the richness of the page using CSS3,colours,gradients,border radius,animation,transformations and transitions.

• Introduction
• Box Model basics
• Container
• Direction
• Wrapping
• Justifying & Alignments
• Display order
• Flexibility
• Alignment
• Create a page that displays product gallery layout coded with flexbox.

• Introduction
• Grid Layout
• Grid Elements
• Placing Grid Lines
• Attaching Elements to the Grid
• Order and Align Items in Grid Layout
• Grid Flow
• Opening Grid Spaces
• Create a page that displays product gallery layout coded with CSS grid.

Syllabus of Amazon Web Services (AWS) Course

• Overview of all basic commands
• Vim editor modes
• Filesystem hierarchy – Basic topics
• File and directories creation
• Grep
• Filter commands (head,tail,more,less)
• Creating users and groups
• Important files related
• Modifying,deleting users and group
• Linux permissions
• Basic permissions overview
• Software management
• Yellowdog update modifier(yum)
• Yum commands
• Different runlevels
• Services and daemons

• Why Cloud and What is Cloud Computing?
• Identify the features and benefits of cloud computing
• Different types of Cloud Computing deployment model
• Public Cloud, Private Cloud, Hybrid Cloud
• Virtualization – An essential in cloud
• Virtualization in Cloud model
• Different types of virtualization
• Hypervisor – Benefits
• Different types of services and its difference in Cloud computing
• IaaS, PaaS, SaaS
• Importance of scaling in cloud computing
• Different types of scaling and its applications
• Issues we overcome using cloud and applications
• Cost model that we use in cloud computing

• Describe the features of AWS
• The features of AWS marketplace
• Describe the features of Amazon Compute Services
• Describe the features of Amazon Storage Services
• Describe the features of Amazon Network Services
• Describe the features of Amazon Database services
• Describe about various services in AWS
• Global Infrastruture – Regions and Availability Zones
• Create a free tier account in AWS and onboarding
• Introduction AWS management console

• Protect your AWS by different authentication system
• Password policies set for users
• AWS User Account and Groups in detail
• Creating custom policies in AWS
• Introduction about Roles and its use
• Creating Roles and associating policies
• Creating programmatic access and management console access for users
• Associating policies to the user and groups

• Describe AMI and AWS Marketplace templates
• Launch a basic EC2 instance
• Different types of Instances Reserved, On-demand, Spot, Dedicated
• Security groups and tags for EC2 instance
• Public key – Private key introduction and protecting EC2 with keys
• Attaching and detaching EBS volumes
• Launch an ec2 instance from an AMI
• Create custom AMI and working with different region
• Make use of amazon EBS volume and create snapshots
• Manage the configuration of your application
• Deploying a new instance from the created AMI

• Get Started with Auto Scaling Using the Console
• Creating Launch configurations and make use of it for autoscaling groups
• Maintain a Fixed Number of Running EC2 Instances
• Dynamic Scaling
• The lifecycle of autoscaling
• Policies of autoscaling

• Introduction to Loadbalancer (ELB)
• Different types of Loadbalancer in AWS
• Application Load balancer
• Network Load balancer
• Classic Load balancer
• Migrating classic load balancer to new load balancer
• Components and types of load balancing

• Create EBS volumes
• Delete EBS Volumes
• Attach and detach EBS volumes with EC2 instance
• Creating and deleting snapshots

• Understanding S3 durability and redundancy
• Introduction about S3 Buckets
• How S3 Uploading works and how to Download
• How to S3 Permissions
• How to implement S3 Object Versioning S3 Lifecycle Policies
• Storage Gateway
• Import Export
• S3 Transfer Acceleration
• Glacier storage

• Describing cloud front
• Creating a cloud front distribution
• Hosting a website of cloud front distribution
• Implementing global restrictions
• Configuring origins and behaviors

• Describe Hosted zones and Domain name understanding
• How to create hosted zones
• Hosting a website with custom domain name
• Understanding routing policies

• Describing Security Practices for Cloud Deployment
• AWS Shared Responsibilities and Securities
• Importance of Cloud Trail
• Describing Trust advisor

• Introduction to Amazon Virtual Private Cloud (VPC).
• VPC Advantages and understanding IP addressing CIDR
• Default and Non-default VPC
• Different Components in VPC
• Describe, create, and manage Amazon Virtual Private Cloud
• Amazon VPC, Private Subnet, and Public Subnet
• AWS Networking, Security Groups, and Network ACLs
• Configuration and management of VPN connectivity
• Subnet and Subnet Mask

• Introduction to RDS
• Different database services of AWS: Amazon RDS, Dynamo DB, Redshift etc.
• Create MYSQL RDS Instance, Oracle RDS Instance, MS SQL RDS Instance
• Configuring the database
• Configuring backups
• Configuring the maintenance windows
• Connecting to the database

• Creating a dynamo dB
• Adding data manually
• Learn about strong and eventual consistency
• Calculating Read write consistency
• Configuring alarms

• Knowledge on Cloud watch – A monitoring service
• Create and Configuring Monitoring services
• How to perform Setting thresholds and Configuring actions
• Creating a cloud watch alarm
• Getting statistics for ec2 instances
• Monitoring other AWS services
• Configuring Notifications
• Integrating cloud watch with Autoscaling

• What is SNS
• Creating a topic
• Create subscription
• Subscribed to the subscription
• SQS & SES
• Lambda and Elastic Beanstalk

• Troubleshooting EC2 instance
• Troubleshooting using Cloud watch
• Troubleshooting using ELB
• Troubleshooting by using Cloud front

• Backup and Disaster Recovery
• How to manage Disaster Recovery and Backups
• Best Practice for DR and Backups
• AWS High Availability Design

• An understanding of DevOps and the modern DevOps toolsets
• The ability to automate all aspects of a modern code delivery and deployment pipeline using:
• Build tools – Apache ant, Maven
• Source code management tools – CVS, Git
• Test automation tools – JUnit
• Continuous Integration Tools – Jenkins, Team city
• Configuration management tools – Chef, Puppet, Ansible

Syllabus of JavaScript Training Course

• What is JavaScript?
• What is AJAX?

• The development workflow
• Selecting the right tools for the job
• Just enough HTML and CSS
• Understanding objects
• Understanding variables
• Making comparisons
• Understanding events

• Writing your first script
• Internal vs. external scripts
• Using comments in scripts
• Using the noscript tag in HTML

• Creating alert dialogs
• Understanding conditional statements
• Getting confirmations from users
• Creating prompts for users
• Understanding functions
• Making links smarter
• Using switch/case statements
• Handling errors

• Getting started
• Creating loops
• Passing values to functions
• Detecting objects
• Reading arrays
• Returning values from functions
• Writing arrays
• Building do and while loops
• Re-using functions

• Creating a basic image rollover
• How to write a better rollover
• Creating a three-state rollover
• Making rollovers accessible and 508 compliant
• Making disjointed rollovers
• Creating slideshows
• Displaying random images

• Getting started
• Creating jump menus
• Creating dynamic menus
• Requiring fields
• Cross-checking fields
• Displaying more informative errors
• Verifying radio button selections
• Setting one field with another field
• Verifying email addresses

• Responding to window events
• Responding to mouse movements
• Responding to mouse clicks
• Responding to onBlur form events
• Responding to onFocus form events
• Responding to keyboard events

• Demystifying cookies
• Writing a cookie
• Reading a cookie
• Displaying a cookie
• Counting with cookies
• Deleting cookies
• Handling multiple cookies
• Cookies in action

• Understanding the DOM
• Adding nodes to the DOM
• Deleting nodes from the DOM
• Deleting specific nodes
• Inserting nodes into the DOM
• Replacing nodes in the DOM

• Displaying dates
• Displaying times
• Creating a countdown

• Creating sliding menus
• Creating pop-up menus
• Creating slideshows with captions
• Creating a stylesheet switcher

Syllabus of Core JSP and Servlets Training Course

• 1. The World Wide Web
• 2. HTML Web Servers
• 3. HTTP
• 4. Dynamic Web Pages
• 5. CGI
• 6. Java Web Technologies
• 7. Servlets
• 8. JSP

• 1. JSP Containers
• 2. Servlet Architecture
• 3. Page Translation
• 4. Types of JSP
• 5. Content Directives
• 6. Content Type
• 7. Buffering
• 8. Scripting Elements
• 9. JSP Expressions
• 10. Standard Actions
• 11. Custom Actions and JSTL
• 12. Objects and Scopes
• 13. Implicit Objects
• 14. JSP Lifecycle

• 1. Translation of Template
• 2. Content Scriptlets
• 3. Expressions Declarations
• 4. Dos and Don'ts
• 5. Implicit Objects for Scriptlets
• 6. The request Object
• 7. The response Object
• . The out Object

• 1. HTML Forms
• 2. Reading CGI Parameters
• 3. JSPs and Java Classes
• 4. Error Handling
• 5. Session Management
• 6. The Session API
• 7. Cookies and JSP

• 1. Separating Presentation and Business Logic
• 2. JSP Actions
• 3. JavaBeans
• 4. Working with Properties and Using Form Parameters with Beans
• 5. Objects and Scopes
• 6. Working with Vectors

• 1. Going Scriptless
• 2. The JSP Expression Language EL
• 3. Syntax Type Coercion
• 4. Error Handling
• 5. Implicit Objects for EL
• 6. The JSP Standard Tag Library
• 7. Role of JSTL
• 8. The Core Actions
• 9. Using Beans with JSTL
• 10. The Formatting Actions
• 11. Scripts vs. EL/JSTL

• 1. Web Components
• 2. Forwarding
• 3. Inclusion
• 4. Passing Parameters
• 5. Custom Tag Libraries
• 6. Tag Library Architecture
• 7. Implementing in Java or JSP
• 8. Threads
• 9. Strategies for Thread Safety
• 10. XML and JSP
• 11. JSP for Web Service

• 1. The JSP Standard Tag Library
• 2. JSTL Namespaces
• 3. Going Scriptless
• 4. Object Instantiation
• 5. Sharing Objects
• 6. Decomposition
• 7. Parameterization

• 1. The JSTL Core Library
• 2. Gotchas
• 3. Conditional Processing
• 4. Iterative Processing
• 5. Iterating Over Maps
• 6. Tokenizing Strings
• 7. Catching Exceptions
• 8. Resource Access

• 1. The JSTL Formatting Library
• 2. Locales
• 3. Determining Locale Time Zones
• 4. Setting Locale and Time Zone
• 5. Formatting and Parsing Dates
• 6. Formatting and Parsing Numbers
• 7. Internationalization
• 8. Working with Resource Bundles
• 9. Supporting Multiple Languages

• 1. The JSTL SQL Library
• 2. Using Relational Data
• 3. Connecting with a DriverManager
• 4. Connecting via a DataSource
• 5. The Result Interface
• 6. Making a Query
• 7. Inserts, Updates and Deletes
• . Parameterized SQL Transactions

• 1. The JSTL XML Library
• 2. Using XML
• 3. XML Data Sources
• 4. Parsing and Addressing
• 5. Using XPath in JSTL
• 6. XPath vs. EL
• 7. XPath Context
• 8. Implicit Objects for XPath
• 9. Conditional Processing
• 10. Iterative Processing
• 11. Changing XPath Context
• 12. Working with XML Namespaces
• 13. Using XSLT Chaining Transformations
• 14. Reading XML from the Request Body
• 15. XML and SOAP Web Services

• 1. Architecture Servlets
• 2. Architecture Servlet and HttpServlet
• 3. Request and Response
• 4. Reading Request Parameters
• 5. Producing an HTML Response
• 6. Redirecting the Web Server
• 7. Deployment Descriptors
• 8. Servlets Life Cycle
• 9. Relationship to the Container

• 1. Building an HTML Interface
• 2. HTML Forms
• 3. Handling Form
• 4. Input Application Architecture
• 5. Single-Servlet Model
• 6. Multiple-Servlet Model
• 7. Routing Servlet Model
• . Template Parsers

• 1. Managing Client State Sessions
• 2. Session Implementations
• 3. HttpSession Session
• 4. Attributes
• 5. Session Events
• 6. Invalidating Sessions

• 1. JDBC
• 2. JDBC Drivers
• 3. Using JDBC in a Servlet
• 4. Data Access Objects
• 5. Threading Issues
• 6. Transactions
• 7. Connection Pooling

• 1. The Need for Configuration
• 2. Initialization Parameters
• 3. Properties
• 4. Files
• 5. JNDI and the Component Environment
• 6. JDBC Data Sources
• 7. Working with XML Data

• 1. Servlet Filters
• 2. Uses for Filters
• 3. Building a Filter
• 4. Filter Configuration and Context Filter Chains
• 5. Deploying Filters

Syllabus of Soap Training Course

• Installing SoapUI
• Setup of SoapUI
• Installation of SoapUI pro
• Setup of SoapUI pro
• Get to Know about webservices

• Web Service Architecture
• Web Services Concepts
• Types of web services
• SOAP
• WSDL
• UDDI
• What is Service-oriented Architecture?
• Why SOA?
• SOA Testing Methodology
• SOA test challenges

• Creating Workspace
• Adding projects to Workspace
• Creating Project/Importing Project
• Creating Requests for project operations
• Creating Test Suites
• Creating Test Cases
• Creating Test Steps
• Wsdl project

• Soap Usage
• Soap message structure
• Soap detailed explanation
• Soap encoding rules
• SOA examples
• WSDL usage
• WSDL doc structure
• WSDL examples
• Request , Response

• Soap message structure
• Soap detailed explanation
• Soap encoding rules
• SOA examples
• WSDL usage
• WSDL doc structure
• WSDL examples
• Request , Response

• DataSource
• DataSourceLoop
• DataSink
• Assertions

• Conditional Goto
• Assertions in SoapUI
• Assertion – Contains & Not contains
• Xpath match
• SOAP/Not-SOAP
• Contains/Not Contains
• SOAP fault/Not-SOAP fault
• Response SLA
• XPath match
• JDBC Timeout / JDBC Status

• Passing values between Test Steps
• Passing values between Operations
• Passing values between Services
• TestRequests
• Properties
• Property transfer
• Response to Request transfer
• Global to Test case