JavaScript for Line of Business Applications

Ember components are based on of the W3C Web Components specification. The specification is comprised of four smaller specifications; templates, decorators, shadow DOM, and custom elements. Of these four concepts only three of them have harden specifications, decorators being the exception. By having the specifications in place, framework developers have been able to polyfill these new APIs prior to them being implemented by browser vendors.

Web Components provide true encapsulation for UI widgets. Below is a diagram of how a component works at the most basic level.

While Ember has successfully polyfilled a lot of a specification, frameworks like AngularJS, Dart, Polymer, and Xtags have similar solutions. The only caveat here is that Ember and Angular currently don’t scope styles to the component. Over time, these polyfill solutions will fade away, and frameworks will adopt the browser vendor’s implementation. This is a fundamentally different approach to development, as we can take advantage of future specifications without tying ourselves to experimental features in browsers.

A community project dedicated to collecting resources for the Angular.js framework. You find here easy to follow cookbook style recipes for issues you are likely to face when working with Angular.js.

Performance testing is really a tough task. If the matter was to compare ember and angular, with their given features, simplicity or number of lines in the code, it really become simple as it atleast has a platform. But measuring performance depends on browser, number of environmental factors, data transfer, type of your app, code quality, logic and much more. And the judgement factors are simply the speed and accuracy. But it’s really a variable thing to judge, as the test cases play their roles.

Today with few chosen test cases I would like to show you the visible difference between ember and angular. How according to implementation cases their behavior changes, how they exactly works and these things will help you to choose the right one between ember and angular  for your application.

* Installing Sails and Create Initial Project
* Creating a sign-up page, ‘first-look’ at routes, and adding twitter bootstrap.
* Creating a user model and controller
* Creating a user account
* handling validation errors with a flash message
* Creating a policy and adding client-side validation
* Adding a show action (a.k.a. a Profile Page
* Building an admin page.
* Deleting a user account.
* Changing databases to mongoDB with sails adapters.
* Encrypting passwords with bcrypt.
* Starting a project in the middle using git clone.
* Sign-in page, session controller, new action, and sessions.
* User authentication and restricting access through policies.
* Improving user authenticated navigation.
* Fixing and issue with policies from episode 14.
* Creating a distinction between admin and regular users
* Understanding Web sockets and socket IO including room creation and management
* Create the necessary ui and mechanics for sign-in and sign-out in preparation for using web sockets.
* Adding real-time events to models in 4 lines of code
* Marshalling request parameters
* Integrating socket.io and sails with custom controller actions using Real Time Model Events.
* Manipulating the DOM based upon changes via Real Time Model Events.
* Adding real-time flash messages using real-time model events.
* Correcting a publishUpdate event and adding a policy to the user controller’s subscribe action
* What is CommonJS in relation to node? What does it do? How do I use it?
* Deploying a sails app to Heroku.

In this final article, we’re going to demonstrate some additional concepts that build upon the “full” demo we built in the last article. To be clear, you must be caught up on the series or this entry will be difficult to follow, so you may also want to check out part one.

At the end of last post I quoted the eye-opening comment that Graph Grandmaster Wes Freeman left on one of my questionson Stack Overflow. Following his advice I decided to change the way each of the queues in my application was handled, adding two extra nodes, the head and the tail.

I am very satisfied with how much simpler the new queries are, both to write and to understand, when compared to the older one discussed in the previous post of this series. At this point Wes suggested to run some performance tests. The results can be found below. Not much of a difference from a performance point of view – especially because this was an end-to-end performance test, calling N times the server, executing one insertion/archival at a time.

There are basically two different ways of implementing server side authentication for apps with a frontend and an API:

* The most adopted one, is Cookie-Based Authentication (you can find an example here) that uses server side cookies to authenticate the user on every request.

* A newer approach, Token-Based Authentication, relies on a signed token that is sent to the server on each request.

Putting business and other logic within services has many advantages. First it fulfills the principle of separation of concern or segregation of duties. Each component is responsible for its own work making application more manageable. Second this way each component can be more testable. AngularJS provides first class support for unit testing. Thus we can quickly write tests for our services making them robust and less error prone.

Consider above diagram. Here we divide our application in two controllers: 1. Profile and 2. Dashboard. Each of these controllers require certain user data from server. Thus instead of repeating the logic to fetch data from server in each controller, we create a User service which hides the complexity. AngularJS automatically inject User service in both Profile and Dashboard controller. Thus our application becomes for modular and testable.