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

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 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

Course Overview

This is a fast-paced, practical course aimed at experienced developers and system architects. As you progress, you’ll find helpful tips and tricks, as well as useful self-assessment material, exercises, and activities to help you benchmark your progress and reinforce what you’ve learned. The activities have been devised to simulate real-world conditions in order to equip you with the necessary skills to accelerate software deployment while still maintaining security, portability, and affordability.

Course Objectives

If you are interested in gaining a good grasp of ggplot2 in a systematic and practical way by working through real-world scenarios, then this course is for you.

This course will provide you with knowledge of the following:

  • Illustrating continuous integration and continuous delivery concepts
  • Setting up the R environment, R Studio, and explaining the structure of ggplot2
  • Distinguishing between types of variables and best practices for visualizing them
  • Changing the defaults of visualizations to reveal more information about the data
  • Implementing the “Grammar of Graphics” in ggplot2, such as scales, coordinate systems, position adjustments, and faceting
  • Creating complex visualizations and investigating the correlations between variables
  • Designing and implementing a visualization from scratch

Course Content

LESSON 1- BASIC PLOTTING IN GGPLOT2

  • Introduction to ggplot2
  • Geometric Objects
  • The Grammar of Graphics

LESSON 2- THE GRAMMAR OF GRAPHICS AND VISUAL COMPONENTS

  • More on the Grammar of Graphics
  • Facets
  • Changing Styles and Colors
  • Geoms and Statistical Summaries

LESSON 3- ADVANCED GEOMS AND STATISTICS

  • Advanced Plotting Techniques
  • Time Series
  • Maps
  • Trends, Correlations, and Statistical Summaries

Course Overview

DevOps seems to be the latest ‘buzzword’ and trend in the IT industry. Driven by the business need for ever faster deployment of new functionality and frustration with the time and effort it takes to get new systems into Operations. It is no longer a question of ‘should we adopt DevOps’ ,but ‘when and how’. However DevOps represents a significant cultural and behavioral change and many organizations fail to address this in their adoption. This game can be used to help explore and understand DevOps, and to identify and agree concrete actions for adopting and deploying DevOps practices. The simulation game is based upon ‘The Phoenix Project’ Book.

  • Duration of the simulation 1 day
  • Number of participants 8 – 12

Course Objectives

  • How to apply DevOps principles in a real life situation?
  • How to find the right balance between delivering your SLA requirements and your IT projects according to plan?
  • How to experience how DevOps can bring serious value to your business?
  • How to increase the efficiency and effectiveness of your IT Department?
  • How to create better flow in your teams?
  • How to develop people’s skills to act in a DevOps environment?
  • How to show business their responsibilities in making IT Projects more successful?

Course Content

Do you recognise this?

In order to keep the competition ahead, business is increasingly demanding shorter release cycles for new applications. Operations are often seen as a barrier with long bureaucratic controls and delays in supplying production systems. They benefit from stability. The development department is open to change and wants to deliver new functionality quickly and often.

DevOps is a growing approach to shorten lead-time, increase quality and improve collaboration. However, this requires both a change of mind-set and culture as well as learning new behaviours in Development (Dev) and Operations (Ops). Many companies struggle with the implementation of DevOps and changing the culture.

The DevOps simulation game is based on the book ‘The Phoenix Project’. The organisation Unlimited Units is in trouble. Newspaper articles reveal the bad financial situation of the organisation. The only way to save not only the company but also to make it competitive and profitable is to start the project “The Phoenix Project”.

“The Phoenix Project” is an IT-enabled business transformation with Retail Operations as project owner. Scenario – The IT Manager of Operations is asked to take charge of the IT department and to ensure that “The Phoenix Project” will be a success. However, the IT Manager Operations faces a huge amount of work. Huge delays in issues, functions and projects.

Your team will assume different roles within the organisation Parts Unlimited. You act as Retail Operations, Human Resources and Finance – the roles of the management of the company and you act as IT Manager or one of the other IT team members who need to solve IT problems and the To develop applications.

Your challenge is to apply the principles of DevOps in this Business Simulation. In a number of rounds, you will work on IT projects and issues and ensure that “The Phoenix Project” is completed on time. But beware, the company continues to come up with new ideas and requirements, and developments from outside can also throw fun into the mix!

  • 09:30 Getting acquainted and introduction to the Game
  • 10:00 Start of first round
  • 11:15 End of first round and short break
  • 11:30 Reflection and retrospective
  • 11:45 Start round two
  • 13:00 End of round two and lunch
  • 13:45 Reflection and retrospective
  • 14:00 Start of round three
  • 15:15 End round three and short break
  • 15.30 Reflection and retrospective
  • 16.15 Closing

\