Course Overview

In this course you will learn how to create a new Citrix DaaS deployment and how to migrate to Citrix DaaS from an on-premises Citrix Virtual Apps and Desktops Site. Get hands-on as the course guides you through the architecture, communications, management, installation, and configuration of Citrix DaaS on Citrix Cloud and resource locations that the host apps and desktops for your users. This course is a necessary step in enabling you with the right training and skills, to not only understand, manage, and deliver successfully, but also to make well-informed planning decisions along the way.

Product Versions Covered:

– Citrix DaaS

– Citrix Virtual Apps and Desktops 7 2402 LTSR

Virtual Learning

This interactive training can be taken from any location, your office or home and is delivered by a trainer. This training does not have any delegates in the class with the instructor, since all delegates are virtually connected. Virtual delegates do not travel to this course, Global Knowledge will send you all the information needed before the start of the course and you can test the logins.

Course Objectives

After completing this course you should be able to:

• Understand the differences between Citrix Virtual Apps and Desktops 2402 LTSR on-premises and the Citrix DaaS.
• Install, configure, and manage Citrix Cloud Connectors.
• Create Citrix DaaS workloads.
• Deliver app and desktop resources to users.
• Migrate existing on-premises Citrix Virtual Apps and Desktops 2402 LTSR infrastructure to Citrix Cloud.

Course Content

Module 1: Introduction to Citrix DaaS

• New Citrix Workspace Packaging
• Citrix Virtual Apps and Desktops – OnPremises Site
• What is Citrix Cloud?
• Why Citrix DaaS?
• What is a Migration from Citrix Virtual Apps and Desktops to Citrix DaaS?
• Citrix Cloud Administration

Module 2: Citrix DaaS Architecture, Security, and Operations

• Architecture and Deployment Options
• Citrix DaaS Security
• Citrix DaaS Operations

Module 3: Citrix Cloud Connectors

• Cloud Connector Architecture
• Cloud Connector Services and Communications Overview
• Cloud Connector Operations in a Resource Location
• Cloud Connector Resiliency
• Installing, Updating, and Removing Cloud Connectors
• Supported Domain Scenarios for Cloud Connectors
• Securing Cloud Connector Communications
• Local Host Cache (LHC)
• Citrix Cloud Connector vs Delivery Controller Operations

Module 4: Citrix DaaS Resource Locations

• Citrix DaaS Resource Locations
• Citrix DaaS Hosting Connections
• Zones

Module 5: Active Directory, Authentication, and Authorization

• Active Directory Design Options
• Desktops from Non-Domain Joined VDAs
• Citrix Federated Authentication Service and Identity Provider Services

Module 6: Provisioning VDA Workloads and Delivering Resources

• Master Images
• Machine Creation Services (MCS) in Citrix DaaS
• Citrix Provisioning in Citrix DaaS
• Machine Catalogs
• Delivery Groups

Module 7: Provide Access in Citrix Cloud

• Selecting Between Citrix digital workspace experience and StoreFront
• Citrix StoreFront and Citrix digital workspace experience Communications
• Selecting Between Citrix Gateway Service and On-Premises Citrix Gateway
• Access Layer Communications
• User Authentication

Module 8: Citrix DaaS Administration

• Citrix Cloud Manage and Monitor
• Delegated Administration
• Citrix DaaS Remote PowerShell Software Development Kit
• Manage Multiple Resource Locations

Module 9: Public Cloud Considerations

• General Public Cloud Considerations
• Using Autoscale to Power Manage Machines in a Public Cloud
• Microsoft Azure as a Citrix DaaS Resource Location
• Amazon Web Services as a Citrix DaaS Resource Location
• Google Cloud as a Citrix DaaS Resource Location

Module 10: Operations and Support in Citrix Cloud

• Citrix Cloud Connector Support
• Updating and Rolling Back Machine Catalogs
• VDA Restore
• Citrix Self-Help Strategy
• Monitor Your Environment

Module 11: Migrating to Citrix DaaS from Citrix Virtual Apps and Desktops

• Citrix Cloud Migration Options and Considerations
• Citrix Automated Configuration Tool
• Citrix Image Portability Service

Course Overview

Version control refers to the tracking and traceability of changes. It is, in a way, akin to the use of a bookmark in a book, added by a reader, to mark the point to return to when they resume reading. In version control, a metaphorical bookmark marks a reference to a snapshot of the code base. Git is a version control tool. Using Git, you can make, track, retrieve, and share changes on a repository. GitHub is a hosting service on which a repository resides.

This is a two-day course that will provide you a thorough understanding of what version control is, why it’s necessary, and how it lends itself to application development and version management. With thorough explanations and interesting activities, you will learn all about using using Git and GitHub optimally.

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 retaining security, portability, and affordability. By the end of the course, you will have the right skills to safeguard your application and ensure its speedy development.

Course Objectives

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

This course will enable you to:

• Understand and implement version control best practises
• Navigate the GitHub UI
• Understand what the Feature Branch Workflow is and implement its features
• Use forking features, such as submodules and rebasing
• Master commands for debugging and maintaining a repository
• Implement continuous integration with CircleCi or TravisCi
• Gain insight into release management and how GitHub enables software releases

Course Content

Lesson 1 – Introduction to Version Control

• Defining Version Control
• Navigating GitHub

Lesson 2 – Versioning Commits

• Introduction to Versioning Commits

Lesson 3 – Fetching and Delivering Code

• Fetching the Code

Lesson 4 – Branches

• Utilizing Workflows

Lesson 5 – Collaborative GIT 

• Forking the Workflow
• Debugging and Maintenance
• Housekeeping

Lesson 6 – Automated Testing and Release Management

• Test Automation
• Automated Pull Requests

Course Overview

Spring Boot 2 is the latest incarnation of the Spring Framework, which is a mature, enterprise-grade, and open source application development framework that provides a flexible and modern alternative to the official Java EE standard. It also provides inversion of control containers for the Java platform.

This is a 3-day course, which balances theory and hands-on applications that are focused on practical takeaways. The course will take you through the fundamentals of the Spring Framework. You will then gain an understanding of how to retrieve data using a relational database. Gradually, you will learn how to create browser-based applications. Lastly, you will grasp the concept of RESTful web-services, APIs, and learn how to implement Spring Security.

Course Objectives

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

The course will provide you with knowledge of the following:

• Create a Spring Boot application from scratch
• Write comprehensive tests
• Store data in a relational DB
• Create a RESTful API
• Create a rich web interface
• Secure your application with Spring security

Course Content

Lesson 1 – The Spring Project and Framework

• The Spring Project and Framework
• Bootstrapping
• The Application Context
• Additional Tools- Project Lombok

Lesson 2 – Building a Spring Application

• Dependency Injection in Spring
• Configuration of Spring Boot Applications

Lesson 3 – Testing Spring Applications

• Applying Unit Tests
• Integration Tests

Lesson 4 – The MVC Pattern

• Introducing the MVC pattern
• Spring Web MVC Basics
• Spring Web MVC Controller

Lesson 5 – Displaying Information Using Web Pages

• HTML Templating with Thymeleaf
• Displaying Data Using a Model and Data Binding

Lesson 6 – Passing Data Between the View and the Controller

• Form Handling
• Form Input Types and Value Binding

Lesson 7 – RESTful APIs

• What is a RESTful API?
• REST controllers in Spring
• Hypermedia with Spring Boot

Lesson 8 – Web Application Security

• Securing your Web Application
• Spring Security

Lesson 9 – Persisting Data Using a Database

• Relational Databases and SQL
• Access the Database from Java with JDBC and JdbcTemplate
• Schema Updates
• Outlook – Advanced Database Support

Course Overview

With the help of this course, you can equip yourself with the skills required to create modern, progressive web applications that load quickly and efficiently. This fast-paced course is a great way to learn how to build an effective UX by using the new features of Angular 7 beta, without wasting your efforts on searching for referrals.

To start off, you’ll install the Angular CLI and set up a working environment, followed by learning how to distinguish between the container and presentational components. You’ll explore advanced concepts such as making requests to a REST API from an Angular application, creating a web server using Node.js and Express, and adding dynamic metadata. Toward the end of this course, you’ll gain an understanding of how to implement and configure a service worker using Angular PWA and how to deploy a server-side rendered app to the cloud.

By the end of this course, you’ll have developed the skills needed to serve your users views that load instantly, while reaping all the SEO benefits of improved page indexing.

Course Objectives

After completing this course, you will be able to:

• Identify what makes an Angular application SEO-friendly
• Generate commands to create components and services
• Distinguish between the container and presentational components
• Implement server-side rendering using Angular Universal
• Create a web server using Node.js and Express
• Add dynamic metadata to your web application
• Deploy a server-side rendered app to the cloud
• Implement and configure a service worker using Angular PWA

Course Content

Lesson 1: Creating the Base Application

• Installing Angular CLI
• Creating a New Application
• Configuring Global Styles
• Creating the UI for the Application
• Creating the App Logic

Lesson 2: Server-Side Rendering

• Generating the Universal Code
• Enabling Support for Lazy Loading
• Building the Server
• Adding Dynamic Metadata
• Deploying to Production

Lesson 3: Service Workers

• Installing Angular PWA
• Configuring the Service Worker
• Testing the Service Worker
• Debugging the Service Worker

Course Overview

Automated testing is the way forward. It is faster than manual testing, and you can easily rerun your tests at no extra cost. With this course, you’ll learn how to use Selenium to efficiently test your own applications.

There are several challenges when writing automated tests for web applications: selecting an adequate test framework, using appropriate selectors to avoid flaky tests, and building a good testing framework. This course walks you through these challenges and provides you with the knowledge to overcome hurdles in testing by developing stable and effective testing solutions. You will learn the complete process of automated testing, such as configuring your environment, creating and running automated tests, analyzing reports, and troubleshooting errors by using a Selenium Grid.

Course Objectives

This course starts with the fundamentals and in an incremental fashion provides you with the skills you need to run automated tests on your own web application.

We’ll begin this course by understanding the importance of automating tests. Then, we will learn how to choose good selectors for navigating through your web application while highlighting best practices and techniques.

After writing your first tests, you will go through the object model to help create your own advanced test cases. You will learn how to analyze a test report, track timing errors, and separate real issues from “flaky” tests. You will also learn how to configure and connect to a local grid, a network grid, and a third-party service. By the end of the course, you will have the skills you need to run automated tests on your own web application.

After completing this course, you will be able to:

• Get an overview of Selenium
• Identify what to automate in a project and configure the environment
• Learn to control browser behaviour and manipulate web page elements
• Understand the nuances of writing tests and creating test suites
• Create UI tests with Selenium WebDriver and analyze test results
• Troubleshoot errors in automation and build out meaningful reporting

Course Content

Lesson 1: Getting Started

• What is Automation?
• Selenium Overview
• Environment Configuration

Lesson 2: WebDriver Functionality

• Overview of Frequently Used Methods
• Instantiating WebDriver
• Controlling the Browser Window

Lesson 3: WebElement Functionality

• Using Browser Developer Tools
• Overview of WebElement Functionality
• Interacting with Elements on a Page
• Element Locator Types

Lesson 4: Advanced Element Location

• Going through the DOM
• Searching within Previously Found Elements
• Creating Complex Locators when an Element is Not Easily Reachable

Lesson 5: Waiting for Elements

• Implicit Waits
• Explicit waits
• Implicit Versus Explicit Waits
• Waiting for an Element with a Custom Written Condition

Lesson 6: Page Object Model

• Introduction to the Page Object Model
• Modeling a Web Application Using Page Objects
• Creating a Selenium Framework for a Web Application

Lesson 7: Writing Tests

• What is a Test Framework?
• Choosing a Test Framework
• Creating Test Scripts and Suites
• Validating and Viewing Results

Lesson 8: Analysis and Troubleshooting

• Analyzing the Test Report
• Tracking Down Timing Errors
• Separating Real Issues from “Flaky” Tests

Lesson 9: Using a Selenium Grid

• Configuring and Connecting to a Local Grid
• Configuring and Connecting to a Network Grid
• Connecting to a Third-Party Service

Course Overview

Data analysis is crucial to accurately predict the performance of an application. The course begins by getting you started with R, including basic programming and data import, data visualization, pivoting, merging, aggregating, and joins. Once you are comfortable with the basics, you will read ahead and learn all about data visualization and graphics. You will learn data management techniques such as pivots, aggregations, and dealing with missing values. With this various case studies and examples, this course gives you the knowledge to confidently start your career in the field of data science.

This is a hands-on guide that walks you through concepts with examples using built-in R data. Every topic is enriched with a supporting example that highlights the concept, followed by activities that will gradually build into a full data science project to showcase skills learned. You will perform an end-to-end analysis, starting a data science portfolio.

Course Objectives

The course begins by getting you started with R, including basic programming and data import, data visualization, pivoting, merging, aggregating, and joins. You will learn how to:

• Use the basic programming concepts of R such as loading packages, arithmetic functions, data structures, and flow control
• Import data to R from various formats, such as CSV, Excel, and SQL
• Clean data by handling missing values and standardizing fields
• Perform univariate and bivariate analysis using ggplot2
• Create statistical summary and advanced plots, such as histograms, scatter plots, box plots, and interaction plots
• Apply data management techniques, such as factors, pivots, aggregation, merging, and dealing with missing values, on the example data sets

Course Content

Lesson 1: INTRODUCTION TO R

• Using R, RStudio, and Installing Useful Packages
• Variable Types and Data Structures
• Basic Flow Control
• Data Import and Export
• Getting Help with R

Lesson 2: DATA VISUALIZATION AND GRAPHICS

• Creating Base Plots
• ggplot2
• Interactive Plots

Lesson 3: DATA MANAGEMENT

• Factor Variables
• Summarizing data
• Splitting, Combining, Merging, and Joining Datasets

Course Overview

The Programming for Network Engineers (PRNE) course is designed to equip you with fundamental skills in Python programming. Through a combination of lectures and lab experience in simulated network environments, you will learn to use Python basics to create useful and practical scripts with Netmiko to retrieve data and configure network devices. Upon completion of this course, you should have a basic understanding of Python, including the knowledge to create, apply, and troubleshoot simple network automation scripts.

This course will help you:

– Explain the need for network engineers to learn how to program

– Explain how programming relates to the journey into network automation and programmability

– Create useful and practical scripts to retrieve data and configure network devices

– Create, apply, and troubleshoot simple network automation scripts

– Gain hands-on experience with Python programming

Course Objectives

After completing this course, you should be able to:

• Create a Python script
• Describe data types commonly used in Python coding
• Describe Python strings and their use cases
• Describe Python loops, conditionals, operators, and their purposes and use cases
• Describe Python classes, methods, functions, namespaces, and scopes
• Describe the options for Python data manipulation and storage
• Describe Python modules and packages, their uses, and their benefits
• Explain how to manipulate user input in Python
• Describe error and exception management in Python
• Describe Python code debugging methods

Course Content

Introducing Programmability and Python for Network Engineers

• Programmability
• Continued Importance of the CLI
• Need for Python
• First Python Program

Scripting with Python

• Running a Python Script
• Python Interactive Shell
• Editors and IDEs

Examining Python Data Types

• String Data Type
• Integer Data Type
• Float Data Type
• Boolean Data Type
• type() Function 
• Python Variables
• List Analysis
• Tuple Data Analysis
• Data Set Types
• Python Dictionary
• Nested Data Types
• Navigating Complex Data Structures

Manipulating Strings

• String Manipulation
• String Splitting
• Modifying Strings
• String Contacenation
• Whitespace Stripping
• Formatting and Templating
• Escape Characters
• Regular Expressions
• String Methods

Describing Conditionals, Loops, and Operators

• Whitespace and PEP 8
• Conditionals
• Operators
• Example of Using Conditionals
• Loops
• Loops with Lists, Dicts and Ranges

Exploring Classes, Methods, Functions, Namespaces, and Scopes

• Practical Reuse of Codes
• Functions
• Code Commenting
• Namespaces and Scopes
• Classes and Methods
• Using Inheritance to Extend Functionality
• Main Construct

Exploring Data Storage Options

• Data Formats
• Readng Data from a Simple Text and CSV File
• Writing Data to a Simple Text and CSV File
• Reading Data from a JSON Text File
• Writing Data to a JSON Text File
• Data Access in a RAW or Unstructured Format

Exploring Python Modules and Packages

• Python Standard Library Modules
• Reusable code with Modules and Packages 

Gathering and Validating User Input

• Obtaining User Input
• Command-Line Arguments

Analyzing Exceptions and Error Management

• Errors and Exceptions
• Managing Exceptions
• Assertions

Examining Debugging Methods

• Code Debugging Process
• Python Debugging Functions
• Debuggers
• Python Debugger
• Pdb Commands

Labs

• Execute Your First Python Program
• Use the Python Interactive Shell
• Explore Foundation Python Data Types
• Explore Complex Python Data Types
• Use Standard String Operations
• Use Basic Pattern Matching
• Reformat MAC Addresses
• Use the if-else Construct
• Use for Loops
• Use while Loops
• Create and Use Functions
• Create and Use Classes
• Use the Python main() Construct
• Traverse the File Structure
• Read Data in Comma-Separated Values (CSV) Format
• Read, Store, and Retrieve Data in XML Format
• Read, Store, and Retrieve Date in JavaScript Object Notation (JSON) Format
• Read, Store, and Retrieve Data in a Raw or Unstructured Format
• Import Modules from the Python Standard Library
• Import External Libraries
• Create a Python Module
• Prompt the User for Input
• Use Command-Line Arguments
• Manage Exceptions with the try-except Structure
• Manage Exceptions with the try-except-finally Structure
• Use Assertions
• Use Simple Debugging Methods
• Use the Python Debugger
• Code a Practical Debugging Script

Course Overview

We begin the course by learning about value types (structs and enums), and when they are preferable over classes. We also learn about the copy-on-write technique and how to implement it ourselves. Then we learn how to load JSON from web APIs into our custom types, and how to export that content out again. Finally we learn how to create frameworks, and import other frameworks using CocoaPods or Carthage.

We move on to learn advanced uses of Swift protocols and how protocol-oriented development improves efficiency and leads to more maintainable and reusable code. Then we learn about generics, and how they enable us to support multiple types without duplication. Later in the course, we discover different ways to structure a complete iOS app from scratch. We begin the discussion with the well-known MVC pattern and cover every other trending architecture in the iOS world.

Course Objectives

• Load content from web APIs into structs
• Use methods to store structs to files
• Implement the copy-on-write technique
• Describe protocols and protocol-oriented programming in depth
• Write code with less duplication using generics
• Evaluate different architectural patterns for iOS apps
• Create an iOS app using Redux.

Course Content

LESSON 1: VALUE TYPES

• Reference versus Value Types
• Structs
• Enums

LESSON 2: ENCODING AND DECODING

• JSON Decoding
• JSON Encoding

LESSON 3: SWIFT FRAMEWORKS

• Creating a framework
• CocoaPods
• Carthage

LESSON 4: SWIFT PROTOCOLS

• Protocol Syntax Basics
• Using Protocols as Types
• Mutating Method Requirements

LESSON 5: TRANSITIONING TO PROTOCOL-ORIENTED PROGRAMMING

• Comparing Object-Oriented and Protocol-Oriented Programming
• Implement Employee as a Simple Swift Struct
• Refactoring Employee with an Object-Oriented Approach
• Refactoring Employee with a Protocol-Oriented Approach

LESSON 6: GENERICS

• Basics of Generics
• Creating Generic Types
• Generic Extensions
• Associated Types

LESSON 7: SOFTWARE DESIGN

• The Need for Architectural Patterns
• The Original MVC Report
• Apple’s MVC

LESSON 8: MVC ALTERNATIVES

• Apple’s MVC in Practice
• MVVM (Model-View-ViewModel)
• VIPER

LESSON 9: UNIDIRECTIONAL DATA FLOW

• Identifying Side Effects of Functions
• Unidirectional Data Flow
• Redux in iO

Course Overview

Equip yourself with writing efficient and powerful code which can be easily managed. This fast-paced guide to Scala leads you through the functional and object-oriented concepts that are used in Scala.

You’ll learn how to write safer and stable code by using pure functions and immutable data structures.

Scala is a general-purpose programming language, combining elements of object-oriented with functional programming. It is backed by a strong type system and is designed to be concise.

Course Objectives

• Write Scala applications
• Effectively participate in existing Scala projects
• Recognize and use typical idioms and patterns
• Identify the principles of functional programming and know the essence of advanced functional patterns

Course Content

Day One – Getting Started with Scala
 
We begin our day by easing ourselves into the world of Scala. We setup our development environment and learn some basics of Scala language.

Lesson One – Setting up the Development Environment

Before starting with the Scala language itself, we will identify how to setup our development environment. we will learn the basics of Scala, such as what the simple Scala program looks like and what a typical developer flow is. We will identify how to structure the Scala program. We will also cover some aspects of testing your Scala program by using Unit testing.

• Recognize the structure of a Scala project
• Identify the use of Scala’s sbt tool (interactive build tool) for building and running your project
• Identify how to use the IDE
• Implement interactions with a simple chatbot

Lesson Two – Basic Language Features

We will explore the so-called ‘OO’ part of Scala such as Java or C++. The object-oriented part of Scala will cover classes and objects, traits, pattern matching, case class, and so on. Finally, we will implement the object-oriented concepts that we learn to our chatbot application.

• Identify the structure of non-trivial Scala programs
• Identify how to use main object-oriented facilities: objects, classes, and traits
• Recognize the details of function call syntax and parameter-passing modes

Lesson Three – Functions

We will cover functional programming with Scala and how object-oriented and functional approaches complete each other. We will cover generic classes and also cover how to create user-defined pattern matching and why is it useful.

• Identify the basics of functional programming
• Identify the basics of generic types in Scala
• Implement user-defined pattern matching
• Recognize and use functional compositional patterns
• Day Two – Scala Collections and Type System
• We begin our day by learning various scala collections and then we will cover types.

Lesson One – Scala Collections

We will start by learning how to work with lists. Afterwards, we’ll generalize to sequences and cover some more relevant data structures. Finally, we’ll look at how collections relate to monads and how we can use that knowledge to make some powerful abstractions in our code.

• Identify the Scala collections available in the standard library
• Identify how to abstract on sequences by using higher-order Functions
• Implement the important design principles for working with Scala collections

Lesson Two – Scala Type System

In this lesson, we will cover the type system and polymorphism. We will also cover the different types of variance, which provides a way to constrain parameterized types. Finally, we will cover some advanced types such as abstract type members, option, and so on.

• Identify the Scala type hierarchy
• Use the features the Scala type system provides
• Identify abstractions that the Scala type system enables

Lesson Three – Implicits

We will cover implicit parameters and implicit conversions. We’ll be learning about how they work, how to use them, and what kind of benefits and perils they provide.

• Describe implicits and how the Scala compiler handles them
• Explain the design patterns that implicits enable
• Analyze the common issues that may arise by overusing implicits

Day Three – Building Code using Functional Programming

We begin our day by focusing on the functional programming aspects of Scala. We will then cover Cats and Doobie, which are the two popular functional programming libraries.

Lesson One – Functional Idioms

We’ll cover the core concepts of functional programming like Pure functions, immutability, and higher-order functions. We’ll introduce some of the design patterns that are prevalent in large functional programs. Finally, we’ll cover two popular functional programming libraries called Cats and Doobie, and use them to write some interesting programs.

• Identify the core concepts of functional programming
• Recognize and implement the popular functional programming design patterns
• Implement Cats and Doobie in your own Scala projects

Lesson Two – Domain Specific Languages

We will cover how Scala makes it possible to write powerful DSLs by providing a few interesting language features. We’ll have a brief look at what DSLs are in general terms. We’ll also cover a DSL that you’ll very likely be using if you’re going to work with Scala professionally. Finally, we will implement our own DSL.

• Identify the use of Domain Specific Languages (DSLs)
• Use the DSL that ScalaTest, a popular testing library for Scala, provides
• Design your own DSLs in Scala

Course Overview

Node.js is considered a game changer. It is the biggest shift of the decade in web development. Node.js applications are written in JavaScript, which enables scenarios such as single-language application stacks and the sharing of code between the server and the client.

The goal of this course is to guide you through the emerging world of patterns, techniques, and practices, helping you to understand proven solutions to common problems.

Throughout the course, you will be presented with several libraries and technologies. They will be used to demonstrate a pattern or technique, and will also give you great exposure to the Node.js ecosystem and its set of solutions.

Course Objectives

This course will uncover a set of patterns to solve common problems encountered in Node.js design and coding. Finally, you will explore writing modular and efficient Node.js applications.

Course Content

Lesson 1: Welcome to the Node.js Platform

• The Node.js Philosophy
• Introduction to Node.js 6 and ES2015
• The Reactor Pattern

Lesson 2: Node.js Essential Patterns

• The Callback Pattern
• The Module System and its Pattern
• The Observer Pattern

Lesson 3: Asynchronous Control Flow Patterns with Callbacks

• The Difficulties of Asynchronous Programming
• Using Plain JavaScript
• The async Library

Lesson 4: Asynchronous Control Flow Patterns with ES2015 and Beyond

• Promise
• Generators
• Async/Await Using Babel
• Comparison

Lesson 5: Coding with Streams

• Discovering the Importance of Streams
• Getting Started with Streams
• Asynchronous Control Flow with Streams
• Piping Patterns

Lesson 6: Design Patterns

• Factory
• Revealing Constructor
• Proxy
• Decorator
• Adapter
• Strategy
• State
• Template
• Middleware
• Command

Lesson 7: Wiring Modules

• Modules and Dependencies
• Patterns for Wiring Modules
• Wiring Plugins

Lesson 8: Universal JavaScript for Web Applications

• Sharing Code with the Browser
• Introducing Webpack
• Fundamentals of Cross-Platform Development