Luciano Rodríguez serweb-labs

Provider	Singleton	Instantiable	Configurable
Constant	Yes	No	No
Value	Yes	No	No
Service	Yes	No	No
Factory	Yes	Yes	No
Decorator	Yes	No?	No
Provider	Yes	Yes	Yes

Constant

The Tao of Unix

Rule of Modularity: Write simple parts connected by clean interfaces.
Rule of Clarity: Clarity is better than cleverness.
Rule of Composition: Design programs to be connected to other programs.
Rule of Separation: Separate policy from mechanism; separate interfaces from engines.
Rule of Simplicity: Design for simplicity; add complexity only where you must.
Rule of Parsimony: Write a big program only when it is clear by demonstration that nothing else will do.
Rule of Transparency: Design for visibility to make inspection and debugging easier.

Entidades en Drupal 7

En Drupal 7 se 'mergearon' los usuarios, nodos y taxonomías en una entidad. Las entidades pueden tener campos adicionales a los que ya tenían. Adicionalmente, cada campo puede estar traducido y, por lo tanto, tener distintos valores dependiendo del idioma. En general es mejor acceder a los valores de los campos via APIs en lugar de acceder directamente al campo. Listamos algunas de las funciones más útiles y recomendadas para utilizar:

entity_load() - permite cargar una entidad. Los tipos de las entidades pueden ser 'node', 'user', etc. Ver: entity_load()
field_get_items() - devuelve, dada una entidad y el nombre de un campo la lista de valores que contiene el campo. Ver: field_get_values()
field_view_value() - devuelve un array rendereable con el valor. Para obtener HTML hacer drupal_rend

Golang Workers / Job Queue

A running example of the code from:

This gist creates a working example from blog post, and a alternate example using simple worker pool.

TLDR: if you want simple and controlled concurrency use a worker pool.

Interfaces and protocols

ES2015, The newest iteration of JavaScript, introduces a ton of new features, types, and syntactic sugar. Those have all been explored pretty thoroughly, but the one that has the greatest implications for JavaScript are iterators; not the construct in itself but the use of the Iterator protocol.

Iterators are made possible by two new features: symbols and generators. Iterators are not necessarily a feature on their own, but rather a set of conventions around symbols and generators:

Given that JavaScript does not have interfaces, Iterable is more of a convention:

Source: A value is considered iterable if it has a method whose key is the symbol Symbol.iterator that returns a so-called iterator. The iterator is an object that returns values via its method next(). We say: it enumerates items, one per method call.

	<!doctype html>
	<html ng-app="Demo">
	<head>
	<meta charset="utf-8" />

	<title>
	$scope.$evalAsync() vs. $timeout() In AngularJS
	</title>
	</head>
	<body>

	function getWatchers(root) {
	root = angular.element(root \|\| document.documentElement);
	var watcherCount = 0;

	function getElemWatchers(element) {
	var isolateWatchers = getWatchersFromScope(element.data().$isolateScope);
	var scopeWatchers = getWatchersFromScope(element.data().$scope);
	var watchers = scopeWatchers.concat(isolateWatchers);
	angular.forEach(element.children(), function (childElement) {
	watchers = watchers.concat(getElemWatchers(angular.element(childElement)));

	/**
	* @author qiao / https://github.com/qiao
	* @author mrdoob / http://mrdoob.com
	* @author alteredq / http://alteredqualia.com/
	* @author WestLangley / http://github.com/WestLangley
	* @author erich666 / http://erichaines.com
	*/
	/global THREE, console /

	// This set of controls performs orbiting, dollying (zooming), and panning. It maintains

	/**
	* Fancy ID generator that creates 20-character string identifiers with the following properties:
	*
	* 1. They're based on timestamp so that they sort after any existing ids.
	* 2. They contain 72-bits of random data after the timestamp so that IDs won't collide with other clients' IDs.
	* 3. They sort lexicographically (so the timestamp is converted to characters that will sort properly).
	* 4. They're monotonically increasing. Even if you generate more than one in the same timestamp, the
	* latter ones will sort after the former ones. We do this by using the previous random bits
	* but "incrementing" them by 1 (only in the case of a timestamp collision).
	*/

	<section id="{{ block_html_id }}" class="{{ classes }} clearfix"{{ attributes }}>
	{{ title_prefix }}
	{% if title %}
	<h2{{ title_attributes }}>{{ title }}</h2>
	{% endif %}
	{{ title_suffix }}

	{{ content }}
	</section>