moschel

What the Senior Dev does

1. Architecture decisions - They will be another set of eyes to help make decisions about setting up the appropriate architecture.
2. Oversight - They see the project from the eyes of an outsider, making easier to spot holes. They look for problems and make sure best practices are being followed.
3. Adds value with quick projects - Things like setting up CI, setting up deployment scripts. Quick win projects that improve project efficiency that are hard for other developers to make time for.

Benefits for the project

1. Quality - Having a developer who can oversee the project, even at 20% time, means the quality of the code goes up dramatically.
2. Backup plan - If the main developer gets sick, goes on PTO, or leaves the company, we have someone else who can get up to speed quickly in an emergency, or at least help smooth the transition.
3. Developer longevity - We’ve found that developers on projects without this in place have a high chance of quitting the project and Bitovi. Ad

moschel

title	tags	author	lead	layout
CanJS 2.0 Release Notes	open-source canjs	justinbmeyer	Today we're happy to announce the latest major release of CanJS.	post

CanJS 2.0 is out! It packs new features that advance CanJS' mission to make JavaScript application development even easier. This article will introduce the changes. It brings:

moschel

Live bound templates in CanJS completely change how we build UI controls. When used correctly, live binding gives you far greater separation of concerns and code that is easier to understand and refactor.

In this article, we'll illustrate the clear advantages to using data driven, live bound UI controls, and show how to implement this in your own apps.

Advantages

Live bound templates provide a greater ability to keep UI Control code as semantic as possible, removing most or all of the manual DOM manipulation code that was necessary without live binding.

With live binding, the UI Control strictly maintains the “state” of the control, leaving the visual representation of that state to the View.

moschel

Error in user YAML: (<unknown>): could not find expected ':' while scanning a simple key at line 5 column 1

--- 
title: Weekly Widget 7 - Computes and Sliders
tags: open-source canjs
author: justinbmeyer
lead: Learn why can.compute is the last API you will ever need as we explore using it
in a slider.
layout: post
---

Computes are amazing, especially when

moschel

CanJS and Backbone both provide structure for JavaScript applications through an MVC-like pattern.

CanJS

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

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.

moschel

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.

Live Binding

Backbone has no concept of binding data object and their changes to your templates.

moschel

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

moschel

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

moschel

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) {

moschel

3.2's $.Controller - Templated Event Binding Goodness

JavaScriptMVC 3.2 brings a lot of great features and enhancements. So many features that changes to $.Controller didn't make the cut for our upcoming 3.2 article. This article reviews 3.2's $.Controller and talks about templated event binding (something we neglected to write up for 3.1).

Bind and Memory Leaks

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