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 course complies with instructional designing principles for all the 6 lessons. This will ensure that you repeat and reinforce your gained knowledge at every step. Each and every minute spent during this 2-day course will incrementally take you to a next level.

Course Objectives

If you are interested in gaining a good grasp of Jenkins in a systematic and hands-on way by working through a real-world project, then this course is for you.

The course will provide enough knowledge of the following:

  • Illustrate continuous integration and continuous delivery concepts
  • Analyse how to install and setup Jenkins on Windows
  • Administer and secure Jenkins
  • Set up projects on Jenkins
  • Build continuous delivery pipelines with Jenkins
  • Identify how to setup distributed builds and scale Jenkins

Course Content

LESSON 1- Installing and Setting up Jenkins

  • Continuous Delivery
  • Installing Jenkins
  • The Jenkins Dashboard
  • User Management

LESSON 2 Administering Jenkins

  • Plugin Management
  • Updating & Upgrading Jenkins
  • Configuring Jenkins for Production
  • Creating a Form with a Select Element

LESSON 3- Jenkins Views and Setting up Freestyle Projects

  • Setting up a Freestyle Project
  • Setting up a View to Manage our Projects

LESSON 4- Parameterized Projects and Upstream/Downstream Projects

  • Configuring Parameters for our Projects
  • Creating & Accessing Build Parameters
  • Build Triggers

LESSON 5- Multibranch and Declarative Jenkins Pipelines

  • The CI Workflow
  • The Jenkinsfile
  • Creating Multi-Branch Pipelines

LESSON 6- Distributed Builds on Jenkins

  • Setting up Our Slaves
  • Securely Connecting To Our Slaves
  • Configuring Tasks To Run On Our Slaves

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

Course Overview

This is a 1-day course packed with the perfect balance of theory and hands-on activities that will help you get started with React.

React is widely used to create fast and reusable user interface components. It has been remarkably successful in recent years, since it is easy to use and offers a coherent design model.

React’s ease of use depends on an actual understanding of the core concepts of the library. By exploiting these concepts, you can build a high-quality design interface.

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.

Company Events

These events can be delivered exclusively for your company at our locations or yours, specifically for your delegates and your needs. The Company Events can be tailored or standard course deliveries.

Course Objectives

  • Create components and combine them together to build other components
  • Use JSX declaratives to describe how a component should look
  • Manage a component’s internal state
  • Manage interaction events
  • Exploit component lifecycle events
  • Manage navigation between high-level components
  • Design user interfaces by making the most of React’s features

Course Content

Lesson 1: Introducing React and UI Design

  • What is React?
  • How to Set Up a React-Based Application
  • How to Design a UI

Lesson 2: Creating Components

  • Definition of a Component
  • Using JSX
  • Composing Components
  • Data Propagation
  • Managing the Internal State

Lesson 3: Managing User Interactivity

  • Managing User Interaction
  • Component Lifecycle Events

Managing Routing

Course Overview

This fast-paced practical single-day course focuses on solving challenges presented by data science in a manner that is simple to conceptualize and easy to implement.

This is achieved by leveraging Python libraries that offer abstractions to complicated underlying algorithms. The result is that data science becomes very approachable for beginners, a fact which is reflected by the strength and growing popularity of the Python ecosystem. In this course, we will cover every aspect of the standard data workflow process, including collecting, cleaning, investigating, visualizing, and modeling data.

The Jupyter Notebook acts as an add-on tool – a virtual playground – that allows you to create and share live code, equations, visualizations, and text.

By touching on a variety of topics within the discipline, you’ll be exposed to many interesting examples with real-world data.

Company Events

These events can be delivered exclusively for your company at our locations or yours, specifically for your delegates and your needs. The Company Events can be tailored or standard course deliveries.

Pandas, Matplotlib, and scikit-learn will be useful.

Course Objectives

This course focuses on creating reproducible data analyses using Python and Jupyter, and is intended for an audience with a background in Python. As such, we do not cover the basics of Python in this course. However, we will take a brief tour of the Jupyter interface.

Course Content

Lesson 1: Jupyter Fundamentals

  • Basic Functionality and Features
  • Our First Analysis – The Boston Housing Dataset

Lesson 2: Data Cleaning and Advanced Machine Learning

  • Preparing to Train a Predictive Model
  • Training Classification Models

Lesson 3: Web Scraping and Interactive Visualizations

  • Scraping Web Page Data
  • Interactive Visualizations

Course Overview

Building robust web applications is the need of the hour in the web world. With ASP.NET Core MVC (that makes use of the Model-View-Controller architecture), a web developer can meet this.

In today’s age, it’s important for a developer to possess the ability to separate the programming and business logic. There are few courses available on ASP.NET Core 2 that helps in imparting this ability to a developer.

Course Objectives

As a tried and tested way to build cross-platform applications, this course will take you through the implementation of the core architecture of model, view, and controller.

Build your own shopping cart in an iterative fashion and gain all the skills to develop real-world applications with ASP.NET Core 2.

Course Content

Lesson 1: Setting the Stage

  • Introduction to Web Applications
  • Creating ASP.NET Core application

Lesson 2: Controllers

  • Role of the Controller in ASP.NET MVC Applications
  • Introduction to Routing
  • Our First Controller
  • Implementing our own IActionResult
  • Adding Views
  • Adding Models
  • Passing Data from the Controller to the View
  • Filters
  • Writing a Custom Filter

Lesson 3: Views

  • The View Engine and the Razor View Engine
  • Working with Layout
  • Generating HTML
  • Partial View
  • View Components
  • Tag Helpers

Lesson 4: Models

  • Introduction to Models
  • Model Binding
  • The Entity Framework
  • Using the Entity Framework in ASP.NET MVC applications
  • Database Migration

Lesson 5: Validation

  • Introduction to Validation
  • Client-Side and Server-Side Validation
  • Server-side Validation
  • Client-side Validation
  • Implementation

Lesson 6: Routing

  • Convention-Based Routing
  • Attribute-Based Routing
  • Route Attribute at the Controller Level
  • Passing Routing Values in HTTP Action Verbs in the Controller
  • Route Constraints

Lesson 7: Rest Buy

  • Designing Rest Buy
  • Creating the Entities for the Application
  • Creating EF Context and Migrations

Lesson 8: Adding Features, Testing, and Deployment

  • Adding the Registration Feature
  • Creating a Unit Test
  • Upgrading Our Application to Bootstrap 4
  • Deploying Rest Buy to Azure

Course Overview

This is a 2-day course packaged with the right balance of theory and hands-on activities that will help you easily learn TensorFlow and Keras from scratch.

This course will provide you with a blueprint of how to build an application that generates predictions using a deep learning model. From there you can continue to improve the example model—either by adding more data, computing more features, or changing its architecture—continuously increasing its prediction accuracy, or create a completely new model, changing the core components of the application as you see fit.

Course Objectives

  • A blueprint of the complete process for deploying a deep learning application: from environment setup to model deployment.
  • A hands-on introduction to TensorFlow and Keras, popular technologies for building production-grade deep learning models.
  • An example web-application that uses an HTTP API interface to retrieve model predictions.

Course Content

Lesson 1: Introduction to Neural Networks and Deep Learning

  • What are Neural Networks?
  • Configuring a Deep Learning Environment

Lesson 2: Model Architecture

  • Choosing the Right Model Architecture
  • Using Keras as a TensorFlow Interface

Lesson 3: Model Evaluation and Evaluation

  • Model Evaluation
  • Hyperparameter Optimization

Lesson 4: Productization

  • Handling New Data
  • Deploying a Model as a Web Application

Course Overview

This course offers a deep but gentle dive into Node.js. First, by starting off with the basic building blocks of the modern JavaScript language, which are necessary for students to have a good grasp of Node.js, before delving into the fundamentals of Node.js.

Most courses quickly dive into Node.js forgetting that, at the end of the day, Node.js is still JavaScript. This can end up being a little uncomfortable for JavaScript newbies, since we can’t build a solid house on a shaky foundation.

The course therefore begins with a quick introduction to the modern JavaScript language (ES6+). We will then look into Node’s asynchronous programming model and examine Node’s module system, including built-in modules and application modularization, as well as the NPM third-party module registry. We will skip a number of topics, which we will recommend for further reading, and will finish off by working on a simple web application API using the Hapi.js and Knex.js frameworks.

Course Objectives

This is a 1-day course packaged with the perfect balance of theory and hands-on activities that will help you learn Node.js from scratch.

This course complies with instructional designing principles for all the 3 lessons. This will ensure that you repeat and reinforce your gained knowledge at every step. Each and every minute spent during this 1-day course will incrementally take you to a next level.

Here are the important topics that this course will cover:

Quickly get to grips with Node.js and its module system

Gain an understanding of asynchronous programming in Node.js

Develop scalable and high-performing APIs using Hapi.js and Knex.js

Write unit tests for your API to ensure reliability and maintainability

Complete a variety of hands-on exercises and activities to broaden your understanding of the concepts covered in this courseware

Dive into the Capstone project by building an API for a legacy application

Course Content

Lesson 1: Introduction to Node.js

  • The Basics of Node.js
  • The Module System
  • Asynchronous Programming with Node.js

Lesson 2: Building the API: Part 1

  • Building a Basic HTTP Server
  • Setting up Hapi.js
  • Understanding Requests

Lesson 3: Building the API: Part 2

  • Working with the DB Using Knex.js
  • Authenticating Your API with JWT
  • Testing Your API with Lab