Course Overview

Processing big data in real-time is challenging due to scalability, information consistency, and fault tolerance. This course shows you how you can use Spark to make your overall analysis workflow faster and more efficient. You’ll learn all about the core concepts and tools within the Spark ecosystem, like Spark Streaming, the Spark Streaming API, machine learning extension, and structured streaming.

You’ll begin by learning data processing fundamentals using Resilient Distributed Datasets (RDDs), SQL, Datasets, and Dataframes APIs. After grasping these fundamentals, you’ll move on to using Spark Streaming APIs to consume data in real time from TCP sockets, and integrate Amazon Web Services (AWS) for stream consumption.

Course Objectives

By the end of this course, you’ll not only have understood how to use machine learning extensions and structured streams but you’ll also be able to apply Spark in your own upcoming big data projects.

After completing this course, you will be able to:

  • Write your own Python programs that can interact with Spark
  • Implement data stream consumption using Apache Spark
  • Recognize common operations in Spark to process known data streams
  • Integrate Spark streaming with Amazon Web Services
  • Create a collaborative filtering model with Python and the movielens dataset
  • Apply processed data streams to Spark machine learning APIs

Course Content

Lesson 1: Introduction to Spark Distributed Processing

  • Introduction to Spark and Resilient Distributed Datasetsll
  • Operations Supported by the RDD API
  • Self-Contained Python Spark Programs
  • Introduction to SQL, Datasets, and DataFrames

Lesson 2: Introduction to Spark Streaming

  • Streaming Architectures
  • Introduction to Discretized Streams
  • Windowing Operations
  • Introduction to Structured Streaming

Lesson 3: Spark Streaming Integration with AWS

  • Spark Integration with AWS Services
  • Integrating AWS Kinesis and Python
  • AWS S3 Basic Functionality

Lesson 4: Spark Streaming, ML, and Windowing Operations

  • Spark Integration with Machine Learning

Course Overview

This course complies with instructional design principles in all eight lessons. This will ensure that you repeat and reinforce your gained knowledge at every step. Each and every minute spent on this 3-day course will incrementally take you to the next level.

Course Objectives

If you are interested in gaining a good grasp of Vue.js in a systematic and hands-on way by working through a real-world project, then this course is for you.
 
The course will provide you with knowledge of the following:

  • Creating dynamic and animated lists
  • Identifying how to use computed properties
  • Animating with JavaScript instead of CSS
  • Packaging reusable transitions into components
  • Creating basic AJAX requests with Axios
  • Utilizing Jasmine for testing Vue and Karma workflow
  • Utilizing single-page applications and Webpack

Course Content

LESSON ONE- Getting Started With Vue.Js

  • A Simple Vue.js Program
  • Lists and their Types
  • Creating a Dynamic and Animated List
  • Reacting to Events Such as Clicks and Keystrokes
  • Choosing a Development Environment
  • Formatting Your Text with Filters

LESSON TWO- Basic Vue.Js Features

  • Learning How to Use Computed Properties
  • Filtering a List with a Computed Property
  • Sorting a List with a Computed Property
  • Formatting Currencies with Filters
  • Formatting Dates with Filters
  • Displaying and Hiding an Element Conditionally
  • Adding Styles Conditionally
  • Adding Some Fun to Your App with CSS Transitions
  • Outputting Raw HTML
  • Creating a Form with Checkboxes
  • Creating a Form with Radio Buttons
  • Creating a Form with a Select Element

LESSON THREE- Transitions And Animations

  • Integrating with Third-Party CSS Animation Libraries
  • Adding Your Own Transition Classes
  • Animating with JavaScript Instead of CS
  • Transitioning on the Initial Render
  • Transitioning Between Elements
  • Letting an Element Leave Before the Enter Phase in a Transition
  • Adding Entering and Leaving Transitions for Elements of a List
  • Transitioning Elements That Move in a List
  • Animating the State of Your Components
  • Dynamic Transitions

LESSON FOUR- All About Components

  • Creating and Registering a Component
  • Passing Data to Your Components with Props
  • Making Components Talk to Each Other
  • Making Components Talk with Vuex
  • Reading a Child’s State
  • Using Components in Your Own Components
  • Content Distribution with Slots
  • Single File Components with Webpack
  • Loading Your Components Asynchronously
  • Having Recursive Components

LESSON FIVE- Vue Communicates With The Internet

  • Sending Basic AJAX Requests with Axios
  • Validating User Data before Sending It
  • Recovering from an Error during a Request
  • Creating a REST Client (and Server!)
  • Implementing Infinite Scrolling
  • Processing a Request before Sending It Out
  • Preventing XSRF Attacks on Your App

LESSON SIX- Single-Page Applications

  • Creating an SPA with Vue-Router
  • Fetching Data before Switching Route
  • Managing Errors for Your Routes
  • Adding a Progress Bar to Load Pages
  • Using Named Dynamic Routes
  • Having More Than One Router-View in Your Page
  • Composing Your Routes Hierarchically
  • Adding Transitions between Your Routes
  • How to Redirect to Another Route
  • Saving Scrolling Position When Hitting Back

LESSON SEVEN- Unit Testing And End-To-End Testing

  • Using Jasmine for Testing Vue
  • Adding Karma to Your Workflow
  • Testing Your Application State and Methods
  • Testing DOM Asynchronous Updates
  • End-to-end testing with TestCafe
  • Stubbing External API Calls with Sinon.JS
  • Measuring the Coverage of Your Code

LESSON EIGHT- Organize + Automate + Deploy = Webpack

  • Extracting Logic from Your Components to Keep the Code Tidy
  • Organizing Your Dependencies with Webpack
  • Using External Components in Your Webpack Project
  • Developing with Continuous Feedback with Hot Reloading
  • Running a Code Linter While Developing
  • Releasing Your Components to the Public

Course Overview

The changing way in which we access the web means that there has never been a greater range of screen sizes and associated user experiences. With these trends driving changes in design, typical desktop-only websites fail to meet even minimum expectations when it comes to style and usability, which can be vital when your website is central to yours or your client’s brand.

A responsive web design provides a single solution that looks great on a phone, desktop, and everything in-between, providing the best experience possible for both today’s and tomorrow’s devices. This course covers every essential aspect of RWD and broader front-end development best practices.

With this course, we have created the definitive guide for all things responsive. We cover the entire gamut of HTML5 and CSS3’s new features that help to effortlessly create modern, responsive web designs.

Course Content

Lesson 1: The Essentials of Responsive Web Design

  • Defining Responsive Web Design
  • Our First Responsive Example

Lesson 2: Media Queries – Supporting Differing Viewports

  • Media Query Syntax
  • Combining Media Queries
  • Using Media Queries to Alter a Design
  • Media Queries Best Practices
  • The Viewport Meta Tag
  • Media Queries Level 4

Lesson 3: Fluid Layouts and Responsive Images

  • Converting a Fixed Pixel Design to a Fluid Proportional Layout
  • Flexbox
  • Responsive Images

Lesson 4: HTML5 for Responsive Web Designs

  • HTML5 Markup
  • Semantic HTML5
  • HTML5 Media Elements

Lesson 5: CSS3 – Selectors, Typography, and Color Modes

  • Introduction to CSS
  • Facilitating Feature Forks in CSS
  • New CSS3 Selectors and Their Use
  • CSS3 Structural Pseudo-classes
  • More About CSS
  • New CSS3 Color Formats and Alpha Transparency

Lesson 6: Stunning Aesthetics with CSS3

  • Shadows with CSS3
  • Gradients
  • Background Images
  • CSS Filters

Lesson 7: Transitions, Transformations, and Animations

  • CSS3 Transitions
  • CSS3 2D Transforms
  • CSS3 3D Transformations
  • Animating with CSS3

Lesson 8: Conquer Forms with HTML5 and CSS3

  • HTML5 Forms
  • The HTML5 Input Element
  • Styling HTML5 Forms with CSS3 

Lesson 9: Using SVGs for Resolution Independence

  • Introducing SVGs
  • Inserting SVGs
  • Extra SVG Capabilities and Oddities

Course Overview

PHP is a dynamic language which allows developers to create interactive server-side scripts. PHP is widely known and used by developers all over the world.

PHP has an easy learning curve and has a very user-friendly approach. It is used in almost all domains, including social media, medical, travel, and so on. Want to get up to speed with the latest PHP version? If your answer is yes, then you should take this course.

This course will get you up to speed starting with basic concepts such as variables, data types, arrays and loops. It then progresses to more advanced concepts such as building your own frameworks and creating your own app.

Course Objectives

This course focuses on the basic aspects of PHP right from variables, data types, arrays, and loops. It will also cover an explanation on frameworks, which will help you in writing your own custom framework. This course will also guide you in creating your own application.

Course Content

Lesson 1: Variables, Data Types, Operators and Conditionals

  • The Basics

Lesson 2: Array and Loops

  • Arrays
  • Loops

Lesson 3: Functions and Classes

  • Functions
  • Classes

Lesson 4: Data Operations

  • Inputting and Outputting Data
  • MySQL Basics

Lesson 5: Building a PHP Web Application

  • Concepts of OOP in a Framework Environment
  • Structure of a Framework

Lesson 6: Building a PHP Framework

  • Setting up a Project Development Environment
  • Configuration Class, Default Classes, and Routing
  • The Base Controller
  • Working with PDO

Lesson 7: Authentication and User Management

  • Setting Up Paths and Inclusion of BootstrapConfiguration Class, Default Classes, and Routing
  • Adding Security to the Project
  • Password Recovery
  • Building CRUD for User Management

Lesson 8: Building a Contacts Management System

  • CRUD, the Contact Application
  • Comments, Joins, and Date Formatting

Course Overview

JavaScript is one of the most widely used programming languages in the world. Born as a simple glue between the user and HTML, it has evolved over the years and has acquired an increasingly important role in modern software development. Today, its scope is no longer just the web browser. Now, it also resides on the server, desktop PCs, mobile devices, and even embedded devices.

JavaScript has now become a language to create complex applications. Beginning Object-Oriented Programming with JavaScript explains how we can write robust and efficient code with JavaScript to create scalable and maintainable applications.


The purpose of this course is to cover all the new object-oriented features introduced in ECMAScript 2015 and show how to build large-scale web apps that promote scalability, maintainability, and reusability. It is ideal for development teams that are thinking of using JavaScript for full-stack web development so that they only need to worry about one language across the entire stack.

Course Objectives

This course begins with a subtle refresher on objects. It teaches you how easy it is to define objects with the new ECMAScript classes. From there, we’ll fly you through some essential OOP principles, forming a base for you to get hands-on with encapsulation.


You’ll get to work with the different methods of inheritance. From there, we’ll move on to some advanced patterns for object creation, and you’ll get a strong idea of how to use interesting patterns to present data to users and to bind data. You’ll manage dynamic typing using various data types and get familiar with duck typing and polymorphism.


You’ll explore various presentations such as MVC and MVP, along with implementing data binding.


By the end of this course, you’ll discover whether JavaScript is asynchronous and learn to write asynchronous code using callbacks and events.

Course Content

Lesson 1: Diving into Objects and OOP Principles

  • Creating and Managing Object Literals .
  • Defining Object Constructors
  • Using Object Prototypes
  • Using Classes
  • Beginning with Object-Oriented JavaScript
  • Checking Abstraction and Modeling Support
  • Analyzing OOP Principles Support in JavaScript

Lesson 2: Working with Encapsulation and Information Hiding

  • Setting up Strategies for Encapsulation and Information Hiding
  • Using the Meta-Closure Approach
  • Using Property Descriptors
  • Implementing Information Hiding in ES6 Classes

Lesson 3: Inheriting and Creating Mixins

  • Implementing Objects, Inheritance, and Prototypes
  • Using Class Inheritance
  • Controlling Inheritance
  • Implementing Multiple Inheritance
  • Creating and Using Mixins

Lesson 4: Defining Contracts with Duck Typing

  • Managing Dynamic Typing
  • Defining Contracts and Interfaces
  • Implementing Duck Typing
  • Comparing Duck Typing and Polymorphism

Lesson 5: Advanced Object Creation

  • Mastering Design Patterns, Object Creation, and Singletons
  • Implementing an Object Factory
  • Exploiting the Builder Pattern

Lesson 6: Working with Data

  • Managing User Interfaces
  • Implementing Presentation Patterns
  • What is Data Binding?
  • Implementing Data Binding
  • Applying the Publish/Subscribe Pattern

Lesson 7: Asynchronous Programming and Promises

  • Is JavaScript Asynchronous?
  • Writing Asynchronous Code
  • Introducing Promises

 Lesson 8: Organizing Code

  • Taking Control of the Global Scope
  • Creating Namespaces
  • Organizing Code with the Module Pattern
  • Loading the Module
  • Using the ECMAScript 2015 Modules

Course Overview

This fast-paced practical course focuses on application development while discussing the JavaScript libraries that help to build them. We look at the libraries in JavaScript that help to build applications that have a microservices-based architecture, have features like audio and video calling, real-time score updates, multi-faceted search options, and so on. We not only look at building these applications but also explore a number of best practices to be followed.

Take home the skills to build web applications for changing times

Course Content

Microservices Architecture

  • Topic A: Introduction to Microservices Architecture

Introduction to Seneca

  • Topic A: Using Seneca
  • Topic B: Creating Your First Seneca Application

Communication

  • Topic A: WebRTC
  • Topic B: WebRTC Applications Using PeerJS
  • Topic C: Introduction to Socket.IO

Functional Reactive Programming

  • Topic A: Introduction to Reactive Programming
  • Topic B: Functional Programming in a Nutshell

Using the FRP Library – Bacon.js

  • Topic A: Errors and Exception Handling in Bacon.js
  • Topic B: Bacon APIs

Using the Features of Bootstrap 4

  • Topic A: Introduction to Bootstrap 4
  • Topic B: Understanding the rem and em CSS Units
  • Topic C: The Card Component

React and Flux

  • Topic A: Understanding React
  • Topic B: Getting Started with JSX
  • Topic C: Flux and Flux.js
  • Topic D: Introduction to React Router

Course Overview

The course will initially begin with familiarizing you to the different .NET
technologies and Visual Studio 2017. Beginning from the basic concepts of declaring and working with variables, we move on to writing code that makes decisions, repeats a block of statements, converts between types, and handles errors.

You will also learn about .NET Core and its class library assemblies, and packages of types that are defined in .NET Standard that allow your applications to connect existing components together to perform common practical tasks. You will then learn to make your own types using object-oriented programming (OOP) and learn how to read and write to databases.

You will then see what can be achieved with Extensible Application Markup Language (XAML) when defining the user interface for a graphical app, in particular, for Universal Windows Platform (UWP). Finally, we look at building web applications with a modern HTTP architecture on the server side using Microsoft ASP.NET Core MVC

Course Objectives

The release of .NET Core means that cross-platform development with C# is finally here. In this fast-paced practical course you’ll work through a rapid introduction to C# followed up by an overview of .NET in the context of two real-world applications.

Each component of the course has been carefully designed to build skills and capabilities that are in high commercial demand. You’ll learn how to build and deploy Universal Windows Platform applications for desktop environments, as well as cutting-edge web development techniques with ASP.NET Core MVC. As you progress you’ll find helpful tips and tricks, as well as useful self-assessment material, exercises and activities to help benchmark your progress and reinforce what you’ve learned.

If you’re a pragmatic developer with a few years of experience working with another object-oriented programming language, this course will equip you with the skills you need to succeed with C# and .NET in the modern workplace.

Course Content

Lesson 1: An Overview of Visual Studio 2017

  • Understanding .NET
  • Fundamentals of Visual Studio 2017

Lesson 2: Introducing C#

  • Exploring the Basics of C#
  • Declaring Variables
  • Building Console Applications

Lesson 3: Controlling the Flow, Converting Types, and Handling Exceptions

  • Understanding Selection Statements
  • Understanding Iteration Statements
  • Casting and Converting Between Types
  • Handling Exceptions
  • Checking for Overflow

Lesson 4: Using .NET Standard Types

  • Using Assemblies and Namespaces
  • Debugging and monitoring
  • Storing Data with Collections
  • Debugging Tools
  • Monitoring Performance and Resource Usage

Lesson 5: .NET Deep Dive

  • Understanding OOP
  • Building Class Libraries
  • Implementing Interfaces and Inheriting Classes

Lesson 6: Databases

  • Relational Database Management Systems
  • Working with Entity Framework Core
  • Understanding Universal Windows Platform

Lesson 7: Building Universal Windows Platform Apps Using XAML

  • Understanding Universal Windows Platform
  • Understanding XAML
  • Creating an Application for UWP
  • Using Resources and Templates
  • Data Binding
  • Animating with Storyboards
  • Testing in Emulators

Lesson 8: Building Web Applications Using ASP.NET Core MVC

  • Understanding ASP.NET Core
  • Exploring an ASP.NET Core MVC Web Application
  • ASP.NET Core MVC Controllers
  • ASP.NET Core MVC Models
  • ASP.NET Core MVC Views
  • Taking ASP.NET Core MVC Further

Course Overview

jQuery is a cross-browser JavaScript library used to create dynamic web pages. It was written to make DOM manipulation (moving things around a web page) easier for developers. It uses JavaScript to assign HTML elements these attributes. Because it is a library of predefined functions, all you need to start using jQuery is a working knowledge of the syntax and a reference for the functions available to you.

jQuery has numerous advantages over other JavaScript libraries; some of them being that it is easy to start with, is cross browser-friendly, uses shorter code, has a considerable number of available plugins, and most of all, is easy to use with Ajax.

This means there is a considerable market of developers wanting to get into the world of jQuery.

Course Objectives

This course will show how you can integrate jQuery 3.0 into your web pages, avoid complex JavaScript code, create brilliant animation effects for your web applications, and create a flawless app.

Begin with configuring and customizing the jQuery environment and get hands-on with DOM manipulation. Learn to integrate jQuery with your favorite backend framework. Learn how the ECMAScript 6 features affect web development with jQuery. Discover how to use the newly introduced JavaScript promises and the new animation API in jQuery 3.0, along with sample code and examples.

By the end of the course, you will be able to successfully create a fully-featured and efficient single-page web application and leverage all the new features of jQuery 3.0 effectively.

Course Content

Lesson 1: Beginning with jQuery 3

  • Making our First jQuery-Powered Web Page
  • Using jQuery with Developer Tools

Lesson 2: Selecting Elements

  • Understanding the DOM
  • Exploring CSS Selectors
  • DOM Traversal Methods
  • Lesson 3: Handling Events
  • Performing Tasks on Page Load
  • Handling Simple Events
  • Event Propagation
  • Altering the Journey – The Event Object

Lesson 4: Styling and Animating

  • Modifying CSS with Inline Properties
  • Built-in Animation Effects
  • Creating Custom Animations
  • Simultaneous Versus Queued Effects

Lesson 5: Manipulating the DOM

  • Manipulating Attributes and Properties
  • DOM Tree Manipulation 

Lesson 6: Working with Ajax

  • Loading Data on Demand
  • Passing Data to the Server
  • Deferreds and Promises

Lesson 7:  jQuery Plugins

  • Using a Plugin
  • jQuery UI
  • jQuery Mobile

Lesson 8: Advanced Selectors, Traversing, and DOM Manipulation

  • Selecting and Traversing Revisited
  • Writing a Custom Selector Plugin
  • Using HTML5 Data Attributes
  • Revisiting Attribute Manipulation

Lesson 9: Advanced Events and Effects

  • Event Delegation
  • Defining Custom Events
  • Interrupting Animations
  • Multi-property Easing and Deferred Objects

Lesson 10: Advanced Ajax

  • Fetching Data with CORS
  • Using the jqXHR Object
  • Extending Ajax Capabilities

Course Overview

This is a two-day course packed with the theory and hands-on activities that will help cement the foundation of algorithms and data structures.

Algorithms and data structures are the lifeblood of programming. They enable the programmers to write the code that handles the data efficiently.

Course Objectives

This course begins with the introduction of basic concepts of algorithms and data structures and progresses to implement them using Java. Here is the list of course objectives:

  • Learn about space and time complexities express them using big O notation
  • Explore various classic sorting algorithms, such as merge and quick sort
  • Understand the workings of basic (Lists, queues and stacks) and complex data structures (hash tables and binary trees)
  • Gain an insight into various algorithm design paradigms (Greedy, Divide and Conquer and Dynamic programming)
  • Discover string matching techniques
  • Master graph representations and learn about different graph algorithms, such as cycle detection, traversal and shortest path

Course Content

Lesson 1: Algorithms and Complexities

  • Developing our first alThis is a two-This is a two-day course packed with the theory and hands-on activities that will help cement the foundation of algorithms and data structures.
  • Algorithms and data structures are the lifeblood of programming. They enable the programmers to write the code that handles the data efficiently.day course packed with the theory and hands-on activities that will help cement the foundation of algorithms and data structures.
  • Algorithms and data structures are the lifeblood of programming. They enable the programmers to write the code that handles the data efficiently.gorithm
  • Measuring algorithmic complexity with Big O notation
  • Identifying algorithms with different complexities

Lesson 2: Sorting Algorithms and Fundamental Data Structures

  • Introducing bubble sort
  • Understanding quick sort
  • Using merge sort
  • Getting started with fundamental data structures

Lesson 3: Hash Tables and Binary Search Trees

  • Introducing hash tables
  • Getting started with binary search trees

Lesson 4: Algorithm Design Paradigms

  • Introducing greedy algorithms
  • Getting started with divide and conquer algorithms
  • Understanding dynamic programming

Lesson 5: String Matching Algorithms

  • Beginning naive search algorithm
  • Getting started with the Boyer-Moore string searching algorithm
  • Introducing other string matching algorithms

Lesson 6: Graphs, Prime Numbers, and Complexity Classes

  • Representing graphs
  • Traversing a graph
  • Calculating shortest paths
  • Prime numbers in algorithms
  • Other concepts in graphs
  • Understanding complexity classes of problems

Course Overview

This fast-paced course is designed specially for learning all the aspects of GraphQL right from understanding the basics and features to integrating GraphQL with server-side applications.

GraphQL is a query language developed by Facebook and is a REST-like tool, performing the same functions as REST, only differently. GraphQL brings several advantages to the table, including allowing clients to request only what they want, a single endpoint, and, faster request-response cycle.

GraphQL will allow you to define your data requirements and structure, using types and schemas. They also define how to interact with the data by creating, updating, deleting, and fetching it using queries and mutations. You will also have the additional advantage of getting the data in real-time by using subscriptions provided by Apollo GraphQL.

Course Objectives

This course will enable you to learn all the basics of GraphQL wherein you will identify the features of GraphQL, you will implement the querying of data in real-time.

You will also learn how to connect GraphQL with server-side applications using Apollo client

Course Content

Lesson 1: Understanding GraphQL Concepts

  • GraphQL Features
  • Setting Up a Simple GraphQL Application

Lesson 2: Querying Real-Time Data

  • Real-Time Query Processing
  • Other Community Tools 

Lesson 3: Integrating GraphQL Using Apollo Client

  • Setting up a React Client application