The following is a VERY rough draft of an article I am working on for Alex MacCaw's @maccman's Book. It is very rough, but even now a worthwhile read. Suggestions / comments are very welcome! Please help me :-)
JavaScriptMVC (JMVC) is an open-source jQuery-based JavaScript framework. It is nearly a comprehensive (holistic) front-end development framework, packaging utilities for testing, dependency management, documentation, and a host of useful jQuery plugins.
Yet every part of JavaScriptMVC can be used without every other part, making the library lightweight. Its Class, Model, View, and Controller combined are only 7k minified and compressed, yet even they can be used independently. JavaScriptMVC's independence lets you start small and scale to meet the challenges of the most complex applications on the web.
This chapter covers JavaScriptMVC's
JavaScriptMVC's views are really just client side templates. Client side templates take data and return a string. Typically, the strings are HTML intended to be inserted into the DOM.
$.View is a templating interface that takes care of complexities using templates:
jQuery 1.6 brought Deferred support. They are a great feature that promise to make a lot of asynchronous functionality easier to write and manage. But many people struggle with uses other than 'waiting for a bunch of Ajax requests to complete'. For JavaScriptMVC 3.1, we identified an extremely common but annoying practice that becomes a one-liner with deferreds: loading data and a template and rendering the result into an element.
JavaScriptMVC 3.2 brings a lot of great features and enhancements. So many features that changes to
Neglecting to unbind event handlers is the easiest way to create memory leaks. This is extremely common in an MVC architecture as you constantly listen for model changes:
Task.bind('created', function(ev, newTask){
// add task to list
| var fs = require('fs'), | |
| path = require('path'), | |
| http = require('http'), | |
| host = '', | |
| port = 80, | |
| localport = 9999 | |
| // parse out command line options | |
| process.argv.forEach(function(val) { | |
| if (val.indexOf('--host') == 0) { |
Title: KnockoutJS vs CanJS
This article will be a comparison of KnockoutJS to CanJS. Many developers have asked us how CanJS compares directly to other libraries. While often not a apples to apples comparison, having a good understanding of the differences between MV* libraries will help you make the right choice for how to build your apps.
Knockout's MVVM Pattern - Live bound templates coupled with observable objects, heavily influenced the development of CanJS.
But Knockout basically stops there, a library aiming at providing live bound templates and observable objects. CanJS is that and so much more (model layer, routing, better widget modularity support).
If you choose Knockout to build your large JavaScript application
| title | tags | author | lead | layout |
|---|---|---|---|---|
Weekly Widget 4 - Paginated Grid |
open-source jquerypp |
justinbmeyer |
Learn to use jQuery++'s $.Range to create content aware show / hide buttons. |
post |
This week's widget demonstrates the awesome power of
jQuery++'s range helper. $.Range
Backbone helps you structure your application. This is great, but it doesn't solve the whole problem. CanJS helps you structure your application and lets you actually focus on the part that matters, which is your data.
CanJS essentially gives you all the simplicity of Backbone (model and control layer and no weird asynchronous event loop like Ember and Angular), along with more advanced features that make writing apps much faster and the code more maintainable.
Backbone is popular because its very simple and easy to understand. They are aiming for that level JUST above basic jQuery development, people who just learned jQuery and are looking for a way to organize their code a bit more. It provides this. So does CanJS. But for large complex applications, Backbone lacks a lot of the things we need to make a great app.
Backbone has no concept of binding data object and their changes to your templates.
CanJS and Backbone both provide structure for JavaScript applications through an MVC-like pattern.
CanJS is a lightweight MVC framework built to provide structure for JavaScript applications. It is aimed at developers of any library who need a battle-hardened library that makes building complex applications easy. It is part of a larger offering named JavaScriptMVC from Bitovi (its creators) that has documentation, testing and dependency management tools.
Backbone is a flexible, minimalist solution for seperating concerns in a JavaScript application. It provides just a little bit of structure to a jQuery application and has largely attracted developers who know just enough jQuery to get by and now want to organize their code a bit more.