Index
A
- acceptance tests
- versus integration tests / Acceptance tests
- versus unit tests / Acceptance tests
- about / Acceptance tests
- AMD
- using / Using AMD
- Backbone / Backbone
- models / Models, collections and views
- collections / Models, collections and views
- views / Models, collections and views
- model, creating / Creating a model
- require.config file / The require.config file
- Require config errors, fixing / Fixing Require config errors
- Backbone.Collections, using / Using Backbone.Collections
- Backbone views / Backbone views
- Text plugin, using / Using the Text plugin
- collection, rendering / Rendering a collection
- application, rendering / Creating an application
- jQuery plugins, using / Using jQuery plugins
- Angular
- about / Angular
- classes / Angular classes and $scope
- $scope argument / Angular classes and $scope
- TypeScript compatibility / Angular TypeScript compatibility
- inheritance / Inheritance – Angular versus Backbone
- Angular 2.0
- about / Angular 2.0
- AngularJS
- about / Angular
- anonymous function / Anonymous functions
- any type / The any type
- arrays / Arrays
- assembly
- about / Dependency Injection
- asynchronous functions
- chaining / Chaining asynchronous functions
B
- Backbone
- about / Backbone, Backbone
- inheritance, using / Using inheritance with Backbone
- interfaces, using / Using interfaces
- generic syntax, using / Using generic syntax
- ECMAScript 5, using / Using ECMAScript 5
- TypeScript compatibility / Backbone TypeScript compatibility
- views / Backbone views
- basic types
- TypeScript / TypeScript is strongly typed
- type syntax / Type syntax
- black box tests / Unit, integration and acceptance tests
- Board Sales
- about / Board Sales
- Bootstrap
- about / Bootstrap
- installing / Installing Bootstrap
- using / Using Bootstrap
- elements / Using Bootstrap
- carousel panel 1 element / Using Bootstrap
- show / hide panel button / Using Bootstrap
- filter options / Using Bootstrap
- carousel panel 2 / Using Bootstrap
- Bower package manager / Detailed test results
- Brackets
- about / Brackets
- installing / Installing Brackets
- URL / Installing Brackets
- project, creating / Creating a Brackets project
- live preview, using / Using Brackets live preview
- TypeScript file, creating / Creating a TypeScript file
- TypeScript, compiling / Compiling our TypeScript
- Grunt, using / Using Grunt
- npm (Node package manager) / Using Grunt
- debugging, in Chrome / Debugging in Chrome
- build server, selecting
- Team Foundation Server (TFS) / Team Foundation Server
- Jenkins / Jenkins
- TeamCity / TeamCity
C
- callback function / Function callbacks
- CI
- about / Using continuous integration
- using / Using continuous integration
- benefits / Benefits of continuous integration
- build server, selecting / Selecting a build server
- class
- about / Classes
- constructors / Class constructors
- functions / Class functions, Class functions
- interface function definitions / Interface function definitions
- JavaScript syntax / Classes
- declaration file syntax / Class namespaces
- namespaces / Class namespaces
- constructor overloads / Class constructor overloads
- properties / Class properties
- optional properties / Optional properties
- class constructor overloads
- declaration file syntax / Class constructor overloads
- about / Class constructor overloads
- JavaScript syntax / Class constructor overloads
- classes
- creating, in Angular / Angular classes and $scope
- creating, in ExtJs / Creating classes in ExtJs
- class modifiers
- about / Class modifiers
- constructor access modifiers / Constructor access modifiers
- class property accessors / Class property accessors
- static functions / Static functions
- static properties / Static properties
- class namespaces
- JavaScript syntax / Class namespaces
- declaration file syntax / Class namespaces
- about / Class namespaces
- closures
- generating, with TypeScript class / TypeScript classes generate closures
- collection
- about / Models, collections and views
- rendering / Rendering a collection
- traversing / Traversing a collection
- manufacturer names, finding / Finding manufacturer names
- board types, finding / Finding board types
- CommonJs
- about / CommonJs
- Node, setting up in Visual Studio / Setting up Node in Visual Studio
- Node.js module, creating / Creating a Node module
- Node module, using / Using a Node module
- asynchronous functions, chaining / Chaining asynchronous functions
- compiling
- about / Compiling
- constructor function / Class constructors
- Curl
- URL / CommonJs
D
- data structure
- about / Data structure
- data interfaces / Data interfaces
- integration tests / Integration tests
- collection, traversing / Traversing a collection
- collection, filtering / Filtering a Collection
- data types, TypeScript
- debugging
- TypeScript, in Visual Studio / Debugging in Visual Studio
- declaration file
- writing / Writing your own declaration file
- module keyword / The module keyword
- interfaces / Interfaces
- function overrides / Function overrides
- rounding out / Rounding out our definition file
- syntax reference / Declaration Syntax Reference
- declaration files, NuGet
- installing / Installing declaration files
- declaration syntax reference
- about / Declaration Syntax Reference
- function overrides / Function overrides
- nested namespaces / Nested namespaces
- classes / Classes
- class namespaces / Class namespaces
- class constructor overloads / Class constructor overloads
- class properties / Class properties
- class functions / Class functions
- static functions / Static properties and functions
- static properties / Static properties and functions
- global functions / Global functions
- function signatures / Function signatures
- optional properties / Optional properties
- functions, merging with module definition / Merging functions and modules
- default parameters / Default parameters
- default project settings
- about / Default project settings
- DefinitelyTyped
- about / Definitely Typed
- URL / Definitely Typed
- definition files
- downloading / Downloading definition files
- definition files, TSD
- installing / Installing definition files
- Dependency Injection
- about / Dependency Injection
- versus Service Location / Service Location versus Dependency Injection
- Dependency Injection (DI)
- about / Angular
- Dependency Inversion principle
- about / Dependency Inversion
- Dependency Resolution
- about / Dependency Resolution
- Service Location / Service Location
- Dependency Injection / Dependency Injection
- design pattern / Classes
- Domain Event
- about / The Domain Events Pattern
- reference link / The Domain Events Pattern
- problem space / Problem space
- message interface / Message and Handler Interfaces
- handler interface / Message and Handler Interfaces
- multiple event handlers / Multiple Event Handlers
- event, firing / Firing an event
- event handler, registering / Registering an Event handler for an Event
- error notifications, displaying / Displaying error notifications
- DOM events / DOM events
- DOM events, Marionette
- about / DOM events in Marionette
- Detail view event, triggering / Triggering a Detail view event
- BoardDetailView, rendering / Rendering the BoardDetailView
- done() function
- using / Using the done() function
- duck-typing method / Duck-typing
E
- ECMAScript
- about / EcmaScript
- ECMAScript 5
- using, with Backbone / Using ECMAScript 5
- Embedded JavaScript (EJS) / Global variables
- encapsulation
- about / Encapsulation
- enum
- about / Enums
- const enums / Const enums
- error notifications
- displaying / Displaying error notifications
- event
- firing / Firing an event
- handler, registering / Registering an Event handler for an Event
- explicit casting / Explicit casting
- Extension Manager
- using / Using the Extension Manager
- ExtJs
- about / ExtJs
- URL, for documentation / ExtJs
- classes, creating / Creating classes in ExtJs
- type casting, using / Using type casting
- TypeScript compiler / ExtJs specific TypeScript compiler
F
- Factory class
- about / The Factory class
- using / Using the Factory class
- Factory Design Pattern
- about / The Factory Design Pattern
- business requirements / Business requirements
- tasks / What the Factory Design Pattern does
- IPerson interface / The IPerson interface and the Person base class
- Person base class / The IPerson interface and the Person base class
- returned objects / Specialist classes
- Factory class / The Factory class
- Factory class, using / Using the Factory class
- function definition
- merging, with module definition / Merging functions and modules
- function overrides
- about / Function overrides
- JavaScript syntax / The declaration file syntax
- declaration file syntax / The declaration file syntax
- functions
- about / Functions
- anonymous functions / Anonymous functions
- optional parameters / Optional parameters
- default parameters / Default parameters
- arguments variable / The arguments variable
- callbacks / Function callbacks
- signatures / Function signatures
- callbacks, and scope / Function callbacks and scope
- overloads / Function overloads
- union types / Union types
- functions, class
- declaration file syntax / Class functions
- JavaScript syntax / Class functions
- function signature / Function signatures
- function signatures
- about / Function signatures
- declaration file syntax / Function signatures
- JavaScript syntax / Function signatures
G
- generics
- about / Generics
- syntax / Generic syntax
- classes, instantiating / Instantiating generic classes
- type T, using / Using the type T
- type T, constraining / Constraining the type of T
- interfaces / Generic interfaces, Creating new objects within generics
- used, for checking interface / Interface checking with generics
- generic syntax
- using, with Backbone / Using generic syntax
- getProperties function / Function and constructor overloading with super
- global functions
- declaration file syntax / Global functions
- JavaScript syntax / Global functions
- global variables / Global variables
- Grunt
- URL / Using Grunt
- about / Using Grunt
H
- Handlebars
- URL / Backbone views
- handler interface
- about / Message and Handler Interfaces
- HTML
- JavaScript code blocks, using / Using JavaScript code blocks in HTML
I
- IMediatorFunctions interface
- implementing / Implementing the IMediatorFunctions interface
- Immediately Invoked Function Expression (IIFE) / JavaScript closures
- inferred typing / Inferred typing
- inheritance
- about / Inheritance, Inheritance – Angular versus Backbone
- interface inheritance / Interface inheritance
- class inheritance / Class inheritance
- function, overloading with super keyword / Function and constructor overloading with super
- constructor, overloading with super keyword / Function and constructor overloading with super
- JavaScript closures / JavaScript closures
- using, with Backbone / Using inheritance with Backbone
- Angular, versus Backbone / Inheritance – Angular versus Backbone
- installation, declaration files
- about / Installing declaration files
- installation, definition files / Installing definition files
- integration tests
- versus unit tests / Integration tests
- versus acceptance tests / Integration tests
- about / Integration tests, Integration tests
- simulating / Simulating integration tests
- detailed test results / Detailed test results
- test results, logging / Logging test results
- page elements, searching / Finding page elements
- IntelliSense
- about / Strong Typing
- interface
- about / Interfaces
- programming / Program to an interface
- interfaces
- using, with Backbone / Using interfaces
- Interface Segregation principle
- about / Interface Segregation
- Inversion of Control (IOC) / Interface checking with generics
J
- Jasmine
- URL / Unit testing frameworks
- running, ways / Jasmine runners
- page elements, working with / Working with page elements in Jasmine
- Jasmine.js
- about / Jasmine
- test / A simple Jasmine test
- SpecRunner.html file / Jasmine SpecRunner.html file
- matchers / Matchers
- teardown / Test startup and teardown
- test startup / Test startup and teardown
- data-driven tests / Data-driven tests
- spies, using / Using spies
- spies, using as fakes / Using spies as fakes
- asynchronous tests / Asynchronous tests
- done() function, using / Using the done() function
- fixtures / Jasmine fixtures
- DOM events / DOM events
- Jasmine runners
- about / Jasmine runners
- Testem / Testem
- Karma / Karma
- Protractor / Protractor
- JavaScript
- about / JavaScript is not strongly typed
- variables, defining / JavaScript is not strongly typed
- functions / Functions
- JavaScript code blocks
- using, in HTML / Using JavaScript code blocks in HTML
- structured data / Structured data
- JavaScript framework
- selecting / Choosing a JavaScript framework
- JavaScript variables
- basic types / Basic types
- Jenkins
- about / Jenkins
- jQuery plugins
- using / Using jQuery plugins
- JSLint
- about / Compiling
K
- Karma
- about / Karma
L
- layouts / Marionette application, regions and layouts
- lib directory / Using the Extension Manager
- Liskov Substitution principle
- about / Liskov Substitution
M
- Marionette
- about / Marionette
- views / Marionette views
- DOM events / DOM events in Marionette
- Marionette application
- building / Marionette application, regions and layouts
- main collection, loading / Loading the main collection
- Marionette views
- about / Marionette views
- ManufacturerCollectionView class / The ManufacturerCollectionView class
- ManufacturerView class / The ManufacturerView class
- BoardView class / The BoardView class
- BoardSizeView class / The BoardSizeView class
- filtering, with IFilterProvider interface / Filtering using the IFilterProvider interface
- FilterCollection class / The FilterCollection class
- filtering / Filtering views
- MaxUnit
- URL / Unit testing frameworks
- message interface
- about / Message and Handler Interfaces
- mocha
- URL / Unit testing frameworks
- model
- about / Models, collections and views
- creating / Creating a model
- module
- merging / Module merging
- Moustache
- URL / Backbone views
- multiple event handlers
- about / Multiple Event Handlers
N
- nested function / Function callbacks and scope
- nested namespaces
- declaration file syntax / Nested namespaces
- JavaScript syntax / Classes
- Node
- URL / Using Grunt
- Node.js module
- creating / Creating a Node module
- Node module
- using / Using a Node module
- Nodes
- about / Using Grunt
- Notify library
- NuGet
- about / Using NuGet
- using / Using NuGet
- Extension Manager, using / Using the Extension Manager
- declaration files, installing / Installing declaration files
- Package Manager Console, using / Using the Package Manager Console
O
- Open Closed principle
- about / Open Closed
P
- Package Manager Console
- using / Using the Package Manager Console
- packages, installing / Installing packages
- package names, searching / Searching for package names
- specific version, installing / Installing a specific version
- packages, TSD
- querying / Querying for packages
- page layout
- about / Page layout
- viewing panel / Page layout
- footer panel / Page layout
- board listing panel / Page layout
- filter panel / Page layout
- board detail panel / Page layout
- Bootstrap, installing / Installing Bootstrap
- Bootstrap, using / Using Bootstrap
- print function / Classes
- private accessors
- about / Public and private accessors
- properties, class
- JavaScript syntax / Class properties
- declaration file syntax / Class properties
- Protractor
- about / Protractor
- URL / Protractor
- Selenium, using / Using Selenium
- public accessors
- about / Public and private accessors
Q
- QUnit
- URL / Unit testing frameworks
R
- reflection
- about / Program to an interface
- regions / Marionette application, regions and layouts
- Representational State Transfer (REST) / Integration tests
- require.config file / The require.config file
- Require config errors
- fixing / Fixing Require config errors
- incorrect dependencies / Incorrect dependencies
- 404 errors / 404 errors
- runtime
- type, checking / Runtime type checking
- reflection process / Reflection
- reflection-like capabilities implementation, issues / Reflection
- object, checking for function / Checking an object for a function
- interface, checking with generics / Interface checking with generics
S
- $scope argument
- about / Angular classes and $scope
- Scripts directory / Using the Extension Manager
- Selenium IDE
- URL / Finding page elements
- Service Location
- about / Service Location
- versus Dependency Injection / Service Location versus Dependency Injection
- Service Locator
- building / Building a Service Locator
- problem space / The problem space
- service, creating / Creating a Service
- implementing / A Service Locator
- named interfaces, writing / Named interfaces
- classes, registering against named interfaces / Registering classes against named interfaces
- using / Using the Service Locator
- testing / Testability
- Simply Find an Interface for the Any Type (S.F.I.A.T) / Explicit casting
- Single Responsibility principle
- about / Single Responsibility
- SOLID principles
- about / SOLID principles
- Single Responsibility / Single Responsibility
- Open Closed / Open Closed
- Liskov Substitution / Liskov Substitution
- Interface Segregation / Interface Segregation
- Dependency Inversion / Dependency Inversion
- State Design Pattern
- about / The State Design Pattern
- business rules / Problem space
- class diagram / State class diagram
- concrete classes / Concrete State classes
- Mediator class / The Mediator class
- Mediator class, moveToState function / Moving to a new State
- IMediatorFunctions interface, implementing / Implementing the IMediatorFunctions interface
- changes, triggering / Triggering State changes
- static functions
- declaration file syntax / Static properties and functions
- about / Static properties and functions
- JavaScript syntax / Static properties and functions
- static properties
- about / Static properties and functions
- strong typing
- about / Strong Typing
- syntactic sugar
- about / TypeScript's "syntactic sugar"
T
- TDD
- about / Test Driven Development
- steps / Test Driven Development
- TeamCity
- about / TeamCity
- Team Foundation Server (TFS) / Team Foundation Server
- Testem
- Text plugin
- using / Using the Text plugin
- third-party libraries
- using / Using third party libraries
- JavaScript framework, selecting / Choosing a JavaScript framework
- TodoMVC project
- TSD
- using / Using TypeScript Definition Manager
- URL / Using TypeScript Definition Manager
- packages, querying / Querying for packages
- wildcards, using / Using wildcards
- definition files, installing / Installing definition files
- tsUnit
- URL / Unit testing frameworks
- type casting
- using / Using type casting
- TypeScript
- about / What is TypeScript?, TypeScript is strongly typed
- ECMAScript / EcmaScript
- benefits / The benefits of TypeScript
- compiling / Compiling
- strong typing / Strong Typing
- syntactic sugar / TypeScript's "syntactic sugar"
- JavaScript libraries, defining / Type definitions for popular JavaScript libraries
- DefinitelyTyped / Definitely Typed
- encapsulation / Encapsulation
- public accessors / Public and private accessors
- private accessors / Public and private accessors
- syntax / Type syntax
- inferred typing / Inferred typing
- duck-typing / Duck-typing
- data types / Arrays
- any type / The any type
- explicit casting / Explicit casting
- compatibility, with Backbone / Backbone TypeScript compatibility
- compatibility, with Angular / Angular TypeScript compatibility
- typescript-tiny-ioc
- TypeScript compiler
- TypeScript definition, for JavaScript libraries
- TypeScript IDEs
- about / TypeScript IDEs
- Visual Studio 2013 / Visual Studio 2013
- debugging, in Visual Studio / Debugging in Visual Studio
- WebStorm / WebStorm
- Brackets / Brackets
U
- union types
- guards / Type guards
- aliases / Type aliases
- unit testing frameworks
- about / Unit testing frameworks
- unit tests
- versus acceptance test / Unit, integration and acceptance tests
- versus integration tests / Unit, integration and acceptance tests, Unit tests
- about / Unit tests
- versus acceptance tests / Unit tests
- User Acceptance Testing (UAT) / Simulating integration tests
V
- views
- about / Models, collections and views
- Visual Studio
- Node, setting up / Setting up Node in Visual Studio
- Visual Studio 2013
- about / Visual Studio 2013
- Visual Studio project, creating / Creating a Visual Studio Project
- default project settings / Default project settings
- Visual Studio plugin
W
- WebStorm
- URL / WebStorm
- about / WebStorm
- project, creating / Creating a WebStorm project
- default files / Default files
- index.html file, creating / Default files
- web page, running in Chrome / Running the web page in Chrome
- debugging, in Chrome / Debugging in Chrome
- WebStorm file watcher
- about / Default files
- white box tests / Unit, integration and acceptance tests
- wildcards, TSD
- using / Using wildcards
- Windows Workflow Foundation (WF) / Team Foundation Server