Click on the links below to view course outlines, pre-requisites, course length and course objectives.
WEB DEVELOPMENT
PASSION IS WHAT DRIVES US
Founded in 2006 on the core belief that there is a superior way to train technical teams
OUR COURSES
Close
NEW Updated, Two-Day React Course
Course Number:
N/A
This course explores using the React and Redux frameworks to build client-side single-page applications. React is used to build the components that are rendered to build the user interface. The participant will learn about the component lifecycle, how to define components as classes in React and how to work with props and state.
Redux is the next generation framework to provide a uni-directional flow of information between the layers of the application. The course is fast-paced and relies on the participant having a firm grasp of HTML, CSS, and advanced JavaScript programming with ES6 additions.
Audience:
Course Duration:
2 days
Prerequisites:
- Experience using HTML and CSS to build web pages
- Mastery of advanced JavaScript features, including callbacks, constructors and prototypes
- Exposure to JavaScript ES6 features, including arrow functions, classes, the spread operator, etc.
- Exposure to Node.js and Express web services is a plus
Course Objectives:
Course Outline:
- Chapter One – Getting Started
- The client-side, single-page application
- React ideology
- Package management with Node.js and npm
- Project Structure
- JavaScript ES6 and transpilation
- Development workflow
- Bundling and Webpack
- Debugging ES6
- Chapter Two – Basic Components
- React DOM elements and props
- JSX expressions
- Custom components
- Functional components
- Extending React.Component
- Component hierarchy and nested components
- Props and the flow of information
- Building components
- Rendering components
- Reusable components
- Chapter Three – State
- Input fields
- Uncontrolled components
- Callback functions and class methods as callbacks
- Controlled components and state
- Uncontrolled vs. controlled components
- Working with state: toggling component presentation
- Chapter Four – DOM Abstraction
- DOM events
- HTML elements vs. React DOM elements
- DOM Reconciliation
- List keys
- Referencing browser DOM elements
- Chapter Five – Architecture with Components
- Prop validation
- Built-in and custom validators
- Data flow
- State vs. props
- Pure and stateful components
- Container components
- Component composition strategies
- Immutability
- Lifecycle
- Fetch and AJAX requests
- Chapter Six – Forms
- Form validation strategies
- Chapter Seven – Routing
- The React router
- Route parameters
- Active links
- Changing routes programmatically
- Injecting data sources
- JSON conversions
- Chapter Eight – Redux – 90/120
- Redux architecture
- Store and reducers
- Actions and action creators
- Separating and combining reducers
- Using Redux asynchronously
- Chapter Nine – Deployment
- Deploying Babel in production
- Build tools and webpack
- Appendix A Flux
- Flux architecture
- Stores
- Actions and action creators
- Dispatchers
- Using Flux asynchronously
Close
Behavior Driven Development and Test-Driven Development
Course Number:
N/A
This course covers Behavior Driven Development (BDD) concepts of “write your tests first” and “fail first”. This will drive your development process in a “test-implement-test pass-refactor” cycle. Cucumber-JVM together with JUnit provides the basis for the hands-on aspects of the course. Through a series of practical exercises, students will translate scenarios into runnable acceptance tests using Cucumber-JVM. As such various testing patterns and approaches will be explored including the utilization of isolated testing via Stubs, fakes and Mock objects In students will leverage the evolution of User stories into code and the have the ability to test Web Application via the Selenium API. This course is about 50% lecture & 50% discussion / hands-on exercises.
Audience:
This training session is for developers, testers, business analysts and product owners, to enable them to apply BDD principles and practices to steer their projects with acceptance tests at the level of requirements and user stories.
Course Duration:
3 Days
Prerequisites:
It is recommended that participants have experience working in Java.
Course Objectives:
- Capture the core JUnit syntax
- Use BDD and the test-fail-first approach
- Translate business requirements into user stories with acceptance tests
- Learn how to Refactor to clean up your code
- What makes your code testable
- Use Fakes and Mocks for isolated unit tests
- Use Cucumber-JVM to turn User Stores into Code
- Explore the Selenium API
Course Outline:
JUnit Overview
- Unit Testing
- Testing with JUnit, the test lifecycle – @Before, @After, @BeforeClass, @AfterClass, @Test
- Writing assert methods – assertEquals, assertSame, assertTrue, assertFalse, assertNull
- Hamcrest Matchers and using the assertThat
- Using is, or, contains, hasItem, equalTo
- The allOf and anyOf matchers
Test Driven Development (TDD)
- Principals and Techniques
- TDD Metaphors
- Benefits, Challenges and Limitations
- Handling Requirements Change
- Characteristics of good tests
- Revisit Anti Patterns
Testable Designs (Mocks, Fakes and Stubs)
- Creating testable Code, If you cannot test it what use is it?
- Strategies for Testable Code
- Test Unfriendly features
- Interfaces are great!
- Stubs, Fakes and Mocks
- Mocks as Collborators
- Mocks and return values, void methods, frequency calls and ordering
Behavior Driven Development (BDD) with Cucumber
- Writing User Stories
- Acceptance criteria
- Bridging the communication gap between business stakeholders
- Introduction to Cucumber
- Writing scenarios with Gherkin
- Gherkin syntax
- Using given, when, then
- Java, Ruby or Groovy Fixtures generated from scenarios
- Using JUnit to run your Cucumber stories and scenarios
- Writing set-up and tear down code using hooks (@Before and @After)
- Automate Cucumber steps to drive your application both through and below the user interface
- Refactor Cucumber step definitions to make them more readable and maintainable
Testing Web sites with Selenium
- Using a WebDriver to test web applications and the Selenium API
- Interrogating a response page
- Simulating links and form submissions
- Simulate multiple page navigation
- Continuous Integration
Close
EmberJS
Course Number:
N/A
nTier’s 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.
Audience:
Course Duration:
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.
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
Close
HTML5
Course Number:
N/A
nTier Training’s 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.
Audience:
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
- Offline Application API
- Conclusion
Close
jQuery
Course Outline Coming Soon!
Close
Selenium
Course Number:
N/A
This course will introduce you to the basics of automation testing using Selenium and build on that foundation to cover advanced topics. The course is very hands on with a strong focus on web driver functionality.
Audience:
Course Duration:
2 days
Prerequisites:
Students should have a minimum of six months hands-on coding experience in the language they will be using in production (e.g. Java, C#, Python, etc.).
Course Objectives:
Upon completion of this course, participants should:
- Know how to use Selenium WebDriver automation tool and write test scripts using Java, Python or C#
- Understand the motivation for test automation
- Know how to work with Page Objects
- Have ample practice using Selenium Grid
- Be able to develop Frameworks using WebDriver and Java
Course Outline:
- Introduction
- Selenium
- Test Automation
- Testing Approaches
- Should I Automate?
- Selenium Installation
- Browser Specific
- Non-Browser Specific
- Standalone
- WebDriver – Beginning
- Browsers
- Drivers and Plugins
- Basic Operations
- Open and Closing Window
- Maximizing the Window
- Navigating Back and Forward
- Get Current URL
- Get Page Source
- Resize and Move Window
- WebDriver Elements
- Element Identification
- By XPath
- By CSS
- By ID
- By Name
- By Tag Name
- By Class Name
- By Link Text / Partial Link Text
- XPath Fundamentals
- Element Operations
- Keys and Data Entry
- Performing Actions
- Drag and Drop
- Double Click
- Mouse Over/ Mouse Hover
- Context Menu
- WebDriver – Advanced
- Setup
- Browser Launching
- Waits
- Support Classes
- HTTP Proxies
- Page Loading Strategy
- Web Elements
- Keyboard
- Mouse
- JavaScript Executor
- Exceptions
- Switching Context
- Screen Shots
- Element Identification
- Remote WebDriver
- Server
- Client
- Testing Considerations
- Page Object Models
- Page Factory Model
- Domain Specific Language
- Data-Driven?
- Generating Application State
- Mock External Services
- Improved Reporting
- Avoid Sharing State
- Test Independency
- Using a Fluent API
- Browser State
- Testing Gotchas
- Captchas
- File Downloads
- HTTP Response Codes
- Logins
- Test Dependency
- Performance Testing
- Link Spidering
- Selenium Grid
- Pros and Cons
- Components
- Create Your Own
ANGULAR
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Close
Angular
Course Number:
N/A
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.
Audience:
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
Course Objectives:
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
Close
Introduction to Angular 2
Course Number:
N/A
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
BACKBONE
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Close
Introduction to Backbone.JS
Course Number:
N/A
Course Duration:
3 days
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
Close
Backbone.JS
Course Number:
N/A
nTier’s 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.
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
RUBY
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Close
Introduction to Ruby
Course Number:
N/A
Audience:
Course Duration:
5 Days
Prerequisites:
Course Objectives:
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
Close
Introduction to Ruby on Rails
Course Number:
N/A
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
JAVA SCRIPT
Click on the links below to view course outlines, pre-requisites, course length and course objectives.
Close
JavaScript
Course Number:
N/A
nTier Training’s 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.
Audience:
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
Close
Server-Side JavaScript with Node.JS and Express
Course Number:
N/A
nTier’s 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.
Audience:
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.
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
Close
Advanced JavaScript
Course Number:
N/A
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 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
Close
Advanced JavaScript with AJAX and HTML5
Course Number:
N/A
This course elaborates on nTier’s 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
Close
Introduction to Dojo JavaScript Framework for AJAX
Course Number:
N/A
This course teaches attendees how to build powerful JavaScript AJAX applications using the Dojo Toolkit Dijit and DojoX.
Audience:
Course Duration:
3 days
Prerequisites:
Before participating, all students should attend nTier’s 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
Close
JavaScript for Frameworks
Course Number:
N/A
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 Objectives:
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
- The JavaScript Language
- 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