In this 5-day course, the professional web developers will learn to develop advanced ASP.NET Core MVC applications using .NET Core tools and technologies. The focus will be on coding activities that enhance the performance and scalability of the Web site application. This course will also prepare the student for exam 70-486

Pre-requisites:

• Experience with Visual Studio 2017.
• Experience with C# programming, and concepts such as Lambda expressions, LINQ, and anonymous types.
• Experience in using the .NET Framework.
• Experience with HTML, CSS and JavaScript.
• Experience with querying and manipulating data with ADO.NET.
• Knowledge of XML and JSON data structures.

Target Audience:

This course is intended for professional web developers who use Microsoft Visual Studio in an individual-based or team-based, small-sized to large development environment. Candidates for this course are interested in developing advanced web applications and want to manage the rendered HTML comprehensively. They want to create websites that separate the user interface, data access, and application logic.

Course Duration:

• 35 hours – 5 days

Course Content:

Module 1: Exploring ASP.NET Core MVC

Microsoft ASP.NET Core MVC and the other web technologies of the ASP.NET Core can help you create and host dynamic, powerful, and extensible web applications. ASP.NET Core, of which ASP.NET Core MVC is part, is an open-source, cross-platform framework that allows you to build web applications. You can develop and run ASP.NET Core web applications on Windows, macOS, Linux, or any other platform that supports it. ASP.NET Core MVC supports agile, test-driven development cycle. It also allows you to use the latest HTML standard and Front-End frameworks such as Angular, React, and more.

Lessons

• Overview of Microsoft Web Technologies
• Overview of ASP.NET 4.x
• Introduction to ASP.NET Core MVC

Lab: Exploring ASP.NET Core MVC

• Exploring a Razor Pages Application
• Exploring a Web API Application
• Exploring an MVC Application

After completing this course, students will be able to:

• Understand the variety of technologies available in the Microsoft web stack.
• Describe the different programming models available for developers in ASP.NET.
• Choose between ASP.NET Core and ASP.NET 4.x.
• Describe the role of ASP.NET Core MVC in the web technologies stack, and how to use ASP.NET Core MVC to build web applications.
• Distinguish between MVC models, MVC controllers, and MVC views.

Module 2: Designing ASP.NET Core MVC Web Applications

Microsoft ASP.NET Core MVC is a programming model that you can use to create powerful and complex web applications. However, all complex development projects, and large projects in particular, can be challenging and intricate to fully understand. Without a complete understanding of the purposes of a project, you cannot develop an effective solution to the customer’s problem. You need to know how to identify a set of business needs and plan the Model-View-Controller (MVC) web application to meet those needs. The project plan that you create assures stakeholders that you understand their requirements and communicates the functionality of the web application, its user interface, structure, and data storage to the developers. By writing a detailed and accurate project plan, you can ensure that the powerful features of MVC are used effectively to solve the customer’s business problems.

Lessons

• Planning in the Project Design Phase
• Designing Models, Controllers and Views

Lab: Designing ASP.NET Core MVC Web Applications

• Planning Model Classes
• Planning Controllers
• Planning Views
• Architecting and MVC Web Application

After completing this module, students will be able to:

• Plan the overall architecture of an ASP.NET Core MVC web application and consider aspects such as state management.
• Plan the models, controllers, and views that are required to implement a given set of functional requirements.

Module 3: Configure Middlewares and Services in ASP.NET Core

ASP.NET Core is a framework that allows us to build many different kinds of applications. In this module, you will learn how to leverage the ASP.NET Core framework to handle requests and responses via existing, and custom middleware, and how to configure services for use in middleware and throughout other parts of the application, such as controllers. A middleware is a segment of code that can be used as part of the request and response pipeline that allows us to handle them according to any relevant parameter. This potentially allows multiple separate requests to be handled in a completely different fashion and receive separate responses. Services are classes that expose functionality which you can later use throughout different parts of the application, without having to keep track of scope manually in each individual location and instantiate any dependencies. This is done by using Dependency Injection. Dependency Injection is a technique used by ASP.NET Core that allows us to add dependencies into the code without having to worry about instantiating objects, keeping them in memory, or passing along required dependencies. This allows the application to become more flexible and to reduce potential points of failure whenever you change a service.

Lessons

• Configuring Middlewares
• Configuring Services

Lab: Configuring Middleware and Services in ASP.NET Core

• Working with Static Files
• Creating custom middleware
• Using dependency injection
• Injecting a service to a controller

After completing this module, students will be able to:

• Use existing middleware to set up an ASP.NET Core application.
• Create your own middleware and use it to define custom behavior.
• Understand the basic principles behind Dependency Injection, and how it is used in ASP.NET Core.
• Know how to create a custom service, configure its scope, and inject it to both middleware and ASP.NET Core MVC controllers.

Module 4: Developing Controllers

ASP.NET Core MVC is a framework for building web applications by using the Model-View-Controller (MVC) architectural pattern. The controller is essentially responsible for processing a web request by interacting with the model and then passing the results to the view. The model represents the business layer, sometimes referred to as the domain, and may include data objects, application logic, and business rules. The view uses the data that it receives from the controller to produce the HTML or other output that is sent back to the browser. In this module, you will learn how to develop controllers. Controllers are central to MVC applications. Understanding how controllers work is crucial to being able to create the appropriate model objects, manipulate them, and pass them to the appropriate views. A controller is a class. It contains several methods. These methods are called actions. When an MVC application receives a request, it finds which controller and action should handle the request. It determines this by using Uniform Resource Locator (URL) routing. URL routing is another very important concept necessary for developing MVC applications. The ASP.NET Core MVC framework includes a flexible URL routing system that enables you to define URL mapping rules within your applications. To maximize the reuse of code in controllers, it is important to know how to write action filters. You can use action filters to run code before or after every action in your web application, on every action in a controller, or on other combinations of controller actions.

Lessons

• Writing Controllers and Actions
• Configuring Routes
• Writing Action Filters

Lab: Developing Controllers

• Adding controllers and actions to an MVC application
• Configuring routes by using the routing table
• Configuring routes using attributes
• Adding an action filer

After completing this module, students will be able to:

• Add a controller to a web application that responds to user actions that are specified in the project design.
• Add routes to the ASP.NET Core routing engine and ensure that URLs are user-friendly in an MVC web application.
• Write code in action filters that runs before or after a controller action.

Module 5: Developing Views

Views are one of the three major components of the Model-View-Controller (MVC) programming model. You can define the user interface for your web application by creating views. A view is a combination of HTML markup and C# code that runs on a web server. Therefore, to create a view, you need to know how to write the HTML markup and C# code and use the various helper classes that are built into MVC. You also need to know how to create partial views and view components, which render sections of HTML that can be reused in your web application.

Lessons

• Creating Views with Razor Syntax
• Using HTML Helpers and Tag Helpers
• Reusing Code in Views

Lab: Developing Views

• Adding Views to an MVC Application
• Adding a partial view
• Adding a view component

After completing this module, students will be able to:

• Create an MVC view and add Razor markup to it to display data to users.
• Use HTML helpers and tag helpers in a view.Reuse Razor markup in multiple locations throughout an application.

Module 6: Developing Models

Most web applications interact with various types of data or objects. An e-commerce application, for example, manages products, shopping carts, customers, and orders. A social networking application might help manage users, status updates, comments, photos, and videos. A blog is used to manage blog entries, comments, categories, and tags. When you write a Model-View-Controller (MVC) web application, you create an MVC model to model the data for your web application. Within this model, you create a model class for each type of object. The model class describes the properties of each type of object and can include business logic that matches business processes. Therefore, the model is a fundamental building-block in an MVC application. In this module, you will learn how to create the code for models.

Lessons

• Creating MVC Models
• Working with Forms
• Validate MVC Application

Lab: Developing Models

• Adding a model
• Working with Forms
• Add Validation

After completing this module, students will be able to:

• Add a model to an MVC application and write code in it to implement the business logic.
• Use display and edit data annotations.
• Validate user input with data annotations.

Module 7: Using Entity Framework Core in ASP.NET Core

Web applications often use information and they usually require a data store for that information. By rendering webpages that use data from a data store, you can create a web application that changes continually in response to user input, administrative actions, and publishing events. The data store is usually a database, but other types of data stores are occasionally used. In Model-View-Controller (MVC) applications, you can create a model that implements data access logic and business logic. Alternatively, you can separate business logic from data access logic by using a repository. A repository is a class that a controller can call to read data from a data store and to write data to a data store. When you write an ASP.NET application you can use the Entity Framework Core (EF Core) and Language Integrated Query (LINQ) technologies, which make data access code very quick to write and simple to understand. In this module, you will see how to build a database-driven website in MVC.

Lessons

• Introduction to Entity Framework Core
• Working with Entity Framework Core
• Use Entity Framework Core to connect to Microsoft SQL Server

Lab : Using Entity Framework Core in ASP.NET Core

• Adding Entity Framework Core
• Use Entity Framework Core to retrieve and store data
• Use Entity Framework Core to connect to Microsoft SQL Server

After completing this module, students will be able to:

• Connect an application to a database to access and store data.
• Explain EF Core.
• Work with Entity Framework Core.
• Use EF Core to connect to a database including Microsoft SQL Server.

Module 8: Using Layouts, CSS and JavaScript in ASP.NET Core MVC

While building web applications, you should apply a consistent look and feel to the application. You should include consistent header and footer sections in all the views. Microsoft ASP.NET Core MVC includes features such as cascading style sheets (CSS) styles and layouts that enhance the appearance and usability of your web application. In ASP.NET Core MVC, you can create interactive HTML elements by using JavaScript. You need to know how to use JavaScript in your web application. To simplify adding JavaScript to your web application, you need to know how to use libraries such as jQuery.

Lessons

• Using Layouts
• Using CSS and JavaScript
• Using jQuery

Lab : Using Layouts, CSS and JavaScript in ASP.NET Core

• Applying a layout and link views to it
• Using CSS
• Using JavaScript
• Using jQuery

After completing this module, students will be able to:

• Apply a consistent layout to ASP.NET Core MVC applications.
• Add JavaScript code to your web application.
• Use the jQuery library in your web application.

Module 9: Client-Side Development

When creating an application, it is important to know how to develop both client-side and server-side of the application. In this module, you are going to learn client-side tools that will allow you to create extensive web applications on any scale. These tools are based on the topics covered in Module 8, “Using Layouts, CSS and JavaScript in ASP.NET Core MVC”. In this module, you are going to learn how to use the Bootstrap framework to style your web application. Then you are going to learn how to use Sass and Less, two common Cascading Style Sheets (CSS) preprocessors that add features to CSS, such as variables, nested rules, and functions. These greatly improve the maintainability of complex web applications. Next, you will learn how to set up task runners such as Grunt and gulp and how to use them to compile Sass files during the Microsoft Visual Studio build. You will learn how to use the gulp task runner to perform bundling and minification of CSS and JavaScript files and how to set up a watcher task to compile Sass files as you write your code, without the need to rebuild the solution. Finally, you will learn responsive design tools that allow you to customize your web application’s display based on the capabilities and specifications of a web browser or a device. You will learn to write CSS media queries, how to use the Bootstrap responsive grid system, and how to apply the CSS flexbox layout to your views.

Lessons

• Applying Styles
• Using Task Runners
• Responsive design

Lab: Client-Side Development

• Use gulp to run tasks
• Styling using Sass
• Using Bootstrap

After completing this module, students will be able to:

• Use Bootstrap, Sass and Less in a Microsoft ASP.NET Core application.
• Use task runners in an ASP.NET Core application.
• Ensure that a web application displays correctly on devices with different screen sizes.

Module 10: Testing and Troubleshooting

Software systems such as web applications are complex and require multiple components, which are often written by different developers, to work together. Incorrect assumptions, inaccurate understanding, coding errors, and many other sources can create bugs that result in exceptions or unexpected behavior. To improve the quality of your web application and create a satisfying user experience, you must identify bugs from any source and eliminate them. Traditionally, testers perform most of the testing at the end of a development project. However, it has recently become widely accepted that testing throughout the project life cycle improves quality and ensures that there are no bugs in production software. You need to understand how to run tests on small components of your web application to ensure that they function as expected before you assemble them into a complete web application. It is also important that you know how to handle exceptions while they occur. While an application is running, you may encounter unexpected occurrences. It is important that you manage your exceptions correctly and provide a good user feedback while avoiding leaking information about the application structure. Finally, by using logs throughout the application, you can monitor user activities that might lead to unexpected issues and then you can find solutions to bugs, which you normally would be unsure how to reproduce, by following flows which occurred on the production environment and finding additional errors.

Lessons

• Testing MVC Applications
• Implementing an Exception Handling Strategy
• Logging MVC Applications

Lab: Testing and troubleshooting

• Testing a Model
• Testing a controller using a fake repository
• Implementing a repository in MVC project
• Add exception handling
• Add logging

After completing this course, students will be able to:

• Run unit tests against the Model–View–Controller (MVC) components, such as model classes and controllers, and locate potential bugs.
• Build a Microsoft ASP.NET Core MVC application that handles exceptions smoothly and robustly.
• Run logging providers that benefit your applications and run them by using a common logging API.

Module 11: Managing Security

Since web applications are normally targeted towards users utilizing only a browser to use the application, there are likely to be far more users than in the case of installed applications. However, the open nature of a web application means security must always be at the forefront of your mind when building them. As part of security, you must decide which users can perform what actions, all while protecting users and your application from malicious third parties with possible access to your application. Authentication is the act of utilizing several parameters to make sure that a user is who they claim to be. By implementing authentication, you can ascertain who a user is and provide them with appropriate content while utilizing your applications. Authorization is the process where an already authenticated user in the application can be granted access to specific actions or resources. By utilizing authorization, you can prevent users from accessing sensitive material not intended from them or from performing actions which they should not be able to. Finally, at some point in its lifespan, your applications may come under attack by malicious users. These can vary in means and intent, but the cost of being undefended can be great. You may lose potential users who are affected, valuable data could be erroneously changed, and in the worst cases the entire application may become unusable. Solutions to some of the most popular attacks will be reviewed in this module.

Lessons

• Authentication in ASP.NET Core
• Authorization in ASP.NET Core
• Defending from Attacks

Lab : Managing Security

• Use Identity
• Add Authorization
• Avoid the Cross-Site Request Forgery Attack

After completing this module, students will be able to:

• Add basic authentication to your application.
• Configure Microsoft ASP.NET Core Identity.
• Add basic authorization to your application.
• Utilize several different authorization approaches.
• Know how security exploits work and how to better defend against them.

Module 12: Performance and Communication

Modern web applications require complex interactions with users. Users will often request a lot of data in a small time-frame, while also expecting relevant data as soon as it comes online. This can easily cause a significant amount of load on an unprepared server, resulting in unnecessarily complex or repeated operations and a heavy load on your server. Fortunately, there are multiple ways to reduce the load. Caching allows you to store commonly repeated requests, preventing the need to perform the same logic repeatedly. By using caching, you can reuse data that has already been loaded and present it to the user. This provides the user with a fast response time and reduces system resources used in conducting the logic for the action. State meanwhile allows achieving a state of consistency between different requests. By utilizing various forms of state management, you can transform the normally stateless web experience into one that is custom tailored to individual clients, with different users enjoying a separate and relevant experience in the same application. Finally, SignalR is a framework that allows the abstraction of several different communication protocols into an easy to use API, which allows you to easily create a single set of tools on the server and client to facilitate two-way communications. This allows you to focus on the logic you wish to implement while allowing you to not have to cater to specific browsers.

Lessons

• Implementing a Caching Strategy
• Managing State
• Two-way communication

Lab: Performance and Communication

• Implementing a Caching Strategy
• Managing state
• Two-Way communication

After completing this module, students will be able to:

• Implement caching in a Microsoft ASP.NET Core application.
• Use state management technologies to improve the client experience, by providing a consistent experience for the user.
• Implement two-way communication by using SignalR, allowing the server to notify the client when important events occur.

Module 13: Implementing Web APIs

Most web applications require integration with external systems such as mobile applications. You need to know how to use Web APIs to promote application interaction with external systems. You can use the Web API to implement Representational State Transfer (REST) services in your application. REST services help reduce application overhead and limit the data that is transmitted between client and server systems. You need to know how to call a Web API by using server-side code and jQuery code to effectively implement REST-style Web APIs in your application.

Lessons

• Introducing Web APIs
• Developing a Web API
• Calling a Web API

Lab: Implementing Web APIs

• Adding Actions and Call Them Using Microsoft Edge
• Calling a Web API using server-side code
• Calling a Web API using jQuery

After completing this module, students will be able to:

• Create services by using ASP.NET Core Web API.
• Call a Web API from server-side code and jQuery.

Module 14: Hosting and Deployment

ASP.NET Core MVC applications are designed to provide a service to multiple users simultaneously while only requiring the server to be installed, and the clients to use browsers to access it. This results in highly desirable applications which do not rely on the user installing dedicated software, and ensuring it is accessible by clients on a wide variety of machines. In order to setup an ASP.NET Core application for a production environment, you will need to compile your code and compress it, and then set it up and running on a dedicated server. Hosting involves using a dedicated server to contain the compiled application and serve it to users as a web-based service. There are many different technologies which can be used to host your application and you should choose one that is appropriate for your requirements. Deployment is the process where the project code is compiled and then transferred to the hosting server in a way that functions within the requirements of the hosting environment. Microsoft Azure is a cloud service provided by Microsoft. It can be used to host ASP.NET Core applications and is a popular tool in the cloud technology market. It provides convenient Web Application related services at multiple billing options according to requirements.

Lessons

• On-premise hosting and deployment
• Deployment to Microsoft Azure
• Microsoft Azure Fundamentals

Lab: Hosting and Deployment

• Deploying a Web Application to Microsoft Azure
• Upload an Image to Azure Blob Storage

After completing this module, students will be able to:

• Host and Deploy an ASP.NET Core MVC application on IIS.
• Host and Deploy an ASP.NET Core MVC application on Microsoft Azure.
• Be able to utilize services offered by Microsoft Azure to improve the capabilities of your web applications.

R is an open-source free programming language for statistical computing, data analysis, and graphics. R is used by a growing number of managers and data analysts inside corporations and academia. R has also found followers among statisticians, engineers and scientists without computer programming skills who find it easy to use. Its popularity is due to the increasing use of data mining for various goals such as set ad prices, find new drugs more quickly or fine-tune financial models. R has a wide variety of packages for data mining. It’s a language that many non-programmers can easily work with, naturally extending a skill set that is common to high-end Excel users. It’s the perfect tool for when the analyst has a statistical, numerical, or probabilities-based problem based on real data and they’ve pushed Excel past its limits.

Course Objectives:

• R Programming JumpStart is a hands-on course covers the manipulation of objects in R including reading data, accessing R packages, writing R functions, and making informative graphs. It includes analyzing data using common statistical models.
• This course covers the manipulation of objects in R including reading data, accessing R packages, writing R functions, and making informative graphs. It includes analyzing data using common statistical models. The course teaches how to use the R software (http://www.r-project.org) both on a command line and in a graphical user interface (GUI).

Pre-requisites:

• This is an introductory level programming course. Attendees for this course should have prior practical hands-on experience with another programming language. Prior exposure to working with statistics and probability, as well as hands-on working knowledge of Excel would also be helpful but is not required. We will collaborate with you to design the best solution to ensure your needs are met, whether we customize the material, or devise a different educational path to help your team best prepare for this training.
• Good understanding of statistics and working with excel.

Target Audience:

Anyone who wishes to build their proficiency in using R programming language can attend this course. This course is ideal for: Business and IT Professionals, Survey Researcher, Risk Analyst & Data Scientists and Data Engineers

Course Duration:

• 21 hours – 3 days

Course Content:

R and statistics

• Using R interactively
• An introductory session
• Getting help with functions and features
• R commands, case sensitivity, etc.
• Recall and correction of previous commands
• Executing commands from or diverting output to a file
• Data permanency and removing objects

Simple manipulations; numbers and vectors

• Vectors and assignment
• Vector arithmetic
• Generating regular sequences
• Logical vectors
• Missing values
• Character vectors
• Index vectors; selecting and modifying subsets of a data set
• Other types of objects

Objects, their modes and attributes

• Intrinsic attributes: mode and length
• Changing the length of an object
• Getting and setting attributes
• The class of an object

Ordered and unordered factors

• A specific example
• The function tapply() and ragged arrays
• Ordered factors

Arrays and matrices

• Arrays
• Array indexing. Subsections of an array
• Index matrices
• The array() function
• Mixed vector and array arithmetic. The recycling rule
• The outer product of two arrays
• Generalized transpose of an array
• Matrix facilities
• Matrix multiplication
• Linear equations and inversion
• Eigenvalues and eigenvectors
• Singular value decomposition and determinants
• Least squares fitting and the QR decomposition
• Forming partitioned matrices, cbind() and rbind()
• The concatenation function, (), with arrays
• Frequency tables from factors

Lists and data frames

• Lists
• Constructing and modifying lists
• Concatenating lists
• Data frames
• Making data frames
• attach() and detach()
• Working with data frames
• Attaching arbitrary lists
• Managing the search path

Reading data from files

• The read.table()function
• The scan() function
• Accessing builtin datasets
• Loading data from other R packages
• Editing data

Probability distributions

• R as a set of statistical tables
• Examining the distribution of a set of data
• One- and two-sample tests

Grouping, loops and conditional execution

• Grouped expressions
• Control statements
• Conditional execution: if statements
• Repetitive execution: for loops, repeat and while
• Session: Writing your own functions
• Simple examples
• Defining new binary operators
• Named arguments and defaults
• The ‘…’ argument
• Assignments within functions
• More advanced examples
• Efficiency factors in block designs
• Dropping all names in a printed array
• Recursive numerical integration
• Scope
• Customizing the environment
• Classes, generic functions and object orientation

Statistical models in R

• Defining statistical models; formulae
• Contrasts
• Linear models
• Generic functions for extracting model information
• Analysis of variance and model comparison
• ANOVA tables
• Updating fitted models
• Generalized linear models
• Families
• The glm() function
• Nonlinear least squares and maximum likelihood models
• Least squares
• Maximum likelihood
• Some non-standard models

Graphical procedures

• High-level plotting commands
• The plot() function
• Displaying multivariate data
• Display graphics
• Arguments to high-level plotting functions
• Low-level plotting commands
• Mathematical annotation
• Hershey vector fonts
• Interacting with graphics
• Using graphics parameters
• Permanent changes: The par() function
• Temporary changes: Arguments to graphics functions
• Graphics parameters list
• Graphical elements
• Axes and tick marks
• Figure margins
• Multiple figure environment
• Device drivers
• PostScript diagrams for typeset documents
• Multiple graphics devices
• Dynamic graphics

Packages

• Standard packages
• Contributed packages and CRAN
• Namespaces
• Summary and Closing Remarks

Course Customization Options

To request a customized training for this course, please contact us to arrange.

This workshop teaches the participants how to design and develop server-side applications using the event-driven, non-blocking model framework Node.js. This program inducts the participant in some of the advanced concepts of the JavaScript language so that the participant is well equipped to build end-to-end application using JavaScript.

Course Objectives:

• Understand the non-blocking nature of Node.js
• Writing asynchronous code with call-backs and streams
• Learn how to modularize code using NPM and require ()
• Understand and take advantage of the built-in apis for building scalable few applications
• Learn how to build web api using Express.js
• Learn how to build real-time applications using WebSockets and socket.io

Pre-requisites:

• Experience in application development in any programming language
• Basic knowledge of the JavaScript language
• Exposure to any server technology (J2EE, .NET, Ruby etc)

Target Audience:

• Web developer who wants to build data intensive scalable applications using Node.js

Course Duration:

• 35 hours – 5 days

Course Content:

ADVANCED JAVASCRIPT

Expressive JavaScript

• The Flexibility of JavaScript
• JavaScript as a Loosely Typed Language
• Functions as First-Class Objects
• Object Mutability

Functions In Depth

• Function Objects
• Function Literal
• Function Invocation Patterns
• Augmenting Types
• Recursion & Closures
• Functions as Callbacks
• Function Currying & Memorization

Closures In Depth

• How Closures Work
• Private Variables, Callbacks and Timers
• Binding Function Contexts
• Overriding Function Behavior

Object Orientation With Prototypes

• Object Instantiation
• Constructors
• Inheritance and Prototype Chain
• Extending Object
• Extending Number
• Instantiation Issues
• Writing class-like code

JavaScript Gotchas

• Global Variables
• Scope
• Semicolon Insertions
• Type Coercion
• Summary and Conclusion

Introduction to Node.js

• Installing Node.js
• Node’s Event Loop
• Alternatives to Node.js
• Writing asynchronous code

Modularizing code

• Understanding built-in modules
• Techniques for modularizing JavaScirpt code
• Using require() to modularize application code
• Using npm for third-party modules
• Handling Exceptions

Events and Streams

• Understanding Events
• EventEmitter class
• Understanding Streams
• Reading and writing streams
• Using pipe()

Accessing Local Resources

• Process Object
• Manipulating File System
• Understanding Buffers

Node.js and the web

• Handling web requests
• Building a web server
• Understanding the need for web sockets
• Realtime interaction using socket.io

Building APIs using Express.js

• Installing Express.js
• Routing
• Parameters and queries in routing
• Creating REST services
• Authentication and authorization
• Error Handling

NodeJs Addons using C++

• Overview of N-API
• Using node-gyp and node-addon-api
• Configuring application
• Building and using C++ Api in Node.js

Scaling Node applications

• The Child process model
• exec, spawn, and fork functions
• Using the Cluster module

Node.js Eco System

• Node Packages
• Packages of interest
• Deciding Factors
• Summary and Conclusion

Course Customization Options

To request a customized training for this course, please contact us to arrange.

The Angular 8 training course covers all major components, syntax, and tooling of the Angular web application framework. Angular 8 fulfill the expectations of modern developers who demand fast performance and responsiveness from their web applications. Participants will set up their working environment to have all the tools needed to start building Angular 8 components with minimum effort.

The program starts with an introduction of JavaScript, NPM, and TypeScript. Participant will understand TypeScript, a powerful typed super set of JavaScript that compiles to JavaScript. The course dives into component-driven development with Angular components. The participants will also learn to create and use Angular 8 Directives and Pipes. Data binding (both 1 and 2 way) is discussed in the context of the new directive API. Finally, the core parts of Angular such as services, HTTP, routing, form validation are covered to develop applications based on the Model-View-Controller (MVC) architecture.

Course Objectives:

• Utilize the Angular core constructs to build Single Page Applications.
• Install necessary modules correctly using NPM.
• Write applications in TypeScript to be transferred to browser-supported JavaScript.
• Build Template and Module-driven forms.
• Utilize Pipes and built-in data formatting tools.
• Setup routing and URLs.
• Execute CRUD commands on REST APIs over Http.

Pre-requisites:

• Before attending this course, students should have general programming experience and knowledge of HTML, CSS and JavaScript

Target Audience:

• Web Application Developer
• Developers

Course Duration:

• 35 hours – 5 days

Course Content:

Day 1

Introduction

• Overview of ES5
• Installing Node and NPM
• JavaScript Basic Syntax
• Detailing on ES5 problems
• JavaScript project creation using NPM
• Introduction to TypeScript
• TypeScript Environment Setup
• Basic Syntax
• Types, Variables and Operators
• Decision Making
• Loops
• Functions and Lambda Expressions

Introduction to TypeScript

• Classes and Objects
• Interface
• Inheritance
• Generics
• Enums
• Number and Strings
• Arrays
• Tuples and Union
• Namespaces and Modules
• Decorators
• Ambients
• Mixins

Introduction to Angular

• Angular CLI
• Why Angular 8
• Angular 8 Features
• Installing and Using Angular 8
• Creating the first Angular Project
• Architecture Overview
• What is new in Angular 8

Building with Components

• Introducing the component
• Component Decorator Properties
• Template
• Inline Template
• Interpolation – Plain text, Object and Array
• Adding CSS
• Component Starter
• Integrating Bootstrap
• Summary

Day 2

Data and Event Binding

• Binding Syntax
• One-Way Binding
• Property binding
• Attribute binding
• Setting Element Properties
• Binding Events
• Key event filtering
• Template Reference Variables
• Two-Way Binding of Input Fields

Attribute Directive

• What are Directives
• Directive Types
• Apply Styles using NgClass and NgStyle
• Applying Styles Directly
• Obsolete Directives and Property Binding
• Controlling Element Visibility
• Setting Image Source Dynamically
• Setting Hyperlink Source Dynamically
• Creating custom Directive

Structural Directives

• Adding and Removing Elements Dynamically
• Looping Using ngFor
• ngFor – Basic Syntax
• Creating Tables with ngFor
• ngFor Local Variables
• Swapping Elements with ngSwitch
• ngSwitch – Basic Syntax
• ngSwitch – Full Template Syntax
• Creating custom Directive

Template Driven Forms

• A Basic Angular Form
• Binding Input Fields
• Accessing the Form Object
• Binding the Form Submit Event
• The Submit Function
• Basic HTML5 Validation – “required” Attribute
• Angular Validators
• Angular Validation State
• Displaying Form Validation State
• Displaying Field Validation State
• Disabling Submit when Form is Invalid
• Submitting the Form
• Binding to Object Variables
• Additional Input Types
• Checkboxes
• Select (drop down) Fields
• Rendering Options for Select (drop down)
• Date fields
• Radio Buttons
• Summary

Day 3

Pipes and Data Formatting

• What are Pipes?
• Using a Built-in Pipe
• Chaining Pipes
• Some Pipe Examples
• Decimal Pipe, Currency Pipe
• Custom Pipes
• Using Custom Pipes
• A Filter Pipe
• A Sort Pipe
• Pipe Category: Pure and Impure
• Pure Pipe Example
• Impure Pipe Example

The Angular Component Router

• Routing and Navigation
• The Component Router
• Traditional Browser Navigation
• Component Router Terminology
• Setting up the Component Router
• Routes
• The app.routes.ts File
• Bootstrapping Routing in main.ts
• A Basic App With Routing
• App Routes
• App Component
• Programmatic Navigation
• Basic Navigation
• Passing Data During Navigation
• Creating Routes with Route Parameters
• Navigating with Route Parameters
• Using Route Parameter Values
• Retrieving the Route Parameter Synchronously
• Retrieving the Route Parameter Asynchronously
• Query Parameters
• Query Parameters – queryParams
• Query Parameters – Navigation
• Retrieving Query Parameters Asynchronously

Services and Dependency Injection

• What is a Service?
• Creating a Basic Service
• What is Dependency Injection?
• What Dependency Injection Looks Like
• Injecting Services
• Using a Service in a Component: Dedicated Instance
• Using a Service in a Component: Shared Instance
• Dependency Injection and @Self
• Dependency Injection and @Host
• Dependency Injection and @Optional

RxJS and Observables

• What is an Observable?
• Introduction
• Environment Setup
• What are Streams
• What is RxJS
• RxJS Observable
• Subject
• Behaviour Subject
• Core RxJS Concepts – Errors, Completion and Subscriptions
• RxJS Operators
• RxJS Filter Operator
• RxJS concatMap Operator
• RxJS mergeMap Operator
• RxJS exhaustMap Operator
• RxJS startWith Operator
• Building Components with RxJS
• Sharing HTTP Responses with the shareReplay Operator
• Observable Concatenation
• Understanding the merge Observable combination Strategy
• Unsubscription
• Summary

Day 4

HTTP Client

• The Angular HTTP Client
• Importing Individual Providers into Services
• Service Using Http Client
• Service Imports
• What does an Observable Object do?
• Making a Basic HTTP GET Call
• Using the Service in a Component
• Importing Observable Methods
• Enhancing the Service with .map() and .catch()
• Using .map()
• Using .catch()
• Using to Promise()
• GET Request
• GET Request with Options
• GET Request Example
• POST Request
• POST Request Example
• Reading HTTP Response Headers

Reactive Forms

• Introduction
• Registering the reactive forms module
• Generating a new form control
• Registering the control
• Managing control values
• Grouping form controls
• Creating FormGroup
• Associating the FormGroup model and View
• Saving form data
• Displaying the component
• Creating nested form groups
• Grouping the nested form in the template
• Partial model updates
• Generating form controls with FormBuilder
• Injecting the FormBuilder service
• Generating form controls
• Simple form validation
• Dynamic controls using form arrays

Angular Modules

• Introduction
• What are Modules?
• Getting Started with Feature Modules
• Splitting Modules Correctly
• Adding Routes to Feature Modules
• Component Declarations
• Understanding Shared Modules
• Understanding the Core Module
• Understanding Lazy Loading
• Implementing Lazy Loading
• Modules & Services
• Loading Services Differently

Dynamic Components

• Introduction
• Dynamic component Loading
• The anchor directive
• Loading Components
• Resolving Components
• Developing Dialog Component
• Adding the Dialog Component
• Summary

Day 5

Angular Material Design

• Introduction
• Key principles
• Setting up Angular Material
• Creating Material Master Module
• First Material Components
• Flexbox Basics
• Adding Sidenav Component
• Adding Responsiveness
• Using Lists
• Using Cards
• Using Tabs
• Using Tables
• Adding Pagination
• Adding Filtering
• Adding Header Sorting

Angular Material Design – Dialogs and Popups

• Adding Toolbar Menu
• Dialog Basics
• Creating First Dialog
• Scaffolding a Form
• Customizing the Form
• Adding Form Validation
• Using DatePicker
• Saving the Data
• Snackbar Notification
• Creating Custom Themes
• Toggling Themes
• RTL and LTR Support

Client-Side Authentication Service

• Introduction to Cryptographic Hashes
• Implement a Password Policy
• Modelling a User Session
• Browser Cookies
• Protect Cookies using HTTP Only Cookies
• Client-Side User Session Management
• Securing a REST Endpoint
• User Login
• Implementing Logout
• Understanding CSRF
• Implement CSRF double submit cookie defense
• Introduction JSON Web Tokens
• JSON Web Tokens In Detail – Header and Payload
• JWT Signature With HS256 / RS256
• Combine Cookies and JWTs
• Setting Subject and Expiration
• Storing JWT In Local Storage
• Authorization Router Guard

Unit Testing

• Introduction to Jasmine and Karma
• Benefits of Unit Testing
• Karma Config
• Using – describe
• Using – it
• Using – beforeEach
• Testing a Form
• Testing a Component with Services
• Testing an asynchronous operation
• Summary and Closing Remarks

Course Customization Options

To request a customized training for this course, please contact us to arrange.

In this 5-day course, the professional web developers will learn to develop advanced ASP.NET Core MVC applications using .NET Core tools and technologies. The focus will be on coding activities that enhance the performance and scalability of the Web site application. This course will also prepare the student for exam 70-486.

Course Objectives:

• Describe the Microsoft Web Technologies stack and select an appropriate technology to use to develop any given application.
• Design the architecture and implementation of a web application that will meet a set of functional requirements, user interface requirements, and address business models.
• Configure the pipeline of ASP.NET Core web applications using middleware, and leverage dependency injection across MVC application.
• Add Controllers to an MVC Application to manage user interaction, update models, and select and return Views.
• Develop a web application that uses the ASP.NET Core routing engine to present friendly URLs and a logical navigation hierarchy to users.
• Create Views in an MVC application that display and edit data and interact with Models and
• Create MVC Models and write code that implements business logic within Model methods, properties, and events.
• Connect an ASP.NET Core application to a database using Entity Framework Core.
• Implement a consistent look and feel across an entire MVC web application.
• Write JavaScript code that runs on the client-side and utilizes the jQuery script library to optimize the responsiveness of an MVC web application.
• Add client side packages and configure Task Runners.
• Run unit tests and debugging tools against a web application in Visual Studio 2017.
• Write an MVC application that authenticates and authorizes users to access content securely using Identity.
• Build an MVC application that resists malicious attacks.
• Use caching to accelerate responses to user requests.
• Use SignalR to enable two-way communication between client and server.
• Describe what a Web API is and why developers might add a Web API to an application.
• Describe how to package and deploy an ASP.NET Core MVC web application from a development computer to a web server.

Pre-requisites:

• Experience with Visual Studio 2017.
• Experience with C# programming, and concepts such as Lambda expressions, LINQ, and anonymous types.
• Experience in using the .NET Framework.
• Experience with HTML, CSS and JavaScript.
• Experience with querying and manipulating data with ADO.NET.
• Knowledge of XML and JSON data structures.

Target Audience:

This course is intended for professional web developers who use Microsoft Visual Studio in an individualbased or team-based, small-sized to large development environment. Candidates for this course are interested in developing advanced web applications and want to manage the rendered HTML comprehensively. They want to create websites that separate the user interface, data access, and application logic.

Course Duration:

• 35 hours – 5 days

Course Content:

• Exploring ASP.NET Core MVC
• Designing ASP.NET Core MVC Web Applications
• Configure Middlewares and Services in ASP.NET Core
• Developing Controllers
• Developing Views
• Developing Models
• Using Entity Framework Core in ASP.NET Core
• Using Layouts, CSS and JavaScript in ASP.NET Core MVC
• Client-Side Development
• Testing and Troubleshooting
• Managing Security
• Performance and Communication
• Implementing Web APIs
• Hosting and Deployment

Course Customization Options

To request a customized training for this course, please contact us to arrange.

ASP.NET MVC is an open source web development framework from Microsoft that provides a Model View Controller architecture. ASP.net MVC this course offers an alternative to ASP.net web forms for building web applications. It is a part of the. Net platform for building, deploying and running web apps. This course will enable you the full control over the rendered HTML. Easy integration with JavaScript frameworks. Following the design of stateless nature of the web and RESTful URLs that enables SEO.

Course Objectives:

• Understand the benefits of MVC design over traditional ASP.NET Web Forms.
• Understand the about the role of Model, View and Controller in integrating them to develop a complete web application and Request life cycle.
• Understand how Routing API maps requests to action methods in the controller.
• Learn about the Razor Syntax Fundamentals, Layout View, Sections and Partial Views
• Learn how to reuse code rendering HTML using custom HTML Helper method
• Building Custom Model Binders for typical conditions in which built-in default binders are not usable.
• Understanding and applying validation framework for both client and server validations.
• Learn about the Architecture of Config File,App Settings, Exception Handling and Encrypting
• Connection String.
• Learn about the Sharing data across requests from same client/user using Cookies and Session management.
• Learn about the Output Caching and Data Caching.
• Access databases and performing CRUD operations using LINQ and Entity Framework.
• Learn about the Windows,Forms and Role-Based Authentication.
• Implementing ASP.NET Identities in ASP.NET MVC applications.
• Learn about the Mapping URL to Controller Action Method,Applying Constraints and Attribute Routing in MVC 5.
• Modularize using Areas.
• Learn about the Ajax Helper Methods, Jquery UI Controls and Jquery Templates.
• Compress the output using bundling and minification features. -Develop views which are mobile compatible.
• Develop Service Oriented RESTful services using Web API feature of ASP.NET MVC.
• Perform automated testing of Web applications created using ASP.NET MVC
• Build and deploy ASP.NET MVC application to the production server.

Pre-requisites:

• Basic knowledge of .Net Framework 3.5/4.5, C# Programming ,Entity Framework, Linq.

Target Audience:

• For beginners and professionals who want to learn ASP.NET MVC 5 step by step.
• Technical Team Leader
• Software Developer

Course Duration:

• 35 hours – 5 days

Course Content:

Introduction to Web Programming

You will learn about how the browser and Server gets communicating with each other, life cycle of HTTP, about the http protocol and also the importance of get and post methods.

• Communication between Web -Server and Web Browser
• HTTP Protocol
• HTTP Request Life Cycle
• Request and Response Structure
• About Get and Post methods

Overview of HMTL and JavaScript.

You will learn about the basics of Html, JavaScript language & the Document Object Model, Handling

Events in Javascript, Steps for Debugging Javascript, Performing Client side validations and Alter, show, hide and move objects on a web page.

• HTML Overview
• HTML Tags Reference
• HTML Examples
• Introduction to JavaScript
• JavaScript Examples
• Debugging JavaScript in VS.NET

Overview of Classic ASP

You will learn about the how html page is displayed on webserver,how asp page is rendered on the webserver, Asp objects, Installing IIS and ASP on Windows and Html form behavior.

• ASP Objects
• Understanding Form Tag
• Request and Response Model
• Sample Programs

Overview of ASP.NET WebForms

You will learn about the how to build the application using ASP.Net WebForms,ASP.Net

Architecture,ASP.Net WebForms Controls, Page events in page life cycle,Navigation and Masterpage.

• Creating an ASP.NET Website
• Using ASP.NET WebForm Controls
• NET Architecture
• Understanding Page Controller
• Architecture
• Navigating between Pages
• Overview of Master Pages

Introducing to ASP.NET MVC

You will learn about the major pieces of the Microsoft ASP.Net MVC Framework , Responsibilities of Model,View and Controller,benefits of MVC design over traditional ASP.NET Web Forms.

• What is MVC Architecture?
• What is ASP.NET MVC?
• Understanding Model
• Understanding View
• Understanding Controller
• Advantages of MVC based Web Application
• Features of ASP.NET MVC Framework

First MVC Application

You will learn about the MVC Folder Structure, how to create a new ASP.Net MVC project , Role of Model,View and Controller in integrating them to develop a complete web application and Request life cycle.

• Software Requirements
• Developing First MVC Applications
• Rendering HTML output
• Understanding Life Cycle of ASP.MVC Request

Exploring Controller’s

You will learn about the Passing data from controller to view,Action methods of Controller class,Action

Result object returns form action methods,Action filters and Asynchronous Controllers.

• Exploring Controllers and ControllerBase class
• Passing data from Controller to View using ViewData/ViewBag
• Types of Action Methods
• Action Method Parameters
• Action Selectors
• Action Filters Overview
• Authentication Filters in MVC 5
• Building Custom Action Filters
• Filter Override features.
• Asynchronous Controllers

Exploring Razor Views

You will learn about the Razor Syntax Fundamentals, Advantages of Razor syntax over traditional aspx markup syntax, Layout View , Implementing the Sections in view, Partial Views and Types of Views.

• Types of Views
• Introducing Razor View
• Razor Syntax Fundamentals
• Enum Support
• Layout view Razor (Master Pages)
• Significance of _ViewStart.cshtml
• Working with Sections
• Working with Partial Views
• Bootstrap support for editor templates

Digging into HTML Helpers

You will learn about what are Html helper methods,how to use them in razor syntax , how to use “For” methods with strongly typed models, overriding the Display and Editor templates and Building Custom

Helpers using Extension Methods

• HTML Helper Methods
• Render HTML Form
• Using DropDownList
• Binding Html Helper to Model
• Using “For” Methods with Typed Model
• Overriding Display Templates
• Overriding Editor Templates
• Custom Helper method

Understanding Model Binders

You will learn about the Default Model Binders and Building Custom Model Binders for typical conditions in which built-in default binders are not usable.

• Default model Binder
• Complex Type Model Binding
• FormCollection Model Binding
• Http Posted File Model Binding
• Bind Attribute

Annotations and Validations

You will learn about how to implement data annotation ,applying validation framework for both client and server validations, how to build custom validations and Developing Custom Unobtrusive Client Side

Validation

• Overview of Data Annotations
• Annotations and Validation Attributes
• How Validation Works
• Explicit server side validations of Models
• Custom Validations using IValidatableObject
• Developing Custom Unobtrusive Client Side Validation
• Applying Annotations to Model classes using Metadata class

Web Configuration File and Global Application Class

You will learn about the Architecture of Config File,App Settings, HttpApplication Class, Limitation of Exception handling, how to catch specific type of errors and how to Encrypting Connection String.

• Architecture of Config File
• config and Web.Config
• AppSettings
• web Section
• Exception Handling
• Location Section
• Encrypting ConnectiongString

State Management Techniques

You will learn about the Sharing data across requests by same client/user using Cookies and Session management.

• Cookies
• Managing Cookies in ASP.NET MVC Application
• Authentication in Cookies
• Cookie Dictionary
• Sessions Management
• Sharing data between clients using static class

Web Caching

You will learn about the Output Caching and Data Caching.

CRUD operations using Entity Framework

You will learn about the CRUD operations using LINQ and Entity Framework,Repository patterns, Generic Repository and Understanding about Depedency injection.

• Basic CRUD Operations using Scaffold Templates
• Separation of work using BO Classes
• Using Single Database Context Object across all Business Objects
• Writing Generic Class / Repository
• Caching in Repository
• Custom Controller Factory and Dependency Injection.

Authentication and Authorization

In this module, you will learn about the Types of Authentication, how to use Windows authentication, how to use Forms authentication, encrypting password in config file and Role-Based Authentication.

• Overview of Authentication and Authorization
• Types of Authentication
• [Authorize] and [AllowAnonymous] attributes
• Windows Authentication Implementation
• Forms Authentication Implementation
• Roles Based Security

ASP.NET Identities

You will learn about the Single Sign On using Facebook & Google,Two Factor Authentication, Email Confirmation and Role Management.

• NET Identity Introduction
• OWIN and Katana
• Customizing Template Generated Code
• Extending Identity Model and using Integer Key instead of String Key
• OAuth and Social Authentication
• Code MVC Application with Facebook, Twitter, LinkedIn and Google OAuth2 Sign-on
• Implementing Email Confirmation
• Two Factor Authentication
• User and Role Management

URL Routing

You will learn about the Mapping URL to Controller Action Method,Applying Constraints and Attribute Routing in MVC 5.

• Overview
• Mapping URL to Controller Action Method
• Applying Constraints on Route parameters
• Resolving Namespace Ambiguity Ignoring Routes
• Attribute Routing improvements in MVC 5

Working with Areas

You will learn about the concept of Areas,how to add an area for MVC project, Linking between areas.

• Understanding Areas
• Adding Areas
• Registering Areas
• Linking between Areas
• JQuery with Kendo Demo
• MVC and Kendo Data

Course Customization Options

To request a customized training for this course, please contact us to arrange.

In this 5-day course, the professional web developers will learn to develop advanced ASP.NET MVC application using .NET Framework 4.6 tools and technologies. The focus will be on coding activities that enhance the performance and scalability of the Web site application. This course will also prepare the student for exam 70-486.

Course Objectives:

• Describe the Microsoft Web Technologies stack and select an appropriate technology to use to develop any given application.
• Design the architecture and implementation of a web application that will meet a set of functional requirements, user interface requirements, and address business models.
• Create MVC Models and write code that implements business logic within Model methods, properties, and events.
• Add Controllers to an MVC Application to manage user interaction, update models, and select and return Views.
• Create Views in an MVC application that display and edit data and interact with Models and Controllers.
• Run unit tests and debugging tools against a web application in Visual Studio 2017.
• Develop a web application that uses the ASP.NET routing engine to present friendly URLs and a logical navigation hierarchy to users.
• Implement a consistent look and feel, including corporate branding, across an entire MVC web application.
• Use partial page updates and caching to reduce the network bandwidth used by an application and accelerate responses to user requests.
• Write JavaScript code that runs on the client-side and utilizes the jQuery script library to optimize the responsiveness of an MVC web application.
• Implement a complete membership system in an MVC 5 web application.
• Build an MVC application that resists malicious attacks and persists information about users and preferences.
• Describe how to write a Windows Azure web service and call it from and MVC application.
• Describe what a Web API is and why developers might add a Web API to an application.
• Modify the way browser requests are handled by an MVC application.
• Describe how to package and deploy an ASP.NET MVC 5 web application from a development computer to a web server for staging or production.

Pre-requisites:

• Experience in developing applications by using Visual Studio 2012.
• Experience in developing ASP.NET MVC 5 web applications.
• Experience in developing ASP.NET Web Forms and Web Pages applications
• Experience in developing applications using the Visual C# language.
• Experience in developing web sites that use the JavaScript language.
• Experience in using the jQuery JavaScript library.
• Experience in using Windows Azure to host web sites, services, and databases.

Target Audience:

This course is intended for professional web developers who use Microsoft Visual Studio in an individualbased or team-based, small-sized to large development environment. Candidates for this course areinterested in developing advanced web applications and want to manage the rendered HTML comprehensively. They want to create websites that separate the user interface, data access, and application logic.

Course Duration:

• 35 hours – 5 days

Course Content:

• Exploring ASP.NET MVC 5
• Designing ASP.NET MVC 5 Web Applications
• Developing ASP.NET MVC 5 Models
• Developing ASP.NET MVC 5 Controllers
• Developing ASP.NET MVC 5 Views
• Testing and Debugging ASP.NET MVC 5 Web Applications
• Structuring ASP.NET MVC 5 Web Applications
• Applying Styles to ASP.NET MVC 5 Web Applications
• Building Responsive Pages in ASP.NET MVC 5 Web Applications
• Using JavaScript and jQuery for Responsive MVC 5 Web Applications
• Controlling Access to ASP.NET MVC 5 Web Applications
• Building a Resilient ASP.NET MVC 5 Web Application

This workshop teaches the participants how to design and develop server side applications using the event-driven, non-blocking model framework Node.js. This program inducts the participant in some of the advanced concepts of the JavaScript language so that the participant is well equipped to build end-to-end application using JavaScript.

Course Objectives:

• Understand the non-blocking nature of Node.js
• Writing asynchronous code with call-backs and streams
• Learn how to modularize code using NPM and require()
• Understand and take advantage of the built-in apis for building scalable few applications
• Learn how to build web applications using Express.js
• Understand how to handle authentication and authorization
• Learn how to build real-time applications using WebSockets and socket.io

Pre-requisites:

• Experience in application development in any programming language
• Basic knowledge of the JavaScript language
• Exposure to any server technology (J2EE, .NET, Ruby etc)

Target Audience:

• Web developer who wants to build data intensive scalable applications using Node.js

Course Duration:

• 21 hours – 3 days

Course Content:

Day 1

JavaScript

Introduction oLanguage Overview 

• Data Types oProgramming constructs
• Handling Exceptions
• Objects, Functions & Arrays
• Timer Functions

Expressive JavaScript 

• The Flexibility of JavaScript
• JavaScript as a Loosely Typed Language
• Functions as First-Class Objects
• Object Mutability

Functions In Depth 

• Function Objects
• Function Literal
• Function Invocation Patterns
• Augmenting Types
• Recursion & Closures
• Functions as Callbacks
• Function Currying & Memorization

Closures In Depth 

• How Closures Work
• Private Variables, Callbacks and Timers
• Binding Function Contexts
• Overriding Function Behavior

Object Orientation With Prototypes 

• Object Instantiation
• Constructors
• Inheritance and Prototype Chain
• Extending Object
• Extending Number
• Instantiation Issues
• Writing class-like code ES6

New in ES6 oClasses olet and const

• Arrow functions
• Enhanced Object Literals
• Destructuring
• Spread Operator
• Generators and Iterators
• Symbols
• Comprehensions
• Async Programming using Promises

Using Babel.js 

Day 2 – 3

NODE.JS

Introduction to Node.js

• Installing Node.js
• Node’s Event Loop
• Alternatives to Node.js
• Writing asynchronous code

Modularizing code

• Understanding built-in modules
• Techniques for modularizing JavaScript code
• Using require() to modularize application code
• Using npm for third-party modules oHandling Exceptions

Events and Streams 

• Understanding Events
• EventEmitter class
• Understanding Streams
• Reading and writing streams
• Using pipe()

Accessing Local Resources

• Process Object
• Manipulating File System
• Understanding Buffers

Node.js and the web

• Handling web requests
• Building a web server
• Understanding the need for web sockets
• Realtime interaction using socket.io

Building web applications using Express.js 

• Installing Express.js
• Routing
• Parameters and queries in routing
• Building views using view engine of choice (ejs / jade / handlebars
• Using blocks for layout ODisplaying data
• Working with forms
• Serving files
• Working with cookies and sessions
• Authentication and authorization
• Error Handling

 NodeJs Addons using C++ 

• Overview of N-API
• Using node-gyp and node-addon-api
• Configuring application
• Building and using C++ Api in Node.js

Scaling Node applications 

• The Child process model
• Exec, spawn, and fork functions
• Using the Cluster module

Node.js Eco System 

• Node Packages
• Packages of interest
• Deciding Factors

Debugging Node Applications

• Summary and Closing Remarks

Course Customization Options

To request a customized training for this course, please contact us to arrange.

This workshop aims at equipping the participants with the necessary knowledge and skills required to build rich internet applications using cutting edge RIA framework from google “Angular”.

Course Objectives:

• Be able build RIA using Angular
• Be able to write front end applications using typescript
• Exploit two-way binding offered by Angular
• Use dependency injection for better maintainability
• Understand and use various directives offered by Angular
• Create custom components
• Use gulp for commonly performed tasks in JavaScript application development

Pre-requisites:

• Should be familiar with any one web development technologies
• Should have intermediate level exposure in JavaScript

Target Audience:

• Web Developer who wants to build best-of-breed web applications with the simplicity and elegance of JavaScript.

Course Duration:

• 35 hours – 5 days

Course Content:

TypeScript

• Building Blocks
  • Modules
  • Interfaces
  • Class
  • Functions
  • Enum

• Types
  • Static, Dynamic & Optional Types
  • Inferred Types
  • Builtin Types
  • Custom Types
  • Type Declaration
  • Type Inference

• Abstractions
  • Defining Interfaces
  • Creating Interface Methods

• Class
  • Private and Public Scope
  • Defining Members
  • Static Functions
  • Default and Optional Parameters
  • Overloading functions
  • Constructors
  • Implementing Interfaces
  • Inheritance and Polymorphism

Angular

• Introduction to Angular
  • How Angular is opinionated
  • Difference between Angular 1.0 Angular 2.0 and above (Optional)

• Angular Building Blocks
  • Module
  • Component
  • Template
  • Metadata
  • Data Binding
  • Service
  • Directive
  • Dependency Injection

• Anatomy of an Angular Applications
  • Assembling applications using Modules
  • Identifying UI layers for Components
  • Metadata for Components

• Testing
  • Jasmine Overview
  • Writing Tests in Typescript
  • Configure Karma to execute Tests
• Components & Templates
  • Interpolation
  • Expressions and Statements
  • Bindings
  • Value Binding
  • Property Binding
  • Event Binding
  • Two way Binding
  • Component Life Cycle
  • Testing Components
• Directives
  • Attribute Directives
  • Structural Directives
  • Using the Template Tag
  • Using the “*” in directives
  • Creating Components
  • Extending Directives
  • Creating Custom Directives
  • Updating DOM Nodes
  • Handling DOM Events

• Pipes
  • Role of pipes in Angular 2 applications
  • Using builtin pipes
  • Chaining Pipes
  • Creating Custom Pipes
  • Testing Direvtives

• Dependency Injection
  • Configuring the Injector
  • Importing & Exporting Components
  • Importing & Exporting Services
  • Registering Providers
  • Class Providers and Value Providers
  • Factory Providers

• Forms
  • Building forms using components and Templates
  • Two way binding
  • Change Tracking using ngControl
  • Validation
  • Error Handling
  • Testing Angular Forms

• Routing and Navigation
  • Including the Router
  • Configuring the routes
  • Router Outlets and Links
  • Nested Routes
  • Accessing Route Params
  • Lazy loading of Modules and Components

• Communicating with Servers
  • Using the http provider
  • Async Programming Using Promises
  • Resolving and Rejecting Promises
  • Configuring the requests
  • Sending Http Headers
  • Caching Responses
  • Request and Response Transformation
  • Using RESTful Resources
  • Using RxJS Objservables

• RxJs
  • Streams as data source
  • Difference between Iterators and Observables
  • Using RxJs for observable manipulation
  • Sequences
  • Using sequence operators such as map(), filter(), concatAll(), reduce(), zip()
  • Handling Errors

• Authentication & Authorization
  • Authentication Using JWT
  • Using Route Guards
    • CanActivate
    • CanActivateChild
    • CanDeactivate
    • CanLoad

• JWT Http Interceptors
• Authorization Workflow
• Role-based Authorization
• State Management (ngRx)
  • State Management Strategies
  • Redux as a state management solution
  • Store Vs Services
  • Application Store
  • Reducers
  • Actions
  • Dispatching Actions
  • Action Creators
  • Using ngRx
  • Handling Errors

• Realtime Updates using WebSockets
  • Need for bidirectional realtime communication
  • WebSockets overview
  • Using WebSockets in Angular
  • Subscribing and Publishing websocket events using RxJs

• Build Automation
  • Using Webpack
  • Module Bundling using Webpack
  • Using Ahead Of Time compilation (AOT)
  • Summary and Closing Remarks

Course Customization Options

To request a customized training for this course, please contact us to arrange.

This workshop is aimed at imparting the required knowledge required to build Rich Internet Applications (RIA) using React.js.

Course Objectives:

• Understand what React.js is and what problem it solves
• Explore the basic architecture of a React.js application
• Gain a deep knowledge of React.js components and JSX
• Build a working application that uses React.JS components
• Learn React.js best practices
• Compose an application using Flux architecture
• Know how to maintain application state in a Redux Store
• Know how to do module bundling using webpack
• Use React dev tools

Pre-requisites:

• Web development experience with advanced level of expertise in JavaScript.
• Must be familiar with ES6
• Exposure to any server technology (J2EE, .NET, Ruby etc)

Target Audience:

Web developer who wants to build best-of-breed web UIs with the simplicity and elegance of JavaScript.

Course Duration:

• 28 hours – 4 days

Course Content:

RIA/SPA Basics

• Classic Web applications vs Rich Internet applications
• Challenges in building Client centric applications
• Benefits of RIA Frameworks
• Where React.js fits in?

Building UI using React.js

• Introduction
  • Need for React.js
  • Advantages of Virtual DOM

• View Components using JSX
  • JSX Syntax
  • Using JSX to create view classes
  • Creating views without using JSX

• Models
  • Advantages of Immutability

• Components
  • Component Lifecycle
  • Virtual DOM
  • Component Events
  • Using States and Properties
  • Initializing States from properties
  • Accessing DOM nodes using refs
  • Synthetic Events
  • Component Compositions
  • Communication Between Components
  • Reusable Components

• Forms
  • Controlled Components
  • Uncontrolled Components

• Unit Testing React.js Components
• js Best Practices

Flux Architecture and Redux

• Introduction
  • Overview of Reactive programming
  • Benefits of Unidirectional data flow

• Architecture
  • Building blocks in Flux
  • Dispatcher
  • Stores
  • Action
  • Views

• Dispatcher
  • The role of dispatcher
  • Registering callbacks
  • Triggering Actions

• Store
  • The role of Store
  • Maintain Application State
  • Event Broadcasting

• Reducer
  • Creating Reducers
  • Retrieving State
  • Combining Reducers

• Action Creator
  • Creating Actions
  • Dispatching actions to the dispatcher
  • Using Middlewares
  • Dispatching Async Actions using Thunk middleware

• Views
  • React Components as Views
  • State Subscribers
  • Updating data from the store

• React-Redux Bindings
  • Binding Components to React Store using “Connect”
  • Injecting Redux Store using Provider
  • Using Providers with React Routers

• Testing
  • Overview of Mocha & expect (chai.js)
  • Organizing Unit tests using Mocha
  • before & after setup
  • Performing assertions using expect
  • Using Karma.js
  • Using Jest for mocking dependencies
  • Testing React components
  • Testing Stores
  • Summary and Closing Remarks

Course Customization Options

To request a customized training for this course, please contact us to arrange.