Course Overview

This course is geared for developers who have little or no prior working knowledge of object-oriented (OO) programming languages (such as C, COBOL, 4GL, and so forth). Throughout the course, you will learn the best practices for writing great OO programs in Java 8, using sound development techniques, improved features for better performance, and new capabilities for addressing rapid application development. Special emphasis is placed on OO concepts and best practices.

Course Objectives

• OO programming and its advantages in today’s world
• Objects, classes, and OO implementations
• Basic concepts of OO such as encapsulation, inheritance, polymorphism, and abstraction
• Fundamentals of the Java language, its importance, uses, strengths, and weaknesses
• How Java language relates to OO programming and the object model
• Use classes, inheritance and polymorphism
• Use collections, generics, autoboxing, and enumerations
• Use Lambda expressions
• Use the stream application programming interface (API)
• Discover the new date/time API
• Use the Java Database Connectivity (JDBC) API for database access
• Work with annotations
• Java tooling

Specific Java 8 features that are covered in the course include:

• The new date/time API
• Lambda expressionsMethod and constructor references
• The stream API
• Collectors
• The optional class

Course Content

• 1. Java 8: A First Look
• The Java Platform
• Java Platforms
• Lifecycle of a Java Program
• Responsibilities of JVM
• Documentation and Code Reuse
• Using the JDK
• Setting up Environment
• Locating Class Files
• Compiling Package Classes
• Source and Class Files
• Java Applications
• The Eclipse Paradigm
• Workbench and Workspace
• Views
• Editors
• Perspectives
• Projects
• 2. OO Concepts
• Object-Oriented Programming
• Real-World Objects
• Classes and Objects
• Object Behavior
• Methods and Messages
• Inheritance, Abstraction, and Polymorphism
• Encapsulation
• Inheritance
• Method Overriding
• Polymorphism
• 3. Getting Started with Java
• Writing a Simple Class
• Classes in Java
• Class Modifiers and Types
• Class Instance Variables
• Primitives vs. Object References
• Creating Objects
• Adding Methods to the Class
• Passing Parameters into Methods
• Returning a Value from a Method
• Overloaded Methods
• Constructors
• Optimizing Constructor Usage
• Language Statements
• Operators
• Comparison and Logical Operators
• Looping
• Continue and Break Statements
• The Switch Statement
• The For-Each() Loop
• For-Each Loop Restrictions
• Using Strings
• Strings
• String Methods
• String Equality
• StringBuffer
• StringBuilder
• Java 8: String Joiner
• Specializing in a Subclass
• Extending a Class
• Casting
• The Object Class
• Default Constructor
• Implicit Constructor Chaining
• 4. Essential Java Programming
• Fields and Variables
• Instance vs. Local Variables: Usage Differences
• Data Types
• Default Values
• Block Scoping Rules
• Final and Static Fields
• Static Methods
• Using Arrays
• Arrays
• Accessing the Array
• Multidimensional Arrays
• Copying Arrays
• Variable Arguments
• Java Packages and Visibility
• Class Location of Packages
• The Package Keyword
• Importing Classes
• Executing Programs
• Java Naming Conventions
• 5. Advanced Java Programming
• Inheritance and Polymorphism
• Polymorphism: The Subclasses
• Upcasting vs. Downcasting
• Calling Superclass Methods from Subclass
• The Final Keyword
• Interfaces and Abstract Classes
• Separating Capability from Implementation
• Abstract Classes
• Implementing an Interface
• Abstract Classes vs. Interfaces
• Exceptions
• Exception Architecture
• Handling Multiple Exceptions
• Automatic Closure of Resources
• Creating Your Own Exceptions
• Throwing Exceptions
• Checked vs. Unchecked Exceptions
• 6. Java Developer’s Toolbox
• Utility Classes
• Wrapper Classes
• The Number Class
• Random Numbers
• Autoboxing/Unboxing
• The Date Class
• Enumerations and static imports
• Enumeration Syntax
• When You Should Use Enumerations
• Using Static Imports
• When You Should Use Static Imports
• Java 8 – The Date/Time API
• The Core Date/Time classes
• Formatting Dates
• Working with Time Zones
• Manipulate Date/Time Values
• 7. Collections and Generics
• Generics
• Generics and Subtyping
• Bounded Wildcards
• Generic Methods
• Legacy Calls to Generics
• When Generics Should Be Used
• Collections
• Characterizing Collections
• Collection Interface Hierarchy
• Iterators
• The Set Interface
• The List Interface
• Queue Interface
• Map Interfaces
• Using the Right Collection
• Collections and Multithreading
• 8. Lambda and Streams
• Java 8: Introduction to Lambda
• Functional vs OO Programming
• Anonymous Inner-classes
• Lambda Expression Syntax
• Functional Interfaces
• Method references
• Constructor references
• Java 8: Streams
• Processing Collections of data
• The Stream interface
• Reduction and Parallelism
• Filtering collection data
• Sorting Collection data
• Map collection data
• Find elements in Stream
• Numeric Streams
• Create infinite Streams
• Sources for using Streams
• Java 8: Collectors
• Creating Collections from a Stream
• Group elements in the Stream
• Multi-level grouping of elements
• Partitioning Streams
• 9. Java Application Development
• Introduction to Annotations
• Annotations Overview
• Working with Java Annotations
• JDBC
• Connecting to the Database
• Statement and PreparedStatement
• ResultSet
• Executing Inserts, Updates, and Deletes
• Controlling Transactions and Concurrency

Course Overview

Build distributed applications that resolve data ownership issues when working with transactions between multiple parties. Blockchain applications provide a single-shared ledger to eliminate trust issues involving multiple stakeholders. With the help of Introduction to Blockchain and Ethereum, you’ll learn how to create distributed blockchain applications which do not depend on a central server or datacenter.

Course Objectives

The course begins by explaining Bitcoin, Altcoins, and Ethereum, followed by taking you through distributed programming using the Solidity language on the Ethereum blockchain. By the end of this course, you’ll be able to write, compile, and deploy your own smart contracts to the Ethereum blockchain

Course Content

Lesson 1: Ethereum Blockchain

• Introducing the Ethereum Blockchain
• Cryptology and Keys
• Opening an Ethereum Account
• The Ethereum Network, Nodes, and Mining
• Transactions and Blocks
• Sending and Checking Transactions

Lesson 2: Learning Solidity 

• The Solidity Language
• Your First Smart Contract
• Basic Solidity
• Testing Solidity 

Lesson 3: Solidity Contracts

• Your First dApp
• Using an Oracle

Course Overview

This is a 2-day course packed with the right balance of theory and hands-on activities to help you take your TypeScript skills to the next level.

This course complies with instructional designing principles for all the 4 lessons. This will ensure that you frequently repeat and reinforce the knowledge you gain. Having been designed for the development of large applications, TypeScript is being widely incorporated into popular projects such as Angular.

TypeScript is the future of JavaScript. TypeScript offers a sliding scale of how much or how little effort you want to put into your declarations: the more effort you put in, the more type safety and code intelligence you get. TypeScript allows developers to write readable and maintainable web applications. Adopting TypeScript results in more robust software, while still being deployable in apps where regular JavaScript is running.

Pure JavaScript lacks certain language features that are taken for granted in languages such as C# and Java. For example, it has no built-in module system, meaning that there’s no standard way of producing self-contained blocks of code that present well-defined interfaces to developers.

Course Objectives

In this course, we will begin by learning the fundamentals of TypeScript and eventually move toward advanced concepts. Learn how TypeScript relates to JavaScript that you may have written before. We will understand the benefits of TypeScript and how it can help you avoid software defects. We will learn to use type guards, check null and undefined, create tagged union types, and compare the performance of algorithms.

We will use TypeScript to build a weather forecast widget with Angular. We will then progress by building a note-taking client/server application using Angular, Node.js, and MongoDB. Finally, we will create a real-time chat application with React.

By completing this course, you will be able to build interesting TypeScript projects. This course will take your current TypeScript knowledge to the next level.

Here are the important topics that this course will cover:

• Learn the fundamentals of TypeScript
• Build a weather forecast widget with Angular
• Create building a note-taking client/server application using Angular, Node.js, and MongoDB
• Create a real-time chat application with React

Course Content

Lesson 1: TypeScript Fundamentals

• Introduction to TypeScript
• Type Checking
• Advanced Type Analysis Features
• Comparing Performance of Algorithms

Lesson 2: Building a Weather Forecast Widget with Angular 4

• Using Modules
• Creating the First Component
• Using the Component in Other Components
• Using the Main Component

Lesson 3: Note-Taking Client/Server App

• Setting up the Server
• Integrating with MongoDB
• Creating the Client Side with Angular

Lesson 4: Real-Time Chat

• Setting up the Project
• Writing the Server
• Creating the Chat Room

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

Swift greatly simplifies the process of developing applications for Apple devices. This course provides you with the essential skills to help you get started with developing applications using Swift.

After completing this course, you will be able to:

– Explore the fundamental Swift programming concepts, language structure, and the Swift programming syntax

– Transform your thinking to leverage new concepts, such as optionals and protocols

– Use key language elements, such as strings and collections in Swift

– Grasp how Swift supports modern application development using advanced features, such as built-in Unicode support and higher-order functions.

Course Objectives

This course is aimed at developers seeking fundamental Swift programming skills in preparation for learning how to develop native applications for iOS and macOS.

Course Content

Lesson 1: Swift Basics

• Swift Program Structure
• Swift Variables and Constants
• Swift Data Types
• Enums

Lesson 2: Swift Operators and Control Flow

• Swift Operators
• Branching
• Loops

Lesson 3: Functions, Classes, and Structs

• Functions
• Error Handling
• Object-Oriented Features

Lesson 4: Collections

• Arrays
• Sets
• Dictionaries

Lesson 5: Strings

• String Fundamentals
• Using Strings
• Substring

Lesson 6: Functional Programming and Lazy Operations

• Functional Methods
• Lazy Operations
• Swifty Code

Course Overview

Web applications built with Angular can be optimized for search engines (SEO). Building support for SEO in apps means that search engines can read and understand the pages, and that the pages have dynamic data that is specifically aimed at search engines (meta tags). This increases the visibility of your app giving higher search rankings and more links, resulting in more revenues for you or your client. Angular provides built-in features that can be leveraged to ensure apps enjoy maximum visibility on the web. Angular also provides features to ensure that our apps keep working without an internet connection or on a slow connection as well.

Course Objectives

In this course, we will learn how to use Angular to create a progressive web app (PWA) that has great support for SEO. We will begin by identifying what makes an app SEO friendly and installing Angular CLI. We will then build out the UI and application components. By the end of the first lesson, we will have an app ready that is built using Angular’s best practices. In the next lesson, we will implement server-side rendering. We will create a server with Express.js and add dynamic metadata to our app. In the final lesson, we will enable and configure service workers for our app, which will enable our app to work offline.

With this course, you’ll be equipped to create modern, SEO-friendly web apps with best practices using Angular CLI. This course focuses on creating a progressive web app using Angular that is optimized for search engines. As such, we will not focus on understanding Angular basics.

Course Content

Lesson 1: Creating the Base Application

•  Installing Angular CLI
• Generating a New Application
• Setting Defaults for Angular CLI
• Configuring Global Styles
• Creating UI Modules and Components
• Creating the Application Module and Components

Lesson 2: Server-Side Rendering

• Generating the Server App
• Adding Dependencies for the Server App
• Adding Run Scripts to package.json
• Implementing a Web Server
• Adding Dynamic Metadata

Lesson 3: Service Workers

• Installing Dependencies
• Enabling the Service Worker
• Configuring the Service Worker
• Testing the Service Worker
• Debugging the Service Worker

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 Objectives

We’ll focus heavily on applying the latest techniques provided by HTML5 and CSS3, all in the context of real-world examples. Along the way, you’ll discover tips and tricks that make your future designs and development workflow leaner and more maintainable than ever before.

By the time you reach the end, you’ll be equipped with the latest cutting edge front-end development skills, ready to develop your very own modern, responsive websites that are pixel-perfect across a wide range of devices.

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 Prerequisites

Hardware:

This course will require a computer system for the instructor and one for each student. The minimum hardware requirements are as follows:

• Processor: i3
• Memory: 2 GB RAM
• Hard disk: 10 GB
• Internet connection

Software:

For this course, we will use the following software:

• Windows 8 (64-bit)
• Atom
• Node.js
• Bootstrap 4
• React
• The latest version of Google Chrome