PHP : Simular contextos anidados

Viendo el código generado de Twig se me ocurrieron varias cosas para mejorar el rendimiento. En primer lugar hay una serie de funciones que se llaman muchísimo y que se podrían implementar como extensión nativa aumentando sustancialmente el rendimiento sin hacer nada.

Luego hay otra cosa que son los contextos. En Twig los contextos se simulan con un array y array_merge. Los cambios de contexto son muy costosos por este motivo y se hace demasiado amenudo. El tiempo perdido con dos bucles anidados es excesivo. Yo personalmente replantearía ciertas cosas a nivel de rendimiento en Twig.

Esta tarde tenía un rato y he hecho una clase que permitiría simular contextos anidados sin necesidad de merges implementando la interfaz ArrayAccess.

Nuevamente como el código es fácil que salga mal lo subo a pastebin: http://pastebin.com/xzRj4hR8</div>

<?php  

error_reporting(E_ALL | E_STRICT);  

class Context implements ArrayAccess {  
    /**  
     * @var Context  
     */  
    protected $parent;  

    /**  
     * @var ArrayObject  
     */  
    protected $current;  

    public function __construct($items = array(), Context $parent = NULL) {  
        $this->current = new ArrayObject((array)$items);  
        $this->parent = $parent;  
    }  

    protected function &getRef($index) {  
        $ref = &$this->current[$index];  
        if (!isset($ref) && ($this->parent !== NULL)) {  
            $ref = &$this->parent->getRef($index);  
        }  
        return $ref;  
    }  

    public function offsetExists($index) {  
        $ref = &$this->getRef($index);  
        return isset($ref);  
    }  

    public function &offsetGet($index) {  
        return $this->getRef($index);  
    }  

    public function offsetSet($index, $newval) {  
        $ref = &$this->getRef($index);  
        $ref = $newval;  
    }  

    public function offsetUnset($index) {  
        $ref = &$this->getRef($index);  
        unset($ref);  
    }  

    public function enter($items = array()) {  
        return new static($items, $this);  
    }  

    public function leave() {  
        return $this->parent;  
    }  
}  

$context = new Context(array('a' => -10, 'b' => -20, 'c' => -30));  
$context = $context->enter(array('a' => 10, 'b' => 20));  
printf("%d\n", ++$context['a']);  
printf("%d\n", ++$context['c']);  

$context = $context->leave();  
printf("%d\n", ++$context['a']);  
printf("%d\n", ++$context['c']);  

$context['c'] = 6;  

printf("%d\n", $context['c']);

Leer más...

PHP: Acceder y manipular programáticamente a elementos en arrays multidimensionales

Desde que uso MongoDB frente a MySQL me han ido surgiendo nuevos problemas a los que no me había enfrentado de forma común. Poder acceder a documentos que pueden tener una profundidad variable y tener que acceder a una serie de valores podía llegar a hacer que tuviese que montar mucho código para ciertas operaciones. Así que me creé un par de funcioncillas la mar de útiles.

El código mostrado aquí (que es fácil que salga mal) se puede acceder desde pastebin en la siguiente dirección: http://pastebin.com/sUQU8N8j

Nótese que la notación con ‘.’ es para simplificarlo todo sustancialmente pero puede introducir riesgos de acabar con una estructura no deseada si las claves no son estáticas (con valores especialmente introducidos por el usuario). Si se hace uso de whitelisting a la hora de aceptar parámetros del usuario, no debería haber problema.
Se puede hacer fácilmente una variante que en vez de tener como entrada una cadena, tenga un array que especifique las claves a acceder, evitando acceso indebido a más profunidad de la deseada.

Funciones:

function & access_value_dot($key, &$array) {  
    if (is_array($key)) {  
        $values = array();  
        foreach ($key as $single_key) $values[] = access_value_dot($single_key, $array);  
        return $values;  
    }  
    if (empty($key)) return $array;  
    $slices = explode('.', $key);  
    foreach ($slices as $slice) $array = &$array[$slice];  
    return $array;  
}  

function access_value_dot_set($key, &$array, $value) {  
    if (is_array($key)) {  
        $values = array();  
        $value = array_values($value);  
        foreach (array_values($key) as $k => $single_key) {  
            access_value_dot_set($single_key, $array, $value[$k]);  
        }  
        return;  
    }  
    $ref = &access_value_dot($key, $array);  
    $ref = $value;  
}  

Ejemplos:

public function testAccessValueDot() {  
    $data = array(  
        'level1' => array(  
            'level2b' => array(  
                'level3' => array(  
                    'level4a' => 1,  
                    'level4b' => 'Hello World',  
                ),  
            ),  
            'key' => 2,  
        ),  
        'level1a' => array(),  
    );  
    $this->assertEquals(access_value_dot('level1.level2b.level3.level4b', $data), 'Hello World');  
    $this->assertEquals(access_value_dot(  
        array(  
            'level1.level2b.level3.level4a',  
            'level1.level2b.level3.level4b',  
            'level1.key',  
            'level1a',  
            'level1.level2b.level3',  
        ), $data), array(  
            '1',  
            'Hello World',  
            '2',  
            array(),  
            array(  
            'level4a' => 1,  
            'level4b' => 'Hello World',  
        )  
    ));  
}  

public function testAccessValueDotSet() {  
    $object = (object)array(  
        'bbcode' => array(  
            'title' => 'Hello [b]World[/b]',  
            'descriptions' => array(  
                'short' => 'This is the [b]short[/b] description.',  
                'long' => 'This is the [b]LONG[/b] description.',  
            ),  
        ),  
        'html' => array(  
        ),  
    );  

    $field_keys = array(  
        'title',  
        'descriptions.short',  
        'descriptions.long',  
    );  

    // Accessing bbcode values.  
    $extracted_values = access_value_dot($field_keys, $object->bbcode);  

    {  
        // Converting bbcode to html.  
        $modified_values = array_map(function($value) {  
            return preg_replace_callback('@\\[(\\w+)\\](.*)\\[/\\1\\]@Umsi', function($captures) {  
                list(, $bbcode, $text) = $captures;  
                switch ($bbcode) {  
                    case 'b': return '<strong>' . $text . '</strong>';  
                    default: throw(new Exception("Unknown bbcode '{$bbcode}'"));  
                }  
            }, htmlspecialchars($value));  
        }, $extracted_values);  
    }  

    // Writting bbcode values.  
    access_value_dot_set($field_keys, $object->html, $modified_values);  

    $this->assertEquals(  
        $object->html,  
        array(  
            'title' => 'Hello <strong>World</strong>',  
            'descriptions' => array(  
                'short' => 'This is the <strong>short</strong> description.',  
                'long' => 'This is the <strong>LONG</strong> description.',  
            ),  
        )  
    );  
}  

Leer más...

PHP: Acceder a un puerto remoto protegido con PHP a través de un túnel SSH

Acceder a un puerto local de un servidor con PHP a través de un túnel SHH de forma sencilla.

Tenemos una máquina con acceso por SSH que está escuchando en un puerto con una dirección IP a la que no tenemos acceso de forma externa, bien por estar bindeado a 127.0.0.1, a una IP de una red local o bien por limitaciones de firewall y queremos acceder a ese puerto a través de un túnel SSH de manera remota como si accediésemos desde localhost.
Las extensiones SSH2 de PHP permiten hacer esto de una forma extremadamente sencilla utilizando el wrapper SSH2.TUNNEL de PHP.

Leer más...

C# Utils

Análogamente a mis otros dos proyectos de utilidades generales para D y para PHP que voy actualizando poco a poco:
http://code.google.com/p/phplutils/
http://code.google.com/p/dutils/

He creado otra librería con utilidades para C#:
http://code.google.com/p/csharputils/

Hay algunas cosas interesantes que voy a ir metiendo (algunas ya las he metido) que iré explicando por aquí.

Leer más...

Amagos de regresión para valorar la metodología actual y otras cosas

Llevo ya bastantes meses utilizando TDD. La verdad es que mi experiencia con el TDD aunque no siempre ha sido completa (en algunos proyectos, especialmente los antiguos que me tocó hacer el unittesting a posteriori, ha sido altamente positiva. Hay ya muchos artículos sobre las bondades del unittesting y no quiero que este sea uno más.

Lo que me gustaría comentar aquí es algo más genérico y que en ocasiones no hacemos demasiado.

El TDD está muy bien, y a bote pronto se pueden decir muchos motivos de por qué. La norma general al no haber usado nunca el Desarrollo Dirigido a Tests es escepticismo y pensar que se pierde más tiempo del que se gana. No es hasta cuando te decides y lo pruebas en un proyecto real en serio, hasta que te das cuenta de que funciona. No importa lo mucho que te digan que eso es así. Hay que probarlo.

Si modificas tu framework de trabajo, empiezas a utilizar alguna librería o tecnología nueva, si te funciona es fácil que empieces a olvidar la forma de trabajar de antes, las APIs de antes, las tecnologías anteriores. Evolucionar está bien, pero olvidar no tanto.

He aprovechado parte de esta semana en utilizar la metodología de trabajo que utilizaba antes del TDD. En este caso sabía lo que podía esperar del experimento: diseñaría la arquitectura antes de montarla, y luego me pondría a picar código como un descosido. Al principio bien, pero luego me encontraría con cosas difíciles de probar manualmente o con las que perdía mucho tiempo, bugs y problemas. Los iría corrigiendo, me daría cuenta de que había cosas que no funcionaban exáctamente igual como las había pensado y habría escrito código que me tocaría tirar a la basura. Además de que cada cambio que hiciese sometería a gran parte del sistema a tests manuales para evitar que petase el asunto.

El horror. Tenía el 90% de la funcionalidad al 2º día. Y he estado el resto de días corrigiendo errores, viendo que había cosas que no había planteado bien, etc. etc.
Acabé muy agobiado y estresado y no conseguí terminarlo.

Ayer me puse ya a montar tests. Vi que lo había montado de una forma que me permitía hacer los tests con mayor facilidad que antes de empezar a hacer TDD, pero que aun así había cosas con las que no podía hacer TDD directamente. Eran difíciles de testear y por lo tanto difíciles de mantener y de seguir. Tardé varias horas en montar los tests, con los tests montados, probar la funcionalidad era cuestión de pulsar un botón. Si rompía algo me enteraba al momento. Hice el 10% infernal que no había podido hacer en varios días en un par de horas, entretenido y sin agobio alguno.

A mí esta experiencia me ha servido para valorar aún más la metodología TDD. Me ha servido para ver que tras haber usado TDD el código que escribo, sin ser perfecto, ha aumentado en calidad y en capacidad de mantenimiento.

En el caso del TDD no he encontrado nada que me hiciese volver para atrás parte de mi forma de pensar. Pero estoy seguro que con algunas tecnologías después de haberlas estado usando un tiempo y viciado con su forma de funcionar, podría replantearme ciertas cosas al hacer una retrospectiva tecnológica.

“Echa un breve vistazo hacia atrás antes de pensar cómo seguir hacia delante.”

Me gustaría también comentar otra cosa. Me regalaron para reyes los libros “El libro negro del emprendedor” y “Vivir sin jefe”. Son dos libros que recomiendo enérgicamente a cualquiera; independientemente de que sean emprendedores o de que no. Habrán también ya artículos sobre estos dos libros y otros similares, así que no voy a hablar sobre ellos demasiado.

Simplemente quería dejar por escrito mi intención de hacer una segunda lectura de estos libros, extrayendo las ideas que considero claves. Especialmente las áreas donde tengo que mejorar.

Seguridad interna, autoestima, integridad, constancia y tranquilidad, antifrustración ante las dependencias ajenas, barbecho, la clave está en los detalles, los errores y los imprevistos no son malos sino sabias lecciones, levantarse las veces que haga falta, control de gestión de recursos, adaptación, renovación e integración contínua y perfecta ante cualquier molde y situación (be water my friend), equilibrio entre desarrollo y beneficio, excelencia técnica y profesional, puntualidad, meta-reflexión periódica, experiencias nuevas y estimulantes para el desarrollo personal y la eliminación de los prejuicios.

Ayer también vi “La Red Social”. Como frikazo me gustó bastante, pero aún sin ello considero que es una muy buena película que vale la pena ver.

Leer más...

Suscribirse via RSS