Index

A

• AbsurdJS
  • about / Working with AbsurdJS
  • working with / Working with AbsurdJS
• actual test
  • writing / Writing the actual test
• Adobe
  • about / Introducing the task runners
• Angular
  • used, for developing client side / Developing the client side with Angular
• AngularJS
  • about / Exploring AngularJS, Final words on AngularJS
  • URL / Exploring AngularJS
  • directives, using / Using directives and controllers
  • controllers, using / Using directives and controllers
  • data binding process / Data binding
  • logic, encapsulating with modules / Encapsulating logic with modules
  • data, preparing with filters / Preparing data with filters
  • dependency injection / Dependency injection
  • model / The model in the context of AngularJS
• AngularJS applications
  • bootstrapping / Bootstrapping AngularJS applications
• API
  • about / Discovering REST and API
  • testing / Testing the API
• API router
  • implementing / Implementing the API router
• app
  • running, ways / Using node-webkit
• application
  • planning / Planning the application
  • Key, creating for / Obtaining your application's Key and Secret
  • Secret, creating for / Obtaining your application's Key and Secret
  • preparing / Preparing the application
  • base, writing / Writing the base of the application
  • package.json file, writing / Writing the package.json file
  • HTML layout, preparing / Preparing the HTML layout
  • JavaScript base, designing / Designing the JavaScript base
• application, extending
  • about / Extending the application
  • updateFileArea function, tweaking / Tweaking the updateFileArea function
  • new page, loading for selected image / Loading a new page for the selected image
  • image, displaying / Showing the image and its dimensions
  • image dimensions, displaying / Showing the image and its dimensions
  • toolbar, removing / Removing the toolbar
• applications
  • about / Introducing the task runners
• application tool
  • running / Running our application tool
• arguments, express-generator command-line tool
  • -h, --help / Using a command-line tool
  • -V, --version / Using a command-line tool
  • -e, --ejs / Using a command-line tool
  • -H, --hogan / Using a command-line tool
  • -c, --css / Using a command-line tool
• assertions
  • about / Classifying tests
• assets
  • delivering / Running the server and delivering the assets
• asynchronous programming
  • about / Asynchronous programming
• atomic design
  • URL / Atomic design
  • about / Atomic design

B

• Backbone.Collection module / Using collections
• Backbone.Events module / Understanding Backbone.js as an event-driven framework
• Backbone.js framework
  • exploring / Exploring the Backbone.js framework
  • framework dependency, recognizing / Recognizing the framework dependency
  • functionality, extending / Extending the functionality
  • event-driven framework / Understanding Backbone.js as an event-driven framework
  • models, using / Using models
  • collections, using / Using collections
  • views, implementing / Implementing views
  • routers, using / Using the router
  • backend / Talking to the backend
• Backbone.View module / Implementing views
• backend part, to-do application
  • writing / Writing the backend of the application
  • Node.js server, running / Running the Node.js server
  • to-do lists, managing / Managing the to-do lists
• basic application structure
  • about / Understanding the basic application structure
• behavior-driven development (BDD)
  • about / Behavior-driven development
• BEM
  • about / BEM (block, element, modifier)
  • URL / BEM (block, element, modifier)
• benefits, CSS preprocessors
  • concatenation / Exploring CSS preprocessors
  • extending / Exploring CSS preprocessors
  • configuration / Exploring CSS preprocessors
• blocks / Developing the client side with Angular

C

• cache manifest file
  • about / Generating a cache manifest file
  • generating / Generating a cache manifest file
• callbacks
  • about / Planning the application
• categories, for application styles
  • basic selectors / Scalable and modular architecture for CSS
  • layout / Scalable and modular architecture for CSS
  • modules / Scalable and modular architecture for CSS
  • state / Scalable and modular architecture for CSS
  • theme / Scalable and modular architecture for CSS
• chat
  • client side, writing / Writing the client side of the chat
• chat logic
  • writing / Writing the chat logic
• classes, Ember.js
  • exploring / Exploring classes and objects in Ember.js
• client side
  • developing, with Angular / Developing the client side with Angular
• client side, of chat
  • HTML markup, preparing / Preparing the HTML markup
  • logic, writing / Writing the chat logic
• code
  • minifying / Minifying your code, Concatenating and minifying with Gulp
  • documenting / Documenting our code
• code-over-configuration principle / Discovering Gulp
• code logic, organizing in modules
  • car construction application, building / Building a car construction application
  • car's engine, using / Using the car's engine
• code shallow / Asynchronous programming
• command-line tool
  • used, for installing Express / Using a command-line tool
• CommonJS / Organizing your code logic in modules
• composition
  • versus, inheritance / Composition versus inheritance
• computed properties, Ember.js / Computed properties
• concatenation
  • about / Concatenating files
• concepts, modular CSS
  • BEM / BEM (block, element, modifier)
  • OOCSS approach / Using the Object Oriented CSS approach
  • SMACSS / Scalable and modular architecture for CSS
  • atomic design / Atomic design
• connect
  • about / Exploring middleware architecture
  • URL / Exploring middleware architecture
• Connect
  • about / Getting acquainted with Express
• controllers, Ember.js / Controllers
• control panel
  • about / Implementing a control panel
  • implementing / Implementing a control panel
• CORBA
  • about / Discovering REST and API
• cross-browser issues
  • about / Knowing the dependencies of Ember.js
• CRUD / Talking to the backend
• crypto module / Working with the database
• CSS2
  • about / Writing modular CSS
• CSS3
  • about / Writing modular CSS
• CSS preprocessors
  • exploring / Exploring CSS preprocessors
  • benefits / Exploring CSS preprocessors
  • Less / Using Less
  • Sass / Using Sass
  • Stylus / Using Stylus
  • AbsurdJS / Working with AbsurdJS
• current directory
  • modifying / Changing the current directory
• current working directory
  • displaying / Displaying the current working directory

D

• DalekJS
  • testing with / Testing with DalekJS
• database
  • selecting / Selecting and initializing the database
  • initializing / Selecting and initializing the database
  • working with / Working with the database
  • record, creating / Creating a new record
  • record, editing / Editing a record
  • record, deleting / Deleting a record
  • books, displaying / Displaying all the books
  • default route, adding / Adding a default route
• data binding
  • about / Data binding
• DELETE request
  • about / Discovering REST and API
• deleteToDo function / Managing the to-do lists
• dependencies / Recognizing the framework dependency
• dependencies, Ember.js
  • jQuery / Knowing the dependencies of Ember.js
  • Handlebars / Knowing the dependencies of Ember.js
• dependency injection
  • about / Dependency injection
• dependency management
  • about / Managing dependencies
• describe method / Testing the file-reading process
• dynamic URLs
  • handling / Handling dynamic URLs and the HTML forms

E

• Ember.js
  • about / Discovering Ember.js, Understanding Ember.js
  • classes, exploring / Exploring classes and objects in Ember.js
  • objects, exploring / Exploring classes and objects in Ember.js
  • computed properties / Computed properties
  • router / Router
  • models / Models
  • controllers / Controllers
• Ember.js part
  • writing / Writing Ember.js
  • templates, defining / Defining the templates
• Ember Inspector
  • about / Router
• Evaluate method / Understanding how PhantomJS works
• EventEmitter / Understanding inter-module communication
• example-logging system
  • about / The example-logging system
• Express
  • URL / Getting acquainted with Express
  • about / Getting acquainted with Express
  • installing / Installing Express
  • installing, package.json used / Using package.json
  • installing, command-line tool used / Using a command-line tool
• express-generator command-line tool
  • about / Using a command-line tool

F

• files
  • concatenating / Concatenating files, Concatenating and minifying with Gulp
  • viewing, for changes / Watching files for changes
  • ignoring / Ignoring files
  • displaying / Showing the files and folders
  • copying / Copying, moving, and deleting files
  • moving / Copying, moving, and deleting files
  • deleting / Copying, moving, and deleting files
• flapi module
  • about / Exploring the required modules
• Flickr.js module
  • writing into / Writing into the Flickr.js module
• Flickr protocol
  • authorizing / Authorizing the Flickr protocol
• folder
  • images, obtaining from / Obtaining images from a folder
• folders
  • displaying / Showing the files and folders
• frontend part, to-do application
  • writing / Writing the frontend
  • files structure / Looking into the base of the application
  • to-do activities, listing / Listing the to-do activities
  • to-do lists, adding / Adding, deleting, and editing the to-do lists
  • to-do lists, deleting / Adding, deleting, and editing the to-do lists
  • to-do lists, editing / Adding, deleting, and editing the to-do lists
• fs module
  • about / Exploring the required modules
• functional testing
  • about / Classifying tests

G

• GET request
  • about / Discovering REST and API
• glob module
  • about / Exploring the required modules
• Google
  • about / Exploring AngularJS
• Grunt
  • about / Introducing the task runners, Exploring Grunt
  • files, concatenating / Concatenating files
  • code, minifying / Minifying your code
  • files, viewing for changes / Watching files for changes
  • files, ignoring / Ignoring files
  • task, creating / Creating our own task
  • cache manifest file, generating / Generating a cache manifest file
  • code, documenting / Documenting our code
• grunt-contrib-concat plugin
  • about / Exploring Grunt, Concatenating files
• grunt-contrib-uglify plugin / Minifying your code
• grunt-contrib-watch plugin / Watching files for changes
• Gruntfile.js file
  • about / Exploring Grunt
• Gulp
  • about / Introducing the task runners, Discovering Gulp
  • installing / Installing Gulp and fetching plugins
  • plugins, fetching / Installing Gulp and fetching plugins
  • files, concatenating / Concatenating and minifying with Gulp
  • code, minifying / Concatenating and minifying with Gulp
• gulp-concat plugin
  • about / Concatenating and minifying with Gulp
• gulp-rename plugin
  • about / Concatenating and minifying with Gulp
• gulp-uglify plugin
  • about / Concatenating and minifying with Gulp
• gulp command
  • about / Concatenating and minifying with Gulp
• gulpfile.js file / Discovering Gulp
• Gulp plugin
  • creating / Creating your own Gulp plugin

H

• Handlebars
  • about / Knowing the dependencies of Ember.js
• handler
  • about / Defining the API parts
• headless browser
  • testing with / Testing with a headless browser
• HTML forms
  • about / Handling dynamic URLs and the HTML forms
• HTML layout
  • preparing, for application / Preparing the HTML layout
• http module / Node.js fundamentals
• HTTP verbs
  • about / Discovering REST and API

I

• @include keyword / Using Sass
• images
  • obtaining, from folder / Obtaining images from a folder
  • uploading / Uploading the images
• installation, Express
  • about / Installing Express
  • package.json used / Using package.json
  • command-line tool used / Using a command-line tool
• installation, Gulp / Installing Gulp and fetching plugins
• installation, Jasmine / Installing Jasmine
• installation, Mocha / Installation
• integration test
  • writing / Writing an integration test
• integration testing
  • about / Classifying tests
• inter-module communication
  • about / Understanding inter-module communication

J

• Jade
  • about / Knowing the dependencies of Ember.js
• Jasmine
  • about / Using Jasmine, Testing the API
  • installing / Installing Jasmine
  • module, defining for testing / Defining the module for testing
  • test-driven development concept, following / Following the test-driven development concept
  • reading of file content, testing / Testing the file-reading process
  • strings, finding in file content / Finding strings in the file content
  • integration test, writing / Writing an integration test
• JavaScript base
  • designing, for application / Designing the JavaScript base
• jQuery
  • about / Knowing the dependencies of Ember.js

K

• Key
  • about / Authorizing the Flickr protocol
  • creating, for application / Obtaining your application's Key and Secret

L

• LESS
  • about / Using a command-line tool
• Less
  • about / Using Less
  • using / Using Less
  • variables, defining / Defining variables
  • mixins, using / Using mixins
  • styles, structuring into nested definitions / Structuring the styles into nested definitions
  • URL, for documentation / Structuring the styles into nested definitions
• logic
  • encapsulating, with modules / Encapsulating logic with modules
• login form
  • styling / Styling a simple login form

M

• @mixin keyword / Using Sass
• manifest.json
  • about / Introducing the task runners
• micro testing framework
  • developing / Developing the micro testing framework
• middleware architecture
  • exploring / Exploring middleware architecture
• minification
  • about / Minifying your code
• mixins, Less
  • using / Using mixins
• Mocha
  • about / Testing with Mocha
  • installing / Installation
  • example, translating / Translating our example using Mocha
  • reporter, selecting / Selecting a reporter
• Model-View-Controller (MVC) pattern / Using a command-line tool, Implementing views
• models, Ember.js / Models
• modifiers
  • about / BEM (block, element, modifier)
• modular CSS
  • writing / Writing modular CSS
• modules
  • logic, encapsulating with / Encapsulating logic with modules
  • exploring / Exploring the required modules
• MongoDB
  • about / Selecting and initializing the database, Working with the database
  • NoSQL, using with / Using NoSQL with MongoDB
  • URL, for downloading / Using NoSQL with MongoDB
• MySQL
  • about / Selecting and initializing the database, Working with the database
  • using / Using MySQL
  • URL, for downloading / Using MySQL

N

• nested definitions
  • style, structuring into / Structuring the styles into nested definitions
• node-webkit
  • using / Using node-webkit
  • URL / Using node-webkit
  • URL, for documentation / Using node-webkit
• Node.js
  • fundamentals / Node.js fundamentals
  • code logic, organizing in modules / Organizing your code logic in modules
  • URL / Using the car's engine
  • about / Getting acquainted with Express, Writing the base
  • server code, writing / Running the server
• Node.js, task runners
  • Grunt / Exploring Grunt
  • Gulp / Discovering Gulp
• Node Package Manager(npm)
  • about / Managing dependencies
• NoSQL
  • using, with MongoDB / Using NoSQL with MongoDB

O

• OAuth
  • about / Authorizing the Flickr protocol
• objects, Ember.js
  • exploring / Exploring classes and objects in Ember.js
• Observer / Understanding inter-module communication
• online library
  • developing / Developing an online library – a REST API
• OOCSS approach
  • about / Using the Object Oriented CSS approach
  • separate structure, and skin / Separate structure and skin
  • separate container, and content / Separate container and content
• open module
  • about / Exploring the required modules
• optimist module
  • about / Exploring the required modules

P

• package.json
  • used, for installing Express / Using package.json
• package.json file
  • using / Exploring the required modules
  • writing / Exploring the required modules, Writing the package.json file
• parts, API server
  • router / Defining the API parts
  • handler / Defining the API parts
  • responder / Defining the API parts
• performance tests
  • about / Classifying tests
• PhantomJS
  • about / Testing with PhantomJS
  • URL / Testing with PhantomJS
  • testing with / Testing with PhantomJS
  • micro testing framework, developing / Developing the micro testing framework
  • working / Understanding how PhantomJS works
  • actual test, writing / Writing the actual test
• POST requests
  • about / Discovering REST and API
• preprocessors
  • about / Exploring CSS preprocessors
• promise
  • fulfilled state / Asynchronous programming
  • rejected state / Asynchronous programming
  • pending state / Asynchronous programming
  • settled state / Asynchronous programming
• promise method / Asynchronous programming
• promises paradigm / Asynchronous programming
• PUT request
  • about / Discovering REST and API

R

• readline module
  • about / Exploring the required modules
• record
  • creating, in database / Creating a new record
  • editing, in database / Editing a record
  • deleting, from database / Deleting a record
• removeListener / Understanding inter-module communication
• reporter
  • selecting / Selecting a reporter
• responder
  • about / Defining the API parts
  • writing / Writing the responder
• response
  • returning / Returning a response
• response object
  • about / Returning a response
• REST
  • about / Discovering REST and API
• REST API
  • about / Developing an online library – a REST API
  • parts, defining / Defining the API parts
  • base, writing / Writing the base
  • router, implementing / Implementing the API router
  • responder, writing / Writing the responder
• REST APIs
  • about / Discovering REST and API
• Revealing Module pattern / Looking into the base of the application
• router
  • about / Defining the API parts
• router, Ember.js / Router
• routes
  • managing / Managing routes
  • defining / Defining the routes

S

• Sass
  • about / Using Sass
  • using / Using Sass
• Secret
  • about / Authorizing the Flickr protocol
  • creating, for application / Obtaining your application's Key and Secret
• server
  • running / Running the server and delivering the assets
• SMACSS
  • about / Scalable and modular architecture for CSS
  • URL / Scalable and modular architecture for CSS
• SOAP
  • about / Discovering REST and API
• Socket.io
  • exploring / Exploring WebSockets and Socket.IO
  • URL / Exploring WebSockets and Socket.IO
  • setting up / Adding Socket.IO
• stress tests
  • about / Classifying tests
• strings
  • finding, in file content / Finding strings in the file content
• styles
  • structuring, into nested definitions / Structuring the styles into nested definitions
• Stylus
  • about / Using a command-line tool, Using Stylus
  • using / Using Stylus
• subject / Understanding inter-module communication
  • writing, of test / Writing the subject of our test
• system testing
  • about / Classifying tests

T

• task
  • creating / Creating our own task
• task runner
  • about / Introducing the task runners
• templates, Ember.js / Views and templates
• templates, Ember.js part
  • defining / Defining the templates
• test
  • subject, writing of / Writing the subject of our test
• test-driven development (TDD)
  • about / Test-driven development
• testing methodology
  • selecting / Choosing a testing methodology
  • test-driven development (TDD) / Test-driven development
  • behavior-driven development (BDD) / Behavior-driven development
• test runner
  • about / Classifying tests
• tests
  • writing, significance / Understanding the importance of writing tests
  • writing, benefits / Understanding the importance of writing tests
  • classifying / Classifying tests
  • unit tests / Classifying tests
  • integration tests / Classifying tests
  • functional tests / Classifying tests
  • system tests / Classifying tests
  • stress tests / Classifying tests
  • performance / Classifying tests
• to-do application
  • backend part / Writing the backend of the application
  • frontend part / Writing the frontend
• tweets
  • obtaining, based on user handle / Getting tweets based on a user handle
  • displaying / Displaying the tweets
• Twitter
  • about / Introducing the task runners

U

• unit testing
  • about / Classifying tests
• updateFileArea function
  • tweaking / Tweaking the updateFileArea function
• user
  • transferring, to second screen / Handling the user input and moving to the second screen
• user-to-user communication
  • implementing / Implementing user-to-user communication
  • server part, modifying / Changing the server-side code
  • frontend, modifying of chat / Making changes to the frontend of the chat
• user handle
  • tweets, obtaining based on / Getting tweets based on a user handle
• user input
  • handling / Handling the user input and moving to the second screen

V

• variables, Less
  • defining / Defining variables
• views, Ember.js / Views and templates

W

• Webkit
  • about / Testing with PhantomJS
• WebSockets
  • exploring / Exploring WebSockets and Socket.IO
• working directory
  • displaying / Displaying and using the working directory
  • using / Displaying and using the working directory
  • current working directory, displaying / Displaying the current working directory
  • files, displaying / Showing the files and folders
  • folders, displaying / Showing the files and folders
  • current directory, modifying / Changing the current directory
  • files, copying / Copying, moving, and deleting files
  • files, moving / Copying, moving, and deleting files
  • files, deleting / Copying, moving, and deleting files