Web Development


Course Information

We, in collaboration with nTier Training, offer Web Development training courses for new programmers as well as experienced developers in EmberJS, HTML5, jQuery, Angular, Backbone, Java Script and Ruby.

If the courses detailed below do not meet your or your organisation’s specific requirements, contact us for a customised training solution.

Ember.JS

The Ember.js course teaches participants how to use Ember to build model-view-controller applications that run in a client browser. We teach experienced HTML and JavaScript developers about the benefits of the MVC pattern in interactive applications, and how to design and structure web applications using the Ember framework in the client environment.

 

Prerequisites:

Attendees must have a solid working knowledge of HTML, CSS and JavaScript, or the scope of this course may be expanded to include that. Familiarity with using JavaScript for server side communication with AJAX (Asynchronous JavaScript and XML) is a plus.

 

Hardware and Software Requirements:

  • An integrated development environment or text editor with support for highlighting/correcting JavaScript syntax
  • The current versions of Google Chrome, Firefox with Firebug, or Internet Explorer (9 or later) are the preferred web browsers
  • Internet access for all attendees and the instructor

 

Course Objectives:

  • Explore the advantages of offloading application code to the client
  • Understand and utilize the model-view-controller pattern
  • Leverage advanced concepts and syntax in JavaScript
  • Integrate advanced collection handling the model code
  • Ember handlebar syntax for dynamically injecting data and code elements into an HTML document

 

Course Outline:

  • Introducing Ember.js
    •  The Model-View-Controller Pattern and Ember.js
    • Models
    • Controllers
    • Views
    • Handlebars

 

  • Refresh
    • Functions and Scope
    • Closures
    • Prototypes
    • jQuery

 

  • Building a View
    • Overview of Page Architecture
    • Interactivity as Defined in The View

 

  • Key Features of Ember.js
    • Bindings
    • Computed Properties
    • Auto-Updating Templates

 

  • Additional Features
    • Getters and Setters
    • Observers
    • Changes in Arrays
    • Control Flow

 

  • Building a Complete Application
    • Step 1: Top-Level Container Views
    • Step 2: Schema and Models
    • Step 3: Adding Interactivity to The Views
    • Step 4: Modals as Views
    • Step 5: Adding Controllers
    • Step 6: Using Routing

 

  • Testing an Ember.js App
    • Unit Tests
    • Unit Testing JavaScript Applications QUnit

HTML5

Our HTML5 training class, intended for experienced HTML developers with some JavaScript experience, teaches the new features of HTML5 and how to put them to immediate use.

 

Course Duration: 2 days

 

Prerequisites:

All attendees must be fluent in HTML 4 and have practical experience with the basics of CSS and JavaScript. Prior knowledge of JSON, DOM, and Ajax is helpful but not required.

 

Course Objectives:

  • Build HTML5 pages
  • Understand the major benefits of HTML5
  • Understand the difference between HTML5 and HTML 4
  • Use the new elements and attributes of HTML5
  • Work with audio and video in HTML5
  • Work with new Canvas element to create code-based drawings in HTML5
  • Use web storage for offline applications
  • Use all of the new HTML5 form elements
  • Understand the current state of browser support for HTML5 and how to make your HTML5 sites degrade gracefully

 

Course Outline:

  •  Introduction

 

  • Laying Out a Page with HTML5
    • Page Structure
    • New HTML5 Structural Tags
    • Page Simplification

 

  • HTML5 – How We Got Here
    • The Problems HTML 4 Addresses
    • The Problems XHTML Addresses
    • The Flexible Approach of HTML5 – Paving the Cowpaths
    • New Features of HTML5
    • The HTML5 Spec(s)
    • Current State of Browser Support

 

  • Sections and Articles
    • The Section Tag
    • The Article Tag
    • Outlining
    • Accessibility

 

  • HTML5 Audio and Video
    • Supported Media Types
    • The Audio Element
      • Audio Format
      • Multiple Sources
      • Audio Tag Attributes
      • Getting and Creating Audio Files
    • The Video Element
      • Video Tag Attributes
      • Creating and Converting Video Files
    • Accessibility
    • Scripting Media Elements
    • Dealing with Non-Supporting Browsers

 

  • HTML5 Forms
    • Modernizr
    • New Input Types
      • Search
      • Tel
      • URL and Email
      • Date/Time Input Types
      • Number
      • Range
      • Min, Max and Step Attributes
      • Color

 

  • HTML5 New Form Attributes
    • Autocomplete
    • Novalidate

 

  • HTML5 New Form Field Attributes
    • Required
    • Placeholder
    • Autofocus
    • Autocomplete
    • Form
    • Pattern

 

  • New Form Elements
    • Datalist
    • Progress and Meter

 

  • HTML5 Web Storage
    • Overview of HTML5 Web Storage
    • Web Storage
      • Browser Support
      • Local Storage
      • Session Storage
      • Prefixing Your Keys
    • Other Storage Methods
      • Web Database Storage
      • Indexed Database API

 

  • HTML5 Canvas
    • Getting Started with Canvas
    • Drawing Lines
      • Multiple Sub-Paths
      • The Path Drawing Process
      • The fill() Method
    • Color and Transparency
    • Rectangles
    • Circles and Arcs
    • Quadratic and Bezier Curves
    • Images
      • drawImage() – Basic
      • drawImage() – Sprites
    • Text

 

  • Integrated APIs
    • Offline Application API
      • Cache Manifest File
      • The HTML File
      • Managing ApplicationCache with JavaScript
      • A Sample Application
    • Drag and Drop API

 

  • Conclusion

jQuery

This course teaches participants to apply the benefits of the jQuery library to their applications. At the conclusion of this class, students will know how to embellish content using jQuery’s DOM modification methods. This course will emphasize the simplicity of HTML and the dynamic decoration of those components using jQuery. Participants will also learn to send and retrieve information with AJAX methods.

 

Audience: This course is designed for developers.

 

Course Duration: 3 days

 

Prerequisites:

Web development experience with JavaScript is required.

 

Course Objectives:

  • Change page on command with DOM manipulation
  • Use AJAX to get the most out of server-side code
  • Build and control HTML tables dynamically

 

Course Outline:

  • Getting Started
    • What jQuery Does
    • History of the jQuery project
    • Downloading jQuery
    • Adding jQuery
    • Executing the Code
    • Why jQuery Works Well
    • Our First jQuery-Powered Web Page
    • Setting Up the HTML Document
    • Injecting the New Class

 

  • Selectors
    • The Document Object Model
    • CSS Selectors
    • Attribute Selectors
    • Custom Selectors
    • Form Selectors
    • Styling Specific Cells
    • Accessing Dom Elements
    • The $() Factory Function
    • Styling List-Item Levels
    • Styling Links
    • Styling Alternate Rows
    • DOM Traversal Methods
    • Chaining

 

  • Events
    • Performing Tasks On Page Load
    • Multiple Scripts On One Page
    • Coexisting with Other Libraries
    • Event Handler Context
    • Shorthand Events
    • Event Bubbling
    • Altering The Bubble Process
    • Stopping Event Propagation
    • Event Delegation
    • Event Namespacing
    • Simulating User Interaction
    • Timing of Code Execution
    • Shortcuts for Code Brevity
    • Simple Events
    • Further Consolidation
    • Compound Events
    • Side Effects of Event Bubbling
    • Event Targets
    • Default Actions
    • Removing an Event Handler
    • Rebinding Events
    • Keyboard Events

 

  • Effects
    • Inline CSS Modification
    • Effects and Speed
    • Fading In and Fading Out
    • Creating Custom Animations
    • Animating Multiple Properties
    • Callbacks
    • Basic Hide and Show
    • Speeding In
    • Compound Effects
    • Toggling The Fade
    • Positioning with CSS

 

  • DOM Manipulation
    • Manipulating Attributes
    • The $() Factory Function Revisited
    • Moving Elements
    • Clone with Events
    • A CSS Diversion
    • Non-Class Attributes
    • Inserting New Elements
    • Marking, Numbering and Linking the Context
    • Copying Elements
    • Cloning for Pull Quotes

 

  • Table Manipulation
    • Loading Data On Demand
    • Working with JavaScript Objects
    • Global jQuery Functions
    • Loading an XML Document
    • Passing Data to The Server
    • Performing a POST Request
    • Security Limitations
    • Additional Options
    • Appending HTML
    • Retrieving a JavaScript Object
    • Executing a Script
    • Choosing a Data Format
    • Performing a GET Request
    • AJAX and Events
    • Using JSON for Remote Data
    • The Low-Level AJAX Method

 

  • jQuery Forms
    • Sorting and Paging
    • Preventing Page Refreshes
    • Row Grouping Tags
    • Column Highlighting
    • Server-Side Pagination
    • JavaScript Pagination
    • Modifying Table Appearance
    • Row Striping
    • Interactive Row Highlighting

 

  • Filtering
    • Reversing the Filters
    • Server-Side Sorting
    • JavaScript Sorting
    • Alternating Sort Directions
    • Sorting and Paging Go Together
    • Row Highlighting
    • Advanced Row Striping
    • Tooltips
    • Filter Options
    • Interacting with Other Code

 

  • Shufflers and Rotators
    • Forms and JavaScript
    • Conditionally Displayed Fields
    • Required Fields
    • Checkbox Manipulation
    • Placeholder Text for Fields
    • Keyboard Navigation
    • Rejecting Non-Numeric Input
    • Parsing and Formatting Currency
    • Other Calculations
    • Form Validation
    • Required Formats
    • Compact Forms
    • AJAX Auto-Completion
    • Working with Numeric Form Data
    • Numeric Calculations
    • Dealing with Decimal Places
    • Rounding Values

 

  • Using Plugins
    • Page Rotators
    • The Headline Rotate Function
    • Retrieving A Feed from A Different Domain
    • Gradient Fade Effect
    • Setting Up the Page
    • Shuffling Images When Clicked
    • Image Enlargement
    • Displaying A Close Button
    • Adding A Loading Indicator
    • Setting Up the Rotator
    • Pause On Hover
    • Adding A Loading Indicator
    • An Image Carousel
    • Revising The Styles with JavaScript
    • Adding Sliding Animation
    • Hiding The Enlarged Cover
    • More Fun with Badging
    • Deleting Items
    • Required Field Messages

 

  • Developing Plugins
    • jQuery Plugins Introduction
    • The Form Plugin
    • Effects
    • Class Animations
    • Additional Effects
    • Widgets
    • Other Recommended Plugins
    • Tables Plugins
    • Charting Plugins
    • How to Use a Plugin
    • The jQuery UI Plugin Library
    • Color Animations
    • Advanced Easing
    • Interaction Components
    • jQuery UI ThemeRoller
    • Forms Plugins
    • Images Plugins

Angular

This course explores using the Angular model-view-controller framework to develop robust client-side applications that work in web browsers. Angular adds a structured framework that binds model data to DOM elements without the need for to program the interaction. This course uses a progressive approach to quickly introduce how Angular binds JavaScript data and functions to HTML, how the digest cycle is used to update the DOM and trigger JavaScript methods bidirectionally, building services to implement business processes, defining routes for single-page applications, creating custom directives to simplify presentations, and communicating with web services to get and put data.

Unit testing is stressed early in the course and used throughout the labs. End-to-end integration testing explores testing the components together and driving tests through the user interface. The progressive, layered approach provides a rock-solid foundation in how to build Angular applications in a short time frame.

 

Course Duration: 3 days

 

Prerequisites:

Before taking the course students should have the following:

  • Familiarity with HTML5 and CSS3
  • Experience with client-side JavaScript programming, including using closures and prototypes
  • Object-oriented programming and Node.js experience is a plus

 

Hardware and Software Requirements:

  • Administrative privileges on the computer used in class
  • Internet connectivity
    • Node.js and bower modules will be installed from their respective repositories on the Internet and any firewalls or restrictions on browsing must allow access
  • An IDE designed for client-side development
    • WebStorm, Komodo and Brackets are Excellent Candidates
  • The Chrome web browser
  • Node.js and Git

 

Course Outline:

  • Foundations
    • Web Application Foundations
    • Angular
    • Modules

 

  • Directives and Expressions
    • Angular and HTML
    • Compilation
    • Model Data
    • Data Binding

 

  • Node.js
    • Node Library Overview
    • Node Package Manager
    • Running Node Applications
    • Node in the IDE
    • A Node Web Server

 

  • Models and Controllers
    • Defining the Application
    • Defining a Controller
    • Initializing Model Data
    • Declaring Actions and Linking to Them

 

  • Unit Tests
    • Testing Paradigms
    • Building Jasmine Unit Tests
    • Testing Controller Logic
    • Focusing on Edge-Cases

 

  • Services, Collections and Filters
    • Services
    • Injecting Services into Controllers
    • Using Collections in $scope
    • Iterating Over Collections in HTML
    • Collections of Objects
    • Filtering Collections
    • Defining Filters with Models
    •  Defining Filters Using Functions
    • Constant and Global Values

 

  • Scope, Routing and Templates
    • Defining Scopes
    • Nested and Isolate Scopes
    • Adding Observers in The Application
    • The Digest Cycle
    • The Single-Page-Application and Routing
    • Defining Routes
    • Integrating Templates

 

  • End-to-End Testing
    • Integration Testing
    • Driving the User Interface

 

  • Server Communication with AJAX
    • Promises in JavaScript
    • Communicating with $Http and $Resource
    • Angular in A Model-View-View Model (MVVM) World

 

  • Directives
    • Directive Conventions
    • Defining Custom Directives

 

  • Scaffolding
    • Angular-Seed, Angular-Enterprise-Seed, Angular-Sprout
    • Creating A Scaffold with Yeoman

 

Introduction to Angular 2

Course Outline:

  • Introduction
    • What is Angular 2?
    • Angular 1 vs Angular 2 comparison
    • Installing and using Angular 2
    • Basic Angular 2 application demonstration
    • Anatomy of Angular 2 application – application file, component file, main directives, etc.

 

  • Introduction to TypeScript and ES6
    • Overview of languages applicable to Angular 2
    • TypeScript syntax
    • Typing – defining variables
    • Typing – defining arrays
    • Typing – classes and objects
    • Interfaces
    • Working with modules
    • TypeScript transpilation techniques
    • Introduction to template strings

 

  • Angular 2 Components
    • What is a component?
    • Component starter
    • Developing a simple to-do list component

 

  • Data and Event Binding
    • Binding syntax
    • Two-way binding of input fields
    • Binding events
    • Combining data binding with events

 

  • Attribute Directives
    • Introduction to directives
    • Directive types
    • Applying styles based on directives
    • Controlling element visibility
    • Setting image source dynamically
    • ngFor – using with templates and creating tables
    • ngSwitch – swapping out view elements

 

  • Template-Driven Forms
    • Preventing default with form submission
    • Field data validation
    • Binding to object variables

 

  • Service and Dependency Injection
    • How to create a basic service
    • Service injection
    • Dependency injection basics
    • Sharing services

 

  • HTTP
    • Basic GET, POST, PUT, DELETE request overview
    • Wrapping HTTP calls into services
    • Using promises to implement HTTP calls

 

  • Application Architecture
    • Using services to create stateless functionality
    • Component best practices
    • Angular 2 production considerations

Introduction to Backbone.JS

Course Duration: 3 days

 

Hardware and Software Requirements:

  • An IDE/editor of Your Choice with Strong JavaScript Support
  • Google Chrome or Firefox with Firebug
    • http://getfirebug.com
  • Internet Access for All Attendees and Our Instructor

 

Course Objectives:

  • Build a responsive client-side web application with Backbone.js
  • Set up an application from start to finish
  • Display information with views
  • Update server-side data with forms
  • Change views with a router
  • Extract common code components
  • Improve application performance

 

Course Outline:

  • Introduction

 

  • Concepts: Model-View-Controller
    • What is Model-View-Controller?
    • How Does Backbone.js Fit into this Model?
    • What About the Back-End?

 

  • Basic Backbone
    • A Very Simple Model
    • Retrieving Our Simple Model
    • Saving Our Simple Model

 

  • Event Handling
    • Capturing Events
    • Abandoning Events
    • Triggering Events

 

  • The Model In-Depth
    • Building a Model with extend()
    • Getters and Setters
    • Constructors and Defaults
    • Managing Changes
    • Validation

 

  • Collections: Multiple Models
    • Overview of the Collections API
    • Creating Your Own Collection
    • Adding and Removing Elements
    • Comparing and Sorting Elements
    • Filtering Collections
    • Data Manipulation as A Batch Operation

 

  • Manipulating Collections with Underscore.js
    • Iteration Functions (forEach, map, filter)
    • Accessors: Last, First
    • Searching: Contains/Include, etc.
    • Aggregation Functions: Max, Min, etc.

 

  • Display Information with Views
    • Display a Model
    • Display Aggregated (Reduced) Data
    • Display Aggregated (Reduced) Data

 

  • Backbone.sync: How to Talk to A Server
    • The RESTful Model of CRUD Interaction
    • Standard Syncing Over REST
    • Alternatives for Non-RESTful Applications

 

  • Update Server-Side Data with Forms
    • Display Forms
    • Perform Client-Side Form Validation
    • Submit A Form to Update an Object

 

  • Change Views with a Router
    • Start on A Main Route
    • Create Links to Display Different Views
    • Animate Changes
    • Tracking History

 

  • Advanced Topics and Techniques
    • Create an Automatically Updating View
    • Extracting Common Code to Libraries

 

  • Improve Performance
    • Preparations
    • Update Data with A Changes Feed
    • Make Requests Over a Websocket
    • Organize with Pagination

 

  • Conclusion

Backbone.JS

Our Backbone.js course teaches participants how to use Backbone to build model-view-controller applications that run in a client browser. We teach experienced HTML and JavaScript developers about the benefits of the MVC pattern in interactive applications as well as how to design and structure web applications using the Backbone.js framework in the client environment.

 

Prerequisites:

Attendees must have a solid working knowledge of HTML, CSS and JavaScript, or the scope of this course may be expanded to provide that. Familiarity with using JavaScript for server side communication with AJAX (Asynchronous JavaScript and XML) is a plus.

 

Hardware and Software Requirements:

  • An integrated development environment or text editor with support for highlighting/correcting JavaScript syntax
  • The current versions of Google Chrome, Firefox with Firebug, or Internet Explorer (9 or later) are the preferred web browsers
  • Internet access for all attendees and the instructor

 

Course Objectives:

  • Explore the advantages of offloading application code to the client
  • Understand and utilize the model-view-controller pattern
  • Leverage advanced concepts and syntax in JavaScript
  • Integrate advanced collection handling the model code

 

Course Outline:

  • Introduction

 

  • Concepts: Model-View-Controller
    • What is Model-View-Controller?
    • How Does Backbone.js Fit into this Model?
    • What About the Back-End?

 

  • Basic Backbone
    • A Very Simple Model
    • Retrieving Our Simple Model
    • Saving Our Simple Model

 

  • Event Handling
    • Capturing Events
    • Abandoning Events
    • Triggering Events

 

  • The Model In-Depth
    • Building A Model with extend()
    • Getters and Setters
    • Constructors and Defaults
    • Managing Changes
    • Validation

 

  • Collections: Multiple Models
    • Overview of The Collections API
    • Creating Your Own Collection
    • Adding and Removing Elements
    • Comparing and Sorting Elements
    • Filtering Collections
    • Data Manipulation as A Batch Operation

 

  • Manipulating Collections with Underscore.js
    • Iteration Functions (forEach, map, filter)
    • Accessors: last, first
    • Searching: contains/include, etc.
    • Aggregation Functions: max, min, etc.

 

  • Display Information with Views
    • Display a Model
    • Display a Collection
    • Display Aggregated (Reduced) Data

 

  • Backbone.sync: How to Talk to A Server
    • The RESTful Model of CRUD Interaction
    • Standard Syncing Over REST
    • Alternatives for non-RESTful Applications

 

  • Update Server-Side Data with Forms
    • Display Forms
    • Perform Client-Side Form Validation
    • Submit A Form to Update an Object

 

  • Change Views with A Router
    • Start On a Main Route
    • Create Links to Display Different Views
    • Animate Changes
    • Tracking History

 

  • Advanced Topics and Techniques
    • Create an Automatically Updating View
    • Extracting Common Code to Libraries

 

  • Improve Performance
    • Preparations
    • Update Data with A Changes Feed
    • Make Requests Over a Websocket
    • Organize with Pagination

• Conclusion

JavaScript

Our JavaScript Training Course teaches JavaScript using a unique, classroom-tested learning path that contains hundreds of small, easy-to-understand examples to demonstrate the full range of JavaScript’s power. One step at a time, this course guides new JavaScript programmers through every essential technique, from script setup to advanced DOM and CSS programming.

 

Course Duration: 2 days

 

Prerequisites:

There are no required prerequisites, but knowledge of HTML is helpful.

 

Course Objectives:

  • Data types, literals and variables
  • Operators, control structures and functions
  • Building dialog boxes and working with JavaScript objects using the Browser object
  • Navigator, windows frames dynamic images and links
  • Event handling, regular expressions and form validation
  • The JavaScript Document Object Model (DOM), Cascading Style Sheets (CSS) and Dynamic HTML

 

Course Outline:

  • Introduction to JavaScript
  • What JavaScript Is and What JavaScript Is Not
  • What JavaScript Is Used For
  • JavaScript and Events
  • What Versions? What Browsers?
  • Where to Put JavaScript
  • JavaScript and Old or Disabled Browsers
  • JavaScript from External Files
  • Script Setup
  • The HTML Document and JavaScript
  • Generating HTML and Printing Output
  • About Debugging
  • The Building Blocks: Data Types, Literals, and Variables
  • Variables
  • Bugs to Watch For
  • Exercises
  • Dialog Boxes
  • Interacting with the User Exercises
  • Operators
  • About JavaScript Operators and Expressions
  • Types of Operators Number, String, or Boolean?
  • Datatype Conversion
  • Special Operators
  • Control Structures, Blocks, and Compound Statements
  • Conditionals
  • Loops
  • Functions
  • What Is a Function?
  • Debugging
  • Objects
  • What Are Objects?
  • User-Defined Objects
  • Manipulating Objects
  • JavaScript Core Objects
  • What Are Core Objects?
  • Array Objects
  • Array Properties and Methods
  • The Date Object
  • The Math Object
  • What Is a Wrapper Object?
  • The Browser Objects: Navigator, Windows, and Frames
  • JavaScript and the Browser Object Model
  • The Document Objects: Forms, Images, and Links
  • The Document Object Model
  • Introduction to Forms
  • Introduction to Images
  • Introduction to Links
  • Handling Events
  • Introduction to Event Handlers
  • Event Handlers as JavaScript Methods
  • Handling a Window or Frame Event
  • Handling Mouse Events
  • Handling Link Events
  • Handling a Form Event
  • Handling Key Events: onKeyPress, onKeyDown, and onKeyUp
  • Handling Error Events
  • The event Object
  • Regular Expressions and Pattern Matching
  • What Is a Regular Expression?
  • Creating a Regular Expression
  • Getting Control–The Metacharacters
  • Form Validation with Regular Expressions
  • Cookies
  • What Are Cookies?
  • Creating a Cookie with JavaScript
  • Dynamic HTML: Style Sheets, the DOM, and JavaScript
  • What Is Dynamic HTML?
  • What Is a Style Sheet?
  • Types of Style Sheets
  • Where Does JavaScript Fit In?
  • JavaScript Web Resources
  • HTML Documents: A Basic Introduction
  • Intro to the Intro
  • What Is HTML? HTML Tags
  • The Minimal HTML Document
  • Character Formatting
  • Linking
  • Adding Comments
  • Case Sensitivity
  • Graphics and Images
  • Troubleshooting
  • Metatags, Cascading Style Sheets, and Java
  • Looking Behind the Scenes, or; What Did We Do Before the Right-Click?
  • What About Frames?
  • CGI and Perl: They Hyper Dynamic Duo
  • What Is CGI?
  • Internet Communication Between Client and Server
  • Creating a Web Page with HTML
  • How HTML and CGI Work Together
  • Log Files
  • Where to Find CGI Applications
  • Getting Information Into and Out of the CGI Script
  • Processing Forms with CGI
  • The CGIpm Module

Advanced JavaScript

The Advanced JavaScript course covers programming with the JavaScript language, building web pages that interact with server-side resources and accelerating development with popular application frameworks. Participants will learn how to use JavaScript and related debugging tools within a browser context as well as how to use the web page as a dynamic user interface. This course also covers how to interact with web services to perform business operations and communicate results to a user and how to leverage existing JavaScript frameworks to easily add advanced capabilities to their apps while keeping them cross-platform and cross-browser compatible.

 

Audience: This course is intended for web designers and developers who wish to learn how to create rich web user experiences using the client-side capabilities of JavaScript.

 

Course Duration: 3 days

 

Prerequisites:

To benefit from this course, participants should have experience developing with JavaScript and must be familiar with core programming constructs in any language, including branching, looping, variables and functions. Participants should also be familiar with HTML, the basics of HTTP and the DOM. Experience with interactive debugging and more advanced aspects of programming and TCP/IP networking is helpful but not necessary.

 

Course Objectives:

  • Data types, literals and variables
  • Operators, control structures and functions
  • Building dialog boxes and working with JavaScript objects using the Browser object
  • Navigator, windows frames dynamic images and links
  • Event handling, regular expressions and form validation
  • The JavaScript Document Object Model (DOM), Cascading Style Sheets (CSS) and Dynamic HTML

 

Course Outline:

  • Brief Review of Difficult JavaScript Topics
    • Scope
    • Closures
    • Events, Capture and Bubbling

 

  • Introduction to jQuery and jQuery UI
    • Widgets (buttons, dialogs, etc.)
    • Implementing Drag and Drop UIs

 

  • JavaScript and Graphics
    • Raster Graphics with Canvas API
    • Vector Graphics with SVG and Raphael
    • Creating Charts and Graphs in HTML with gRaphael and dojox.charting

 

  • More HTML5 APIs
    • Persisting Data with Local Storage
    • Geolocation Services
    • Future of AJAX/Comet with Web Socket
    • Background JavaScript Tasks with Web Workers
    • Future of Crossdomain Messaging
    • Creating Offline Apps

 

  • JavaScript Software Engineering Techniques
    • The Feature Detection Pattern and Modernizr
    • Organizing Code for Large JS Projects
    • Unit and Functional Testing
    • Testing of Async Interactions
    • Developing with JavaScriptMVC

Advanced JavaScript with AJAX and HTML5

This course elaborates on our basic JavaScript training, focused on three areas of client-side JavaScript programming. The first topic explores how to use prototypal inheritance in JavaScript for building robust and reliable applications. The second topic leverages the XMLHttpRequest object to perform AJAX requests. Finally, the third topic explains how to use the advanced features of HTML5 for building advanced client-side applications.

 

Prerequisites:

Solid experience with JavaScript programming is required in addition to familiarity with HTML, CSS and knowledge of how websites work.

 

Course Outline:

  • Objects
    • Objects in the JavaScript Environment
    • Creating Objects
    • Making Objects with Constructor Functions
    • Inheritance Using Constructor Functions

 

  • Prototypes
    • Object Prototypes
    • Prototypal Inheritance
    • Overriding Methods
    • Mixins

 

  • AJAX
    • AJAX vs. Page Refreshes
    • Instantiating XMLHttpRequest
    • Formatting Requests
    • Rendering Responses

 

  • Geolocation
    • Geolocation Methods and Accuracy
    • Getting Location Information
    • Managing Location Updates

 

  • Web Workers
    • Distributing Tasks Across Multiple Processes
    • Creating New Web Worker Processes
    • Communicating Between Processes
  • Web Storage
    • Web Storage vs. Cookies
    • Types of Web Storage
    • Adding and Retrieving Data
    • Managing Web Storage and Exceptions

 

  • Offline Applications
    • Offline Applications vs. the Browser Cache
    • Declaring Offline Components

 

  • Canvas
    • Introducing the 2-D Drawing Canvas
    • Declaring a Canvas
    • Drawing Shapes and Text
    • Combining Events with the Canvas

 

  • Next Steps
    • Where to Go Next

Introduction to Dojo JavaScript Framework for AJAX

This course teaches attendees how to build powerful JavaScript AJAX applications using the Dojo Toolkit Dijit and DojoX.

 

Course Duration: 3 days

 

Prerequisites:

Before participating, all students should attend our JavaScript course or have equivalent experience. If attendees do not have sufficient knowledge of JavaScript, a one-day JavaScript primer can be included.

 

Course Objectives:

As a result of this training, attendees will:

  • Understand Dojo’s API design and feature set
  • Master the use of Dojo’s core features
  • Manipulate and traverse the Document Object Model using Dojo’s DOM APIs
  • Create and control a class hierarchy using Dojo’s OO toolkit
  • Manage events via dojo/on and Dojo’s publish/subscribe capabilities
  • Explore Dijit, the Dojo UI widget library
  • Learn how to debug Dojo applications
  • Use the Dojo Objective Harness to test your Dojo-based applications

 

Course Outline:

  • Introduction to Dojo
    • What Dojo Is and Isn’t
    • Our First Basic Dojo Script
    • How to Do Things the Dojo Way
      • Asynchronous Modules and AMD
      • Requiring the Code You Need
      • Loading Dojo
    • Baseless Dojo
    • DojoConfig: Configuring How Dojo is Loaded

 

  • Retrieving Elements
    • Dojo/Dom: Asking for an Element by Name
    • What Do I Get Back?
    • DOMNodes and Nodes
    • Creating Nodes
    • Placing Nodes
    • Removing Nodes

 

  • Dojo/Query
    • A Different Way of Retrieving Elements
    • Using CSS Selectors (Up to CSS3)
    • Processing NodeLists

 

  • Basic Styling
    • Accessing Style Information
    • Changing Style Settings

 

  • Dojo and JavaScript
    • Array Enhancements
    • Function Enhancements
    • Working with Dates
    • Working with Numbers and Strings

 

  • Dojo and Events
    • Hooking Up Events with Dojo/On
    • Removing Event Handlers
    • Distributing Events Across a Nodelist
    • Using Dojo’s Publish/Subscribe Model

 

  • Dojo and AJAX
    • AJAX Architecture
    • Dojo and AJAX: Dojo/Request
    • Typical AJAX Tasks
      • Changing the Content of a Node
      • Form Processing
    • Processing Data with AJAX
      • JSON Data
      • XML Data
    • Other Dojo/Request Capabilities

 

  • Dojo and Classes
    • Dojo/declare(): Creating Classes
    • Defining Methods and Properties
    • Inheritance and Mixins
    • Constructors

 

  • Dijit Widgets
    • Declarative vs. Programmatic UI
    • Form Widgets
    • Layout Widgets
    • Other Widgets

 

  • Styling Widgets
    • Using Customizable Properties
    • On-The-Fly

 

  • Creating Your Own Widget
    • From Scratch
    • Using A Template
    • Creating Attributes, Getters and Setters

 

  • Subclassing a Widget
    • Using OO
    • Adding Capabilities

 

  • Conclusion

JavaScript for Frameworks

This course is specifically designed to introduce the JavaScript language to support application development in frameworks such as Angular, Backbone, Ember and Node.js. It starts with an introduction to the syntax of the language, building expressions and operators, and using conditional logic and loops. After exploring the built-in JavaScript objects, this course introduces application debugging using the browser developer tools, the pattern matching functionality of regular expressions, how to build and use functions and, finally, how to leverage the functions to validate HTML form elements. To support best practice programming and common techniques used in the frameworks, participants will be introduced to object creation, function object constructors and prototypal inheritance.

 

Course Duration: 2 days

 

Prerequisites:

  • Experience with computer programming and software development concepts
  • A basic understanding of web technology and familiarity with HTML and CSS
  • Familiarity with object-oriented programming concepts is a plus

 

Course Outline:

  • Fundamentals – Part One
    • The JavaScript Language
      • Browsers and Stand-Alone Engines
    • Browser and Node.js read-execute-print Loops
    • Expressions: a = x + y;
    • Data Types and Literals
    • Operators and Expressions
    • Variables and Assignment Operators
    • console.log

 

  • Fundamentals – Part Two
    • Embedding JavaScript in HTML Documents
    • Using document.write to Generate HTML Content
    • Building Relational Expressions
    • If and Switch Statements
    • JavaScript Truth
    • Arrays, While and For Loops
  • JavaScript Objects
    • Working with Object Properties
    • Number Objects
    • String Objects
    • Date Objects
    • The Math Object
    • Array Objects

 

  • Debugging Browser Applications
    • The JavaScript Console
    • Browser Developer Tools
    • Document Sources
    • Document Elements
    • Breakpoints and Values

 

  • Regular Expressions
    • Pattern Matching Fundamentals
    • Defining Regular Expressions
    • Ranges and Modifiers
    • Anchors and Other Special Characters
    • Using The Regex Object to Match Patterns
    • Using String Objects to Match Expressions
    • Replacing Matched Text in Strings
  • Functions
    • Declaring Functions
    • Function Parameters
    • Variable Scope
    • Return Values
    • Using The Function Length and Arguments Properties
    • Including JavaScript Files
    • Throwing and Catching Exceptions
    • The Error Object

 

  • HTML Forms
    • Using Form and Form Field Elements
    • Code Form Element and Document Element Events
    • Locate Document Elements and Modify Properties

 

  • Creating JavaScript Objects
    • Using Literal Object Notation to Define Objects and Properties
    • Understanding Object Extensibility
    • Building Function Object Constructors
    • Defining Closures and Working with Object Methods
    • Understanding Scope and Closures
    • Implementing Inheritance with Constructors

 

  • JavaScript Prototypes
    • The Benefits and Drawbacks of Using Closures in Constructors
    • Implementing Inheritance Through Prototypes
    • How Prototypes Are Assigned During Construction
    • Alternative Methods for Prototypes Definitions
    • Leveraging JavaScript Mixins to Define Prototypes

 

  • Next Steps
    • Suggested Topics for Further Exploration

 

Server-Side JavaScript with Node.JS and Express

Our Server-side JavaScript with Node.js and Express training teaches experienced JavaScript developers how to create server-side applications with JavaScript, Node.js and the Express framework. Class time will be divided, with 65 percent dedicated to hands-on learning and 35 percent to lecture.

This class explains where Node.js came from, what it does and why it has rapidly become one of the leading server technologies. Students will learn how to work successfully with the asynchronous model that underlies Node.js in order to easily and quickly create highly scalable sites and services. Core Node.js APIs are covered as well as practical tips and design patterns for server-side JavaScript.

Students will get a solid understanding of how to approach and solve application design challenges using Node.js. The Express framework is introduced to add a basic layer of abstraction for common web application patterns. Alternative frameworks are briefly discussed as well.

 

Course Duration: 2 days

 

Prerequisites:

Node.js training attendees should have a thorough knowledge of JavaScript. They should be familiar with web server application design concepts as well as basic HTML and CSS.

 

Hardware and Software Requirements:

  • Firefox with Firebug or Google Chrome
  • A local installation of Node.js
  • Admin/root or sudo privileges to install additional features during the class
  • Additional lab files that we would provide

 

Course Objectives:

  • Learn why server-side JavaScript is useful
  • Learn how Node.js is architected to allow high scalability with asynchronous code
  • Create basic web applications with Node.js
  • Work successfully in the asynchronous Node.js environment through use of control-flow mechanisms
  • Use files, streams, connections to other servers and databases in a Node.js application
  • Interactively debug Node.js applications
  • Use the Express framework to quickly create and structure MVC server-side apps and REST services

 

Course Outline:

  • Introduction

 

  • Why Server-Side JavaScript?
    • Advantages and Disadvantages
    • Integration
    • Databases
    • Node + Client MVC Architecture
    • Node with Server-Side Rendering
    • Node for SOA / REST

• About Node
o History of Server-Side Programming Patterns
 Where JavaScript fits in
o CommonJS
o Infrastructure: V8, libev, libeio
o How Does It Work?
o Express, Sails, etc.

• Building a Basic Application
o The Server, Request, Response Objects
o File System Module

• Additional Uses of Node.js Applications
o Operations, Scripting and Tools
o Holding Many Connections Easily
o How to Debug Node.Js Applications

• Async Flow and The Single Thread
o Blocking vs. Non-Blocking Programming Patterns
o Continuation-Passing Style (CPS) and Error Passing

• Node’s APIs
o Node’s Built-In Helpers and Event Emitter
o Adding Push Notifications with SSE, Web Sockets or socket.io
o Node Language Options
o Streams and Buffers
o Accessing Other Servers and Services

• Patterns for Managing Async
o Promises and Deferreds
o Control Flow Libs

• Node.js Middleware Pattern

• The Express Framework
o Routing and MVC in Express
o Alternatives to Express

• Accessing SQL, NoSQL and Other Types of Data Stores

• Architecture
o Node Clustering
o Load Balancing
o Automated Testing
o Message Queues and Cache Services

• Conclusion

Introduction to Ruby

Course Duration: 4 days

 

Course Outline:

  • Standard Ruby Data Types
    • Installing Ruby
    • Executing Ruby Code
    • Getting Help
    • Dynamic Types
    • Ruby Reserved Words
    • Naming Conventions
    • Comments
    • Strings
    • Simple Input and Output
    • Converting String Input
    • Regular Expressions

 

  • Flow Control
    • The if Statement
    • The case Construct
    • Loops
    • Blocks and Iterators
    • Numeric Iterators
    • String Iterators
    • Methods

 

  • Containers
    • Arrays
    • Array Operator Methods
    • Array Equality Operator
    • Arrays as Stacks and Queues
    • Other Useful Arrays Methods
    • Command Line Arguments
    • Hashes
    • Common Hash Methods
    • Sorting Hashes
    • Iterators with Arrays and Hashes
    • Arrays and Methods
    • Hashes and Methods
    • Symbols
    • Closures, Procs and lambdas

 

  • Classes
    • Objects
    • OOP Vocabulary
    • Creating a New Class
    • Using Objects
    • Defining Operator Methods
    • Inheritance
    • self
    • Access
    • Class Data and Class Methods
    • Adding Methods to Classes and Objects
    • Special Global Variables
    • Scope of Variables
    • Built-In Classes
    • Meta Programming

 

  • Modules
    • Introduction
    • Using Core Ruby Classes
    • Ruby Standard Library
    • require
    • File Organization
    • load
    • include
    • Mixins

 

  • Exceptions
    • Introduction
    • Exception Hierarchy
    • Handling Exceptions
    • Multiple Rescue Clauses
    • Exceptions Are Classes
    • ensure
    • retry
    • raise
    • Creating Your Own Exceptions
    • Catch and Throw

 

  • Meta Programming
    • class_eval
    • instance_eval
    • method_missing
    • respond_to

 

  • Input and Output
    • Reading from the Standard Input
    • Reading a Character at a Time
    • Writing to the Standard Output
    • Reading and Writing Disk Files
    • Reading Files Using Iterators
    • I/O With Command Line Commands

 

  • Testing
    • Unit Testing
    • Mini Test
    • Mocks and Stubs
    • YAML
    • Factory Girl
    • Integration Testing
    • Behavior-Driven Development
    • Stories
    • Using Cucumber
    • Feature
    • Scenarios
    • Gherkin
    • Multiple Scenarios
    • Data Tables
    • Using Mocks and Stubs

Introduction to Ruby on Rails

Course Outline:

  • An Introduction to Ruby
    • What is Ruby?
    • Installing Ruby
    • Executing Ruby Code
    • Getting Help
    • Dynamic Types
    • Ruby Reserved Words
    • Naming Conventions
    • Comments

 

  •  Standard Ruby Data Types
    • Numbers
    • Strings
    • Simple Input and Output
    • Converting String Input
    • Regular Expressions

 

  •  Language Components
    • The if Statement
    • The case Construct
    • Loops
    • Blocks and Iterators
    • Numeric Iterators
    • String Iterators
    • Methods

 

  •  Collections
    • Arrays
    • Array Operator Methods
    • Array Equality Operator
    • Arrays as Stacks and Queues
    • Other Useful Arrays Methods
    • Command Line Arguments
    • Hashes
    • Common Hash Methods
    • Sorting Hashes
    • Iterators with Arrays and Hashes
    • Arrays and Methods
    • Hashes and Methods
    • Symbols
    • Closures, Procs and Lambdas

 

  • Classes
    • Objects
    • OOP Vocabulary
    • Creating a New Class
    • Using Objects
    • Defining Operator Methods
    • Inheritance
    • self
    • Access Levels – Public
    • Access Levels – Private
    • Access Levels – Protected
    • Access Levels – Specification
    • Class Data and Class Methods
    • Adding Methods to Classes and Objects
    • Special Global Variables
    • Scope of Variables
    • Built-On Classes
    • Dispatching
    • Meta Programming

 

  • Input and Output
    • Reading from the Standard Input
    • Reading a Character at a Time
    • Writing to the Standard Output
    • Reading and Writing Disk Files
    • Reading Files Using Iterators
    • I/O With Command Line Commands

 

  • Exceptions
    • Introduction
    • Exception Hierarchy
    • Handling Exceptions
    • Multiple Rescue Clauses
    • Exceptions are Classes
    • ensure
    • retry
    • raise
    • Creating Your Own Exceptions
    • Catch and Throw

 

  • Modules
    • Introduction
    • Using Core Ruby Classes
    • Ruby Standard Library
    • require
    • File Organization
    • load
    • include
    • Mixins
    • Using the Comparable Module
    • Using the Enumerable Module

 

  • Test-Driven Development (TDD)
    • Using Mini Test to Test Your Ruby Classes
    • Creating and Using Fixtures
    • Factory Girl
    • Introduction to TDD
    • Mocks and Stubs
    • Refactoring
    • Basic Patterns Including Factory, Strategy and Proxy

 

  • Behavior-Driven Development (BDD)
    • What is BDD?
    • Using Cucumber
    • BDD with Cucumber

 

  • Introduction to Rails
    • Welcome to Ruby on Rails
    •  What Rails Does (and Does for You)
    • Inside MVC in Rails
    • How Separate are the MVC Layers?
    • A Guided Tour of a Small (But Working!) Rails App

 

  • Domain Modeling and ActiveRecord
    • ActiveRecord Overview
    • Domain Modeling, Ruby and Rails
    • Programming the Domain
    • Creating the Database Tables
    • The Rails Application Console

 

  • Routing and Responses
    • The Rails Request/Response Cycle
    • URL Recognition and Routing
    • Named Routes and URL Generation
    • Resource Routing
    • Creating Controllers and Views
    • Understanding ERB Templates

 

  • Forms
    • Displaying and Processing Forms in Rails

 

  • Exploring ActiveRecord Techniques
    • Getting into ActiveRecord
    • Refining AR Associations
    • Many-to-Many Associations with “Through”
    • Miscellaneous Custom Methods in the Models
    • ActiveRelation Basics

 

  • Data Validation with ActiveRecord
    • Validating ActiveRecord Objects
    • The Role of the Controller in Validating Data
    • Examples of Selected Validation Methods