JavaScript for Line of Business Applications

Promises are great for giving us a way of writing asynchronous code without having to indent our code but if that's the only thing you're using them for then you're missing the point of promises. Promises are an abstraction that make doing several things easier. They have two properties that make them easier to work with:

* You can attach more than one callback to a single promise

* values and states (errors) get passed along

Because of these properties it makes common asynchronous patterns using callbacks easy. Here are some cases which may pop up from time to time: 

* Converting callback functions to return promises

* Sequential Calls

* Error Handling

* Pool

* Some fun

React is all about components. So let's build one.

You see that React components are defined using a regular JS object. Some properties and methods of the object such as render() have special meanings, the rest is upforgrabs.

A table is a way to neatly and orderly present some data. The data is front and center, the most important thing. And data is what you should focus on - retrieving, updating, saving, etc.

Once you have the data, you let React take care of the presentation part.

You want the UI to react to changes in the data. So you need a stateful component. Meaning one that has state. This is easier than it sounds.

As you can see the state is an object. Simple as that, the old familiar {key: value}situation. In this case the state is just one property of the state object, appropriately named data. ...

After reading a lot of articles and sample code it wasn’t clear to me what the difference was between the several providers like provider, factory and service. Without this knowledge you could not select the proper provider. I will explain the differences between the providers with examples.

AngularJS uses $provide to register new providers. The providers basically create new instances, but only once for each provider. The $provide has six methods to create custom providers and I will explain each one of them with the help of sample code. These providers are available on $provide:
* constant
* value
* service
* factory
* decorator
* provider

I have recently been working with AngularJS and I have to say, I haven't felt this productive since Rails. I'm a bit of an architecture nut and AngularJS gives me all the building blocks to build a well structured application.

The first building blocks that everyone learns are filters. They are one of a few ways to get presentation logic out of your business logic. Filters format data to be displayed to the user. In this post, I will show you how to build a simple phone number filter. First, lets see how filters would work.

Filters are functions that are passed an expression.

n AngularJS, it is best to build a bunch of smaller modules and then craft them together to build a larger application. Not only does this make it easier to test, but it becomes very easy to reuse components. Following that mantra, we will build a filter as a standalone module.

A filter is just a function that is executed on some input.

In this article I'll showcase basic ember features and ember application development process for a Django-Tastypie-Ember application.

As you can read on ember website the framework has few layers, similar to Django or other frameworks. I won't repeat what's written there. I'll just give a quick overview from a Django developer point of view.

tastypie is a handy app that will make an REST API for use to use in ember application. To make a Tastypie resource we first need to have a Django model. When we have working Tastypie resources we can start creating models in ember application. Data aspects in ember are handled by ember-data.

At first many things in ember may look like magic (events and asynchronous actions), but when you look how this basic app is being made and how it works - the magic will become clear (or you will become a sorcerer which is cool anyway :)).

In this post, I’m going to take a close look at how JavaScript’s prototypal inheritance works by analysing how Microsoft’s TypeScript language uses it to provide a simple implementation of classes. Don’t worry if you’ve never used TypeScript, we’re not really concerned with the language itself here, just the JavaScript that is produced by its compiler, and how it achieves class-based inheritance in a language that doesn’t natively support it.

This is of particular importance because EcmaScript 6 will include classes that work a lot like TypeScript’s. The idea of adding classes to JavaScript is controversial, but I think some of the hostility stems from a mistaken belief that classes are some kind of competing inheritance mechanism to prototyping, or are an attempt to turn JavaScript into Java. In fact, modern proposals for classes in JavaScript are just a syntactic codification of prototypal inheritance patterns that are already in use.

Falcon.js is an MV* framework that helps organize small and large single-page applications that wish to utilize Knockout.js for templating and data binding. Models represent individual data objects that need to sync with server data.

Falcon.js is an MV* framework that helps organize small and large single-page applications that wish to utilize Knockout.js for templating and data binding. Falcon provides:

* Models represent individual data objects that need to sync with server data
* Collections represent a list of models and provide numerous list filtering methods
* Views relate functionality between data objects and Knockout templates

ES6 is coming and with it brings many great things that will help us develop better and faster web applications. Let’s have a look at the most significant ones.

In ES6 there is a lot of syntax sugar that will shorten development time and speed up our applications. Let’s have a taste, shall we?

Finally, ES is turning into a true object-oriented language. With the introduction of classes, we can write our code in a clean and structured way. It will remove the need for the current coded solutions present in nearly every popular library...

* Syntax Sugar
* Classes
* Modules
* Maps and Sets
* Iterators
* Weak Maps
* Proxies
* Template Strings
* Conclusion

Developing a web application with with Ember.js is awesome but can sometimes be a little tricky. Every now and then you figure something out that help you every day. Here's a small extension of Ember.Object that we use as a base for practically all of our resources.

The app I'm developing consist of resources holding data that the user want's to edit, sometimes a few at a time. We need an edit mode and restore on cancel functionality. This is out starting point, so let's start extending!

One of the most frustrating parts of writing web apps is DOM manipulation and event handling. To demonstrate this, let's use this common scenario - we want to hide an element and show another one when a user click on the 'add-note' textbox.

We will look at two way of doing it - one with jQuery and the other with Ractive.js. At the end we'll talk a bit about Ractive.js and how it compares to AngularJS and Ember.js.

This plunkr demonstrates a few different scenarios and capabilities when moving data between a model and a directive. Like other places in Angular JS there are quite a number of different approaches that work, which grants a lot of flexibility but also leads to some confusion.

The example uses a simple controller.

he first version of valueDisplay will put the value on the screen, but will never update the screen if the magic value changes. This approach is only reasonable for static data since the directive reads the value directly from the controller’s scope (using the name specified in the attribute), places the value in the element, then never looks back.

The second version of valueDisplay uses a $watch to update the screen as the model value changes. Notice the attribute value (value="magicString")  is still working like an expression to retrieve and watch data directly from the controller’s scope.

Hi all! I was recently working on a blogpost about developing a cutting-edge web application using Rails + Ember.js. And guess what! Suddenly, Ember.js reached its final version: 1.0.0, that's it, no more release candidates!

Along with this first final version, the Ember.js core team released Ember Data 1.0.0-beta.1, and if we compare it with the previous version 0.13, it has a lot of changes, so upgrading your old Ember.js application could be a bit messy!

Why am I saying this? Well, because your application might stop working! As you probably know, JavaScript applications have a tendency to break with the slightest change.

So, here I just want to show you the most important changes that I found while I was upgrading my Ember.js example application. It's worth mentioning that the major changes come from Ember Data.

* Models

* Adapters & Serializers

* Retrieving data from the server

* Controllers

* Upgrading Ember.js from a Rails application

* Conclusion

Knockout.js is a very powerful 2-way binding MVVM framework for JavaScript built by Steve Sanderson. The basic idea is rather than work directly with the DOM, a ViewModel ties a JavaScript object to the DOM and any updates to the ViewModel are automatically reflected in the DOM and any DOM changes are reflected in the ViewModel. It provides very little opinion on specifics about how to structure applications which makes it flexible.

Below are some tips and tricks I've learned in using Knockout in a few large scale applications.

* Context Issues
* Better ViewModels with a BaseViewModel
* Accidental Rendering Templates
* Using Extenders
* Working with fn
* Require.js
* Custom Bindings
* Conclusion

You’ve probably heard it a thousand times now. “AngularJS teaches HTML new tricks.” The way it does that is through directives. In my last related post I covered how to build a testable filter. Directives can be tested in a similar fashion, but what happens when they have to interact with the rest of your application? Instead of teaching your controllers how to talk to UI components, or overloading the $scope object, look to services as the mortar to hold pieces of your app together.