Skip to content

Instantly share code, notes, and snippets.

View moschel's full-sized avatar

Brian Moschel moschel

View GitHub Profile
moschel /
Created August 28, 2015 07:20
20% Senior Dev at Bitovi

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
View 2.0.markdown
title tags author lead layout
CanJS 2.0 Release Notes
open-source canjs
Today we're happy to announce the latest major release of CanJS.

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 / Data Driven
Last active December 31, 2015 12:08
Data Driven Controls
View Data Driven

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.


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.

View Weekly Widget 7 - Computes and
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


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.

moschel /
Last active August 23, 2016 13:03
CanJS vs Backbone

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 /
Created February 8, 2013 23:49 — forked from justinbmeyer/
title tags author lead layout
Weekly Widget 4 - Paginated Grid
open-source jquerypp
Learn to use jQuery++'s $.Range to create content aware show / hide buttons.

This week's widget demonstrates the awesome power of jQuery++'s range helper. $.Range

moschel /
Last active December 12, 2015 08:18

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 / proxy.js
Created November 9, 2011 06:46
Funcunit proxy
View proxy.js
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 /
Created October 18, 2011 05:57 — forked from justinbmeyer/
Templated Event Binding

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