Scalera tips: How NOT to change your actor’s state

Intedezting, as a newbie, I would have done it wrong

Scalera

A common key when working with Akka, is modifying properly our actor’s state. If we jog our memory, this framework paradigm allows us to program modeling the concurrency based on actors and message passing. From that base, we could define an actor as a computing unit that may have state and perform tasks based on messages that it will receive through its mailbox and that will be processed sequentially .

That means that, in order to avoid side effects, the actor’s state modification has to take place when processing a message. So senseful so far. However, it’s a pretty common mistake to do something similar to this:

In this case, we have no more warranty that the state change (whose only responsible of keeping it consistent and thread safe is the actor) might cause side efects given that, in the precise moment where the Future modifies the var, it’s…

Ver la entrada original 139 palabras más

Tipos dinámicos

Scalera

Hoy traemos un poco más de magia negra. Leyendo el otro día un poco sobre los procesos de mejora de Scala (SIPs) me encontré algo que realmente me llamó la atención: tipos dinámicos.

¿Qué son?

Los tipos dinámicos permiten definir el comportamiento de un objeto cuando se invoca un método o se intenta acceder a un miembro que no existe. Por ejemplo:

dará un fallo en tiempo de compilación. Con los tipos dinámicos podemos decir que en caso de que se invoque a un método, se llame como se llame, devuelva cierto valor.

¿Cómo funcionan?

Para poder utilizar los tipos dinámicos, es preciso importar import scala.language.dynamics y extender del trait Dynamic:

La clase (o trait) que definamos puede tener todos los atributos y métodos que queramos, pero además podemos implementar los siguientes métodos:

applyDynamic

este método se encarga de gestionar las llamadas a métodos de la instancia.
Si queremos…

Ver la entrada original 340 palabras más

Parallel MapReduce in Python in Ten Minutes

Some years old but nicely explained 😀

Cvet's Blog

Almost everyone has heard of Google’s MapReduce framework, but very few have ever hacked around with the idea of map and reduce. These two idioms are borrowed from functional programming, and form the basis of Google’s framework. Although Python is not a functional programming language, it has built-in support for both of these concepts.

A map operation involves taking a function f and applying it on a per-element basis to a given list L. For example, if f was the square-root function, then the map would take the square of each element in L. A reduce operation (also known as folding) is similar in that it also applies a function g to a given list L, but instead of isolating on each element, g systematically accumulates or collapses the contents of L into a single result. The canonical example of this would g performing a…

Ver la entrada original 876 palabras más

Añadir un metabox a varios tipos de post en WordPress

En WordPress, a veces tenemos que añadir un meta_box a TODOS los tipos de post, sean del tipo que sean… o tal vez a muchos de ellos.

He visto que mucha gente lo que hace es coger el hook “add_meta_box” y llamarlo dentro de un foreach con los tipos a los que se lo quiere añadir… lo cual yo creo que no es correcto,y que debería hacerse como sigue

<?php
function poner_mi_metabox( $tipo ) {

	$post_types = array_values( get_post_types() );
	$excluded_types = array('excluido1', 'excluido2');

	$post_types = array_diff($post_types, $excluded_types);

	if( in_array($tipo, $post_types) ){
		add_meta_box( 'mamor_meta_box', 'Título del metabox',
		'display_el_meta_box', "$tipo", 'side', 'high' );

	}

}

function display_el_meta_box(){
	echo "contenido del meta box";
        //no me pongas aqui el HTML por favor! hazte una plantillica o algo
}

add_action( 'add_meta_boxes', 'poner_mi_metabox' );
?>

Lo que hemos hecho es que cuando se lance el hook “add_meta_boxes” se llame a la funcion “poner_mi_metabox”, que recibe, en cada llamada, el tipo de post que se está evaluando.

Tomamos todos los tipos de posts existentes en nuestro wordpress y le quitamos los que no nos interesen (por ejemplo, attachment sería un candidato en mi caso…), de manera que, si el tipo de post que se está evaluando es de uno de nuestros tipos aceptados, le añadimos la meta box.

Así de simple!

Y bueno, si lo que queremos es sacar solo una lista de los custom_post_types que tenemos, podemos hacerlo usando los argumentos que admite la función… tal y como está en la web de WordPress:

<?php
$args=array(
  'public'   => true,
  '_builtin' => false
);
$output = 'names'; // names or objects, note names is the default
$operator = 'and'; // 'and' or 'or'
$post_types=get_post_types($args,$output,$operator);
  foreach ($post_types  as $post_type ) {
    echo '<p>'. $post_type. '</p>';
  }
?>

Clases en Javascript: The right way

Como bien me apuntan por ahí ( y sin acusar a nadie! jajaja @o0Lillo0o), a la hora de crear clases en javascript no es bueno ni eficiente definir funciones en el propio objeto, sino que lo suyo es hacerlo en el prototype.

Aquí veremos como se ha de crear una clase en Javascript bien hecho (al menos con mi nivel :-p). Crearemos las clases como funciones.

Por ejemplo, creemos una clase Coche. Para ello definiremos que el constructor recibe el nombre del coche.

function Coche( nombre ){
	this.nombre = nombre;
}

Coche.prototype.setNombre = function (nombre){
	this.nombre = nombre;
}

Coche.prototype.getNombre = function (){
	console.log(this.nombre);
}

var c = new Coche("ford");
c.getNombre(); //ford
c.setNombre("Angel del infierno");
c.getNombre(); //adivina!

Y así para cualquier funcion de clase que necesites, se la añades al prototype….

 

Espero que esta opción sea más purista 😉

Singleton en Javascript

Toda persona que programa se ha topado alguna vez con los patrones de diseño, algo que yo creo que, cuando los aprendes (en mi caso en la Universidad se ven algunos y los aplicamos en Java) son un truño algo aburrido ya que todo sacado de contexto lo es.

Una vez que empiezas a meter el morro en el mundo de la programación y no eres no solamente el único que programa (es típico que haya grupos de 2 o 3 como máximo en España a la hora de hacer la mayoría de las prácticas) sino que la aplicación la usa mucha, mucha gente a la vez, te das cuenta de que los patrones de diseño no solamente son necesarios y útiles, sino que además… molan.

Aquí quiero ir poniendo algún que otro patroncillo y la intención es implementarlos en Javascript 🙂

Uno de los patrones más sencillos y que nos sirve para empezar, es el “Singleton”. Este patrón nos sirve para tener una única instancia de una clase, de manera que cualquiera que acceda a esa clase, trabaje sobre la misma instancia.

Esto, para una clase “Usuario” no vale para nada, ya que cuando creo un usuario y lo manipulo, quiero que sea nuevo y único… pero por ejemplo para manejar un objeto de conexión a una base de datos, sí que nos interesa que se acceda a uno solo, de manera que no tengamos 40.000 conexiones abiertas con la BBDD sino solamente una.

Para eso, nos tenemos que asegurar que nadie puede instanciar objetos de la clase ( La instancia se devuelve típicamente con un “getInstance()” )

var ClaseSingleton = (function () {

  // instancia que usaran los demas
  var instance;

  function init() {

    // Singleton

    // metodos que no podran ser accedidos por
    // nadie que use la instancia

    function _metodoPrivado(){
        console.log( "No me ves" );
    }

    var _variableProvada = "Soy inalcanzable para ti";

    var _numAleatorio = Math.random();

	//Esto es lo que devuelve la funcion init(), privada dentro de
	//la clase singleton. Lo que devuelve son, en definitiva
	//las funciones que hacemos publicas

    return {

      // Cosas publicas
      metodoPublico: function () {
        console.log( "Mirameee!" );
      },

      propiedadPublica: "Soy de todos ;)",

      getNumAleatorio: function() {
        return _numAleatorio;
      }

    };

  }; //fin init()

	//esto es a lo que obtendra acceso cualquiera que instancie el singleton
	//solo le damos opcion de hacer el getInstance()
  return {

    // Nos da la instancia si existe
    // o crea una nueva si no existe
    getInstance: function () {

      if ( !instance ) {
	    //el objeto tendra los metodos y props que devuelve init en el return!!
        instance = init();
      }

      return instance;
    }

  };

})();

¿Qué está pasando?

La “clase estática” ( Para simular la clase estática, hacemos una función que se ejecuta en cuanto se define, de manera que no es un objeto instanciable en javascript mediante un “new”, como sería una “clase” normal. ) “ClaseSingleton” tiene, digamos, dos partes: parte privada y la parte pública.

Para hacer una parte privada, es decir, inalcanzable desde fuera de la clase, escribirmos código dentro de la función que simula la clase con normalidad, esto es, creamos variables, funciones… lo que sea necesario, pero para que podamos controlar lo que se hace público y cómo, usaremos la sentencia “return”, devolviendo un objeto javascript que contendrá lo que queramos hacer público.

Es decir, ClaseSingleton puede tener 187 funciones pero si en el return solamente devolvemos una función, esa será la única pública.

Es decir, lo público irá en el objeto del return.

Lo que se hace aquí es dar solamente acceso a aquellos que usan nuestra clase a una función llamada getInstance que devuelve la instancia o la crea en caso de no existir. Cuando la crea, lo hace a través de la función “init” (el nombre es arbitrario, podrias llamarlo de otra manera…). Al llamar a la función init() lo que hace es obtener lo que esta funcion le devuelve en su return, que es un objeto javascript que contiene funciones y variables, que son en realidad, las acciones que ofrece nuestra clase.

 

Más información y MUY buena sobre patrones de diseño en javascript aquí.

 

Clases en Javascript

En Javascript no existen las clases como las conocemos en Java o en C# o en PHP… pero se pueden simular de forma muy chula mediante una función. Para ello, tenemos que seguir esta estructura y listo


function nombreClase(){
	//atributos
	var a1 = "hola!";
	var _a2;

	//funciones
	function _f1(){};
	function f2(){ console.log("ejecuto f2"); };

	//return con la interfaz que ofrecemos
	return{
	    varPublica: a1,
	    funcionDeLaClase: f2
	}

};

Aquí no hay mucho que explicar, solamente que si instanciamos un objeto e la clase, solamente tendremos acceso a “varPublica” y “funcionDeLaClase”, tal y como hemos definido…

Aquí meto unos pantallazos para que veais como se puede probar en la consola de chrome 🙂

Se puede ver que varPublica y funcionDeLaClase estan disponibles

Se puede ver que varPublica y funcionDeLaClase estan disponibles

 

ejemplo de ejecución:

acciones clase

Venga, juega un poco y define tus propias clases!