High Level Application Routing with StarLogic, StarMap, and StarShine - An idea in the making

I'm usually against using frameworks, but a few days ago I realized I could actually design a framework on top of StarShine. This framework was a fun idea I came up with while discussing top level routing of an application.

I wanted to make a Superset of the MVC framework, that focuses purely on the Business Logic part of your application, hence the name StarLogic.

This pattern models an event listener pattern, but does it in a functionally reactive way. Take the following example:

	var StarLogic = require('StarLogic');
	//create a router
	var app = StarLogic();
	function _newId(bo/*Business Object*/) {
	bo.id = new Guid();
	}
	//if id is falsy, give it a new one
	app.addRule({ id: false }, _newId);
	//returns a finished business object
	app.route({});
	//{id: [object Guid]}

view raw StarLogicExample.js hosted with ❤ by GitHub

The idea with this framework, is to define a bunch of simple rules, and have your business logic execute your functions based on the rules. In the above case, any object that passes through the app.route() function will receive an ID if it isn't set already.

High level application routing can occur when you push a route object to a router like this:

	var StarLogic = require('StarLogic');
	//create a router
	var app = StarLogic();
	//fake database module you made
	var DB = require('./DB');
	function _getUser(route) {
	//this is a shared object namespace
	this.user = DB.getUser(route.id);
	}
	function _routeApplication() {
	//do some application stuff here like change the view
	//do some databinding
	this.user;
	//is the returned user
	}
	app.addRule({ controller: "user", id: true, action: true }, _getUser, _routeApplication);

view raw HighLevelRouting.js hosted with ❤ by GitHub

Any object pushed through app will now be checked to see if every rule definition provided is correct, then it will execute _getUser and _routeApplication passing the business object in question to the functions.

Hey wait a minute, what about complex routing and nested routers? Easy. The route function is portable and doesn't rely on this being anything. Here are some examples of where the route function is placed in a proper way.

	var eventApp = StarLogic();
	var route = eventApp.route;
	//every event object will be passed to eventApp
	document.getElementById('myElement').keydown = route;
	function _42KeyDown (evt) {
	evt.preventDefault();
	}
	//this is a bad idea, but you get the idea
	eventApp.addRule({which: 42}, _42KeyDown);
	var subRouter = StarLogic();
	//some random rule
	eventApp.addRule({ bubbles: true }, subRouter.route);
	//Now any keydown event that bubbles will be passed to subRouter for execution
	//add a rule
	subRouter.addRule({ 1:true });
	//create a list of things
	var items = [];
	items.push({1:1}, {2:2}, {3:3});
	//push them to a router
	items.forEach(subRouter.route);
	//now each item will be processed by your defered logic

view raw functional.js hosted with ❤ by GitHub

Essentially you get to design data processes, define application level logic, and design a framework for your application on top of StarLogic. Move over angular, StarLogic is coming to a store near you.

StarShine - 0.1.0 API Finalized, an App Architecture Tutorial, and Factory Inheritence

Here is the presentation on how to get started on using StarShine.

I'm going to demonstrate now how to actually make an app structured on top of StarShine.

	function _eventify() {
	var handlers = {};
	this.on = function(eventName, handler) {
	(handlers[eventName] = handlers[eventName] || [])
	// add the handler to the array
	.push(handler);
	return this;
	}
	this.once = function(eventName, handler) {
	function wrappedHandler() {
	handler.apply(this.off(eventName, wrappedHandler), arguments);
	}
	wrappedHandler.h = handler;
	return this.on(eventName, wrappedHandler);
	}
	this.off = function(eventName, handler) {
	for (var list = handlers[eventName], i = 0; handler && list && list[i]; i++) {
	list[i] != handler && list[i].h != handler ||
	list.splice(i--,1);
	}
	if (!i) {
	delete handlers[eventName];
	}
	return this;
	}
	this.emit = function(eventName) {
	for(var list = handlers[eventName], i = 0; list && list[i];) {
	list[i++].apply(this, list.slice.call(arguments, 1));
	}
	return this;
	}
	}
	function _exposeThis() {
	return this;
	}

view raw eventify.js hosted with ❤ by GitHub

This _eventify method will turn the private namespace of your module into an event emitter. This is useful for many things, but mostly it's a building block for an event emitter Factory. In order to expose the event factory, we simply return this; to expose the methods to the object. Finally, we wrap it in a StarShine factory. Here are some rules to remember.

1. If the parts you create should remain private, create a closure.
2. If the parts you create should only be exposed and the rest of your closures don't rely on it, create a compound factory
3. If the parts you create should be BOTH, create a factory and create an instance in your closure

In this case, I want the event emitter to be public AND private. Option three is our target.

	var EventEmitter = StarShine(_eventify, _exposeThis);
	function _setupEventEmitter(StarShine, window, document) {
	//this turns the private namespace into an event emitter...
	return StarShine.mixIn(this, EventEmitter());
	//and exposes it to the API we are building
	}
	//Setup the app
	var myApp = StarShine(_setupEventEmitter);
	//Execute your code
	var API = myApp(StarShine, window, document);
	//now API has an event emitter

view raw app.js hosted with ❤ by GitHub

Of course, if you wanted events to be private (and therefore not exposed,) simply include the original function that created the event emitter in the first place. You don't even need the _exposeThis function.

	var APP = StarShine(_eventify);
	APP();

view raw simple eventify.js hosted with ❤ by GitHub

Finally, if I want the methods to simply be exposed without referenced internally, I can do factory re-use.

	var APP = StarShine(EventEmitter, _anotherClosure);
	var API = APP();

view raw Option2.js hosted with ❤ by GitHub

Moving on, we should create a couple of closures that define different portions of our application. I'm going to look for anything with a [data-user-control-1] attribute on my dom and put a link inside of it.

	function _renderAllUserControl1(document) {
	//app is an event emitter
	var map = [].map, app = this;
	function _createFragment (documentElement) {
	this.container = document.createDocumentFragment();
	documentElement.appendChild(this.container);
	}
	function _doSomethingWithContainer() {
	//create a bunch of elements
	var a = this.a = document.createElement("a");
	a.href="#goSomeWhere";
	a.innerHtml = "this is a test";
	this.container.appendChild(a);
	}
	//remember, you're going to be passed the index from the .map function
	function _addAnEventListener(documentElement, index) {
	this.a.onclick = function(){
	//UserControls will be defined in this context, see below
	app.trigger("UserControlClick", UserControls[index]);
	};
	}
	function _buildTheApiForMyControl() {
	var private = this;
	return {
	//these methods will be attached to the UserControls list items
	"remove": function() {
	private.container.removeChild(private.a);
	}
	};
	}
	var controlContainers = document.querySelectorAll("[data-user-control-1]");
	var ControlFactory = StarShine(_createUserControl1, _doSomethingWithContainer, _addEventListener, _buildTheApiForMyControl);
	//index and create a user control for each controlContainer
	var UserControls = map.call(controlContainers, ControlFactory);
	APP.on("UserControlClick", function(UserControl) {
	//this method was returned via _buildTheApiForMyControl
	UserControl.remove();
	});
	return {
	//this will be exposed to your global API
	};
	}
	var APPFactory = StarShine(_eventEmitter, _exposeThis, _renderAllUserControl1);
	var myApp = APPFactory(document);

view raw renderUserControl.js hosted with ❤ by GitHub

This is a lot of code to read, so take your time and re-read it.

On the highest level, we define a process. Inside this process, we define a factory for creating a dom fragment and inject it into the container AND the private namespace for later use inside of the _createFragment function.

Then we create an anchor tag using the terrible dom api (encapsulated and transparent to the API consumer!) and append it to the container defined already.

Then we add a click listener to the anchor in a separate process that triggers a global APP event. The this in the parent closure is a reference to the event emitter exposed by our app.

We define an API for the control that can be consumed by the app and anyone who has access to see the UserControl. I put a remove function into the definition of a "UserControl1" as an example.

Finally, I add an event listener to the app to listen for UserControlClick events and remove the anchor from the DOM.

If you define your Application in terms of functions, suddenly everything is modularized and is much easier to maintain. Embrace the "encapsulate and forget about it" principle because you are making building blocks and tools.

The following example is a good place to start for your app.

	StarShine(function(window, document, StarShine){
	'use strict';
	//Immediately Invoked Inline Function
	//Define your application processes
	function _ApplicationProcess(window, document, StarShine){
	var private = this;//share internal variables between other application processes
	//do some code here
	//APP will be defined here after the whole factory executes
	}
	//execute everything once
	var APP = StarShine(_ApplicationProcess)(window, document, StarShine);
	})(window, document, StarShine)

view raw APP.js hosted with ❤ by GitHub

Experiment and make the code work for you.

Now, onto factory inheritence (as promised!)

	//if your factories return an api
	//and they don't need to share their private state between them
	var myCompoundFactory
	= StarShine(Factory1, Factory2, Factory3)
	.proto(Factory1.proto(), Factory2.proto(), Factory3.proto());
	//Just remember that the parameters need to match up for both factories or you may have a problem

view raw CompoundFactory.js hosted with ❤ by GitHub

If you must accept different parameters, or some kind of state needs to be shared between the factories, maybe it would be best to make the combined factories actual private children of the parent factory. Each factory should be a unit or an encapsulated building block designed to operate all by itself.

StarShine factory composition

It's become a habit of mine to discover and re-create my libraries with a twist using a slightly different technique. The flavor of this week is starshine.

	~function(window, define, module, Array, Object){
	'use strict';
	var slice = Array.slice, create = Object.create;
	function mixIn(target, ref) {
	for (var key in ref) {
	if (ref.hasOwnProperty(key)) {
	target[key] = ref[key];
	}
	}
	return target;
	}
	function StarShine() {
	var enclosed = slice.call(arguments),
	proto = {}, type = "anonymous";
	function factory(options) {
	var obj = create(proto), item, i = 0, _len = enclosed.length;
	options = options || {};
	obj._type = type;
	for(;i<_len;) {
	item = enclosed[i++]
	obj = mixIn(obj,typeof item==='function'?item.call(obj, options)||{}:item);
	}
	return obj;
	}
	factory.proto = function() {
	if(arguments.length === 0) {
	return proto;
	}
	proto = slice.call(arguments).reduce(mixIn, proto);
	return factory;
	};
	factory.type = function(factoryType){
	type = factoryType;
	return factory;
	}
	return factory;
	}
	StarShine.mixIn = mixIn;
	if(module) {
	module.exports = StarShine;
	} else if(define) {
	define(StarShine);
	} else {
	window.StarShine = StarShine;
	}
	}(typeof window !== 'undefined'?window:{},typeof define==='function'?define:null,typeof module!=='undefined'?module:null,[], Object);

view raw StarShine.js hosted with ❤ by GitHub

It's easy to overlook a small library like this. Here are a few of it's features.

• StarShine() returns a factory. It's composed of the closures and objects that it gets passed.
• It has built in internal storage and private "shared" variables. (More on that later)
• Objects are defined by Javascript primitives:
  
  1. reusable closures
     
  2. properties
     
  3. methods
     
  4. prototypes
     
• Works like a function composer

Each function closure should encapsulate a piece of functionality like this:

	function defineA(opt) {
	opt.a = "a";
	//this gets mixed into the object
	return {
	"getA": function getA() {
	return opt.a;
	},
	"setA": function setA(a) {
	opt.a = a;
	return this;
	}
	}
	}
	function exposedA(opt) {
	//opt.a is defined here in this context too.
	//You just inherited private shared variables from another context
	return {
	"doubleA": function(){
	opt.a += opt.a;
	return this;
	}
	};
	}
	function superPrivateVaraible() {
	//functions are now like private storage you can manipulate
	var a = "n";
	//this is the object...
	this.privateA = function(){
	return a;
	}
	}
	//Chainable API...
	var AFactory = StarShine(defineA, exposedA, superPrivateVariable).type("AFactory");
	AFactory();
	//has doubleA, getA, setA, _type: "AFactory", privateA

view raw function example.js hosted with ❤ by GitHub

I cannot stress more that being able to share private variables between closures is a crazy fundamental tool that every developer should use. I have personally used something like this in my personal code:

	function _typeA(opt) {
	opt.x = 0;
	opt.y = 0;
	opt.xV = 1;
	opt.yV = 1;
	}
	function _typeB(opt) {
	opt.x = 50;
	opt.y = 50;
	opt.xV = 1;
	opt.yV = 0;
	}
	function _setType(opt) {
	//direct property writing
	this.x = opt.x;
	this.y = opt.y;
	this.xV = opt.xV;
	this.yV = opt.yV;
	//or
	return {
	x: opt.x,
	y: opt.y,
	xV: opt.xV,
	yV: opt.yV
	};
	}
	var A = StarShine(_typeA, _setType);
	var B = StarShine(_typeB, _setType);
	//Re-usable factory pieces are cool

view raw reusable factory pieces.js hosted with ❤ by GitHub

Each factory has it's own prototype, take the following example.

	function _helloWorld () {
	return {
	'hello': 'world'
	};
	}
	var factory = StarShine(_helloWorld);
	//the proto is already set to an object, so this only mixes methods into the prototype
	factory.proto({
	'getHello': function(){
	return this.hello;
	}
	});
	//this does NOT set the prototype reference
	//no arguments returns the prototype
	factory.proto();
	//{
	// 'getHello': function(){
	// return this.hello;
	// }
	//}

view raw example1.js hosted with ❤ by GitHub

There is no way to make a prototype chain using this method, or maybe there is and I'm lazy, but this seems to be the only way I know to get prototypical inheritance:

factory1.proto(factory2.proto());

view raw proto.js hosted with ❤ by GitHub

If someone comes up with a better idea, I would love to modify my code to make it more flexible. Getting access to the prototype itself is useful with instanceof, but I highly doubt it is necessary. Chances are you probably just wanted to create a new prototype and set the _type property. Given the following example:

	factory.type("CustomTypeHere");
	factory();
	//{
	// "_type": "CustomTypeHere"
	//}

view raw factoryType.js hosted with ❤ by GitHub

Accessing a simple property is probably going to be easier on your code and is simply faster.

This library is everything I love about javascript combined into one tiny little package, and I hope you like it.

Request Animation Frame Loops Demystified - How to get started

Today I'm going to start with using snowblower to make some request animation frame loops.

	~function(window, define, module, Array, Object){
	'use strict';
	var slice = Array.slice, create = Object.create;
	function partial(func) {
	var args1 = slice.call(arguments, 1);
	return function(){
	return func.apply(this, args1.concat(slice.call(arguments)));
	};
	}
	function mixIn(target, ref) {
	for (var key in ref) {
	if (ref.hasOwnProperty(key)) {
	target[key] = ref[key];
	}
	}
	return target;
	}
	function argsMixInExec(args, prev, next) {
	typeof next === 'function' ? next.apply(prev, args) : mixIn(prev, next);
	return prev;
	}
	function SnowBlower(proto) {
	var closures;
	proto = proto || {};
	closures = slice.call(arguments,1);
	return function() {
	return closures.reduce(partial(argsMixInExec, slice.call(arguments)), create(proto));
	};
	}
	SnowBlower.mixIn = mixIn;
	SnowBlower.partial = partial;
	if(define){
	define(SnowBlower);
	} else if(module) {
	module.exports = SnowBlower;
	} else {
	window.SnowBlower = SnowBlower;
	}
	}(typeof window !== 'undefined'?window:{},typeof define==='function'?define:null,typeof module!=='undefined'?module:null,[], Object);

view raw SnowBlower.js hosted with ❤ by GitHub

In whatever context you want, make a SnowBlower factory for a stage. Your runtime should create one instance of a stage for every canvas you need.

	function _animationFunctions(){
	//locally cached reference for speed
	var animationFunctions = this.animationFunctions = [],
	slice = [].slice;
	//we use this as a reference to a no Op function to give our API a way to remove animation functions later
	function noOp(){}
	//store these variable out of here so they never have to be allocated inside of your draw loop
	var _funcIndex = -1, _animationIndex = 0, _len = 0;
	requestAnimationFrame(function draw(){
	_animationIndex = 0;
	_len = animationFunctions.length;
	for(;_animationIndex < _len;_animationIndex++) {
	animationFunctions[_animationIndex]();//call the function!
	}
	//find noOps that were declared inside of the draw loop
	_funcIndex = animationFunctions.indexOf(noOp);
	while(_funcIndex > -1){
	//Always remove EVERY noOp function reference outside of the loop
	animationFunctions.splice(_funcIndex, 1);
	//get the next index
	_funcIndex = animationFunctions.indexOf(noOp);
	}
	});
	this.removeAnimationFunctions = function(){
	var idx = 0, funcIdx = -1, len = arguments.length;
	for(;idx<len;idx++){
	funcIdx = animationFunctions.indexOf(arguments[idx]);
	if(funcIdx>0){
	//this can be called INSIDE OF THE ANIMATION LOOP
	animationFunctions = noOp;
	//DO NOT SPLICE HERE
	}
	}
	};
	}
	var Stage = SnowBlower({}, _animationFunctions);

view raw RequestAnimationFrame.js hosted with ❤ by GitHub

Here it is folks. I did not write specific code for your rendering engine. You need to expose whatever stage to the objects your are creating so they can call this code:

	var myStage = Stage();
	function _drawFunc(options){
	options.stage.animationFunctions.push(function(){
	//do your draw stuff and animation here
	})
	}
	var ObjectOnStage = SnowBlower({}, _drawFunc);
	var obj = ObjectOnStage({
	stage: myStage
	});

view raw ObjectOnStage.js hosted with ❤ by GitHub

Piece of cake. Now all you have to do is pick a rendering engine, render the view in the request animation loop, and create your game.

I suggest using PIXI.js or phaser.js because it's a really great API for canvas rendering. Make sure you do all the work before adding the item to the stage. Remove as many variable declarations outside of the draw function as possible to prevent as much resource allocation and memory leaking as possible. Keep it simple. If you want to pass the draw function a parameter or use "this" as the stage, you can modify your request animation loop like this:

	//reference this for use in other functions
	var self = this;
	//modify loop....
	requestAnimationFrame(function draw(){
	_animationIndex = 0;
	_len = animationFunctions.length;
	for(;_animationIndex < _len;_animationIndex++) {
	//call the function with a reference to the stage object and some arguments
	//passing information to the animation functions can definitely be useful
	animationFunctions[_animationIndex].call(self, arguments...);
	}
	//find noOps that were declared inside of the draw loop
	_funcIndex = animationFunctions.indexOf(noOp);
	while(_funcIndex > -1){
	//Always remove EVERY noOp function reference outside of the loop
	animationFunctions.splice(_funcIndex, 1);
	//get the next index
	_funcIndex = animationFunctions.indexOf(noOp);
	}
	});

view raw modified request loop.js hosted with ❤ by GitHub

In the end, everything is logical and fun.

Have any suggestions? Feel free to comment/post on Google Plus.

Thanks!

~function(){'use awesome';console.log('josh')}();

SnowBlower and Object Composition

	~function(window, define, module, Array, Object){
	'use strict';
	var slice = Array.slice, create = Object.create;
	function partial(func) {
	var args1 = slice.call(arguments, 1);
	return function(){
	return func.apply(this, args1.concat(slice.call(arguments)));
	};
	}
	function mixIn(target, ref) {
	for (var key in ref) {
	if (ref.hasOwnProperty(key)) {
	target[key] = ref[key];
	}
	}
	return target;
	}
	function argsMixInExec(args, prev, next) {
	typeof next === 'function' ? next.apply(prev, args) : mixIn(prev, next);
	return prev;
	}
	function SnowBlower(proto) {
	var closures;
	proto = proto || {};
	closures = slice.call(arguments,1);
	return function() {
	return closures.reduce(partial(argsMixInExec, slice.call(arguments)), create(proto));
	};
	}
	SnowBlower.mixIn = mixIn;
	SnowBlower.partial = partial;
	if(define){
	define(SnowBlower);
	} else if(module) {
	module.exports = SnowBlower;
	} else {
	window.SnowBlower = SnowBlower;
	}
	}(typeof window !== 'undefined'?window:{},typeof define==='function'?define:null,typeof module!=='undefined'?module:null,[], Object);

view raw SnowBlower.js hosted with ❤ by GitHub

I'm going to talk about this "library" and why it's very useful. It takes a lot of the compositional techniques of objects and makes it really fun.

Here's an example of how to use SnowBlower.

	~function(window, SnowBlower){
	var Proto = {
	//prototype stuff here
	};
	function _defaultParameters(options) {
	if(!options){
	throw new Error("options is not defined");
	}
	options.x = options.x || 0;
	options.y = options.y || 0;
	options.width = options.width || 100;
	options.height = options.height || 100;
	}
	function _sprite () {
	//"this" is the sprite you are making
	this.x = options.x;
	this.y = options.y;
	this.width = options.width;
	this.height = options.height;
	}
	var SpriteFactory = SnowBlower(Proto, _defaultParameters, _sprite);
	window.SpriteFactory = SpriteFactory;
	}(window, SnowBlower);

view raw Sprite.js hosted with ❤ by GitHub

It takes all the functions and objects that you pass to it, and either executes it in the context of your new object, or mixes it into your new object. If you need polyfills for your environment, just define Array.prototype.reduce, Object.create, and replace the Object.prototype.hasOwnProperty function to reflect your environment.

It's designed to be small and SnowBlower assumes you have all the pieces and closures that define your object up front. If you need to compose factories, you can just create a function that does it for you.

	var proto = {};
	function PartialFactory() {
	var args1 = [proto].concat([].slice.call(arguments));
	return function(){
	return SnowBlower.apply(this, args1.concat([].slice.call(arguments)));
	};
	}
	//Now pass some arguments to PartialFactory to predefine your factory

view raw PartialFactory.js hosted with ❤ by GitHub

This is a DRY method of reusing functions you have already defined to compose objects. The sky is the limit! Just thought I would share this compositional technique with you.

~function(){console.log('josh')}();

Your Instatouch Library is Cute

I love the JS community. In fact, I think it's the best community to be in programming wise. There is so much support when you need help, especially if you have no idea what you are talking about.

I just want to point out a few things that have taken steps backwards in the past few years when it comes to mobile web experience.

There are at least a dozen different libraries like this: https://github.com/ftlabs/fastclick where the goal is to make the web more responsive. As a mobile phone user, these packages make my experience WORSE. There, I said it.

The reason why it's worse, I've found, is because I like to scroll and read content on the page. If my finger happens to press a link while I am swiping on the page, it fires the click event! This is definitely not good if that link happens to do something very permanent. At best, I found myself pressing the back button so much I gave up completely frustrated with my experience.

My recent experience on cheezburger was rather frustrating because the links take up the whole screen! Maybe I'm just too slow, or JS wasn't designed to do this. I'm willing to accept either, but I'm definitely used to the way browsers work on my phone.

Your Instatouch library is cute, but it makes my user experience more difficult in some cases, and only marginally faster in others. Thanks but no thanks guys, I'll take the DOM as it is.

-Josh

Installing Node.js on my Android Phone

I have the LG Optimus G on Sprint (LS970) and had to do a couple of things to my phone before I could start using node from the command line. I had to root, install TWRP, and then install DebianKit (the biggest offender on being a Pain In my Rear.)

Anyway, here is the steps I took to get everything working.

Some notes I had:

1. I could not install anything useful on my phone using apt-get until I resized the debian.img file on the sdcard.
   
2. I had to do a lot of trial and error before I could finally get the debian image resized correctly
   
3. Installing nvm was easy once I had space
   
4. I had fun
   

In functional health:
~function(){console.log('Josh')}()