vsb>А MVC хорошего как не было, так и нет нигде

var x = Behavior.variable(3);
var y = Behavior.variable(5);

function calc(x, y, z) {
  return x + y * z;
}

var res = Behavior.apply(calc, [x, y, 7]);
var elt = UI.div(UI.text(res));
Behavior.appply(alert, res);

x.set(10);
y.set(20);

function filter(spec, items) {
  var res = [];
  items.foreach(function(item) {
    if (item.firstName == spec.firstName && item.lastName == spec.lastName)
      res.append(item);
  });
  return res;
}

function mkSpec(firstName, lastName) {
  return { firstName : firstName, lastName : lastName };
}

var firstName = ...
var lastName = ...
var allItems = ...

var itemsToShow = Behavior.apply(filter, [Behavior.apply(mkSpec, [firstName, lastName]), allItems]);
var itemPages = Behavior.apply(paginate, [itemsToShow]);
var pageToDisplay = Behavior.apply(Arrays.itemAt, [itemPages, currentPage]);

function blackMagic(x, y, z) {
  return x + y *z;
}

//Knockout:
var x = ko.observable(5);
var y = ko.observable(7);
var z1 = ko.computed(function() {
  return blackMagic(x.value(), 42, y.value());
});
var z2 = ko.computed(function() {
  return blackMagic(4, x.value(), x.value());
});

//Mine:
var x = R.variable(5);
var y = R.variable(7);
var z1 = R.apply(blackMagic, [x, 42, y]);
var z2 = R.apply(blackMagic, [4, x, x]);

function f1(x, y) {
  return 2 * x + y;
}
function f2(x, y) {
  return x - y + 4;
}
var a = R.variable(1);
var b = R.apply(f1, [a, 3]);
var c = R.apply(f2, [a, 9]);
var res = R.apply(f1, [b, c]);
R.apply(alert, [res]); 
// Сколько будет алертов при вычислении следующей строки:
a.set(10);

// Какие-то глобальные (или долгоживущие) observable.
var globalA, globalB;

// Временный scope (например, диалоговое окно)
var session = R.session();
var x = R.variable(123);
var a = session.proxy(globalA);
var b = session.proxy(globalB);
var y = R.apply(fn, [a, b, x]);
//...
// При закрытии окна
session.destroy();

namespace KindOfModel {
  var x = 5;
  var y = 7;
  var z1,z2;
  
  @observing "x" "y"  
    function() { z1 = x + y + 42; }

  @observing "x" 
    function() { z2 = 2 * x + 42; }
}

<form model="KindOfModel">
  <label>X</label> <input(x)>
  <label>Y</label> <input(y)>
  Z1: <output(z1)> and Z2 <output(z2)>
</form>

var group = Async.group();
var preop1 = group.add(startPreop1());
var preop2 = group.applyAsync(startPreop2, [preop1]);
var preop3 = group.applyAsync(startPreop3, [preop2]);
var ajaxQuery = group.applyAsync(doLongLastingOp, [preop3]);
var postOp1 = group.applyAsync(startPostOp1, [ajaxQuery]);
var postOp2 = group.applyAsync(startPostOp2, [postOp1]);
var postOp3 = group.applyAsync(startPostOp3, [postOp2]);

R.apply(function(state) {
  switch (state.state) {
    case 'progress' :
      console.log('Progress is ' + state.progress);
  }
}, [group.progress]);

// cancellation:
group.cancel();

// functions:
function startPreop2() {
  // Staightfroward. between ajax and async API.
  return Net.call(....);
}

Async.group = function() {
  // Observable array.
  var ops = R.Arrays.variable();
  // Observable array of observables!
  var progresses = R.Arrays.mapValues(ops, function(op) {
    // Это будет behavior!
    return op.progress;
  });
  // Observable array of "progress values"
  var flatProgresses = R.Arrays.flatten(progresses);
  // Create behaviour which is sum of all progresses in the 
  // observable array (reduce operation).
  var totalProgress = R.Arrays.reduce(flatProgresses, 0, function(sum, state) {
    switch(state.state) {
      case 'progress': return sum + state.progress;
      case 'success' : return sum + 1;
      case 'error' : return sum;
      default: return sum; // log error
    }
  });
  var totalElems = R.Arrays.lenghtBehaviour(flatProgresses);
  // Среднее арифметическое, допустим, мы так считаем прогресс.
  var progress = R.apply(function(prog, count) {
    return count > 0 ? prog / count : 0;
  }, [totalProgress, totalElems]);
  
  return {
    'add' : function(op) {
      ops.push(op);
    },
    'applyAsync' : function() {
      var op = Async.applyAsync(arguments[0], arguments.slice(1));
      ops.push(op);
      return op;
    },
    'progress' : progress,
    'cancel' : function() {
      ops.foreach(function(op) { op.cancel(); });
    }
  }
}

• reactive programming (core) — 3-5 дней (я за один-два пишу уже)
  
• async wrappers (using reactive) — 3-5 дней (тоже один/два по коду, но нужно приличное reactive programming и еще дополнительное время на выяснение требований (специфичных для данного конкретного проекта)).
  
• UI core ~ 3 дня для первых экранов, еще пару дней растянуто на 2-4 недели (пишется по мере необходимости).
  
• Advanced UI 3-5 дней, растянуто по сроку жизни проекта (т.е. от месяца до нескольких месяцев).
  
• Networking layers — 3-5 дней. Это всякие фишки, которые умеют выводить сообщения об ошибках и т.п. Мое любимое — предложить пользователю залогиниться и повторить операцию, если у него истекла сессия (без перезагрузки страницы, естественно). Собственно, этот networking layer нужен в любом приложении. Поверх async, promises и т.п. — не важно, все равно писать надо.