Programación LAMP con Scrum y XP

El síndrome de lo malo conocido

2012-02-23T18:16:00.001-03:00

Tienes la idea y el dinero pero... ¿cómo llevar adelante el proyecto? es la pregunta que te frena.

Lo primero que la mayoría de las personas hacen, es "planificar" esa idea de negocios. En esa planificación, lo primero que surge es un boceto de la idea. Pero cuando ese boceto, comienza a tomar forma, es el momento en el cual, la mayoría, se ve ganado por la obsesión en los detalles.

¿Qué sucede entonces? Es tal el costumbrismo al que todos hemos sido sometidos -sobre todo, en sociedades subdesarrolladas como la nuestra, donde la frase "más vale malo conocido que bueno por conocer", se nos termina haciendo carne sin más remedio-, que el miedo a lo desconocido toma mayor importancia que los resultados: nos terminamos olvidando de los resultados, postergándolos y nos aferramos a "seguir un plan" al pie de la letra, incluso, cuando está demostrado que seguir ese plan, reduce la calidad final de todo lo que teníamos en mente.

¿Ágil o predictivo?
Sin dudas, "hacer las cosas de manera tradicional" es la elección de la mayoría. Aunque, insisto, hacerlas de forma tradicional juegue en desmérito de los resultados.

Hace algo más de 6 meses, un gran amigo y colega me decía "a mi lo que me interesa, es que el producto final, sea tan bueno, que nadie pueda criticarlo". Seis meses hablando de ello, dándole mi punto de vista, sugiriendo y aconsejando aunque solo hace poco menos de dos meses, que el proyecto comenzó a desarrollarse.

Hoy, hablando por teléfono con él, le comenté que estaría bueno que presentaran el proyecto en el próximo Betabeers Buenos Aires 2012 (a realizarse recién, a principios de Abril), a lo que -para mi gran sorpresa-, me respondió:
- "Es que todavía no hay nada para mostrar"
Lógicamente, le aclaré:
- "Mira que recién es para Abril, ya serán 4 meses" y me dijo:
- "Si, es que el primer entregable lo corrimos para principios de Mayo"

Sinceramente, no pude contenerme y le dije:
- "Haciéndolo por Sprints, a esta altura, no solo ya tendrían algo para mostrar, sino que además, mínimamente, habría 4 deploy ya hechos".

Mi amigo, simplemente se limitó a responder con la frase, que más escuché en los últimos 5 o 6 años de mi carrera:
- "Lo que pasa es que tuvimos que reformular el alcance y nos llevaron bastante tiempo los prototipos"

- "¿Prototipos?!?!", le dije y continué: - "¿Qué prototipos necesitaban para algo tan simple?".
Y me respondió:
- "Es que el cliente, necesitaba hacerse una idea de como iba a quedar, antes de aprobar el proyecto.

No podía creer lo que escuchaba, incluso cuando ya lo he escuchado miles de veces, no podía salir de mi asombro. Por eso, insistí:
- "Pero ¿no es hora de cambiar de metodología y probar a comenzar planificando iterativamente en orden de prioridades?"

La respuesta fue:
- "¿Pero qué me asegura que se cumpla con el tiempo pautado?"

Ay! Mi amigo:
- "¿qué te lo asegura ahora si ya tuviste que postergar entregables? ¡Tu tiempo terminó hace rato!"

Hablando con él, una vez más, me di cuenta que no hay nada que uno pueda hacer o decir para mejorar las cosas. Que no se trata de dar argumentos técnicos, sino de "cambiar la mentalidad" de las personas. Y creo, que no hay Freud que pueda con ello. Son temas que exceden a la gestión de proyectos, a la informática y a los negocios. Es simplemente, la personalidad que engloba a una sociedad, que no está acostumbrada a evolucionar favorablemente.

Si bien nunca pierdo las esperanzas, cada vez que veo este tipo de situaciones, una especie de resignación ácida, comienza a invadirme.

Test-First Programming en Bash y Shell Scripting

2012-01-23T17:27:00.000-03:00

Test-First Programming en Bash y Shell Scripting

[...] Resulta que shUnit2 está basado en jUnit y entre otros Sistemas Operativos, soporta GNU/Linux, FreeBSD y OpenSolaris. Cabe destacar que posee una lista aceptable de asserts y soporta métodos setUp() y tearDown().

La última versión estable (al 22 de enero de 2012) es la 2.0.3 (que data de 2007) y a la fecha, se encuentra en desarrollo la versión 2.1.x. Lógicamente, se distribuye con licencia LGPL (Software Libre) y se encuentra perfectamente documentado y con sus FAQ correspondientes [...]

Software Libre - No te quedes con la duda

2012-01-22T00:16:00.000-03:00

En estos dos últimos días, y a raíz de un twit que publiqué, relacionado a una entrevista que 360 TV realizó a Linus Torvalds, el creador de Linux, el kernel que utiliza el Sistema Operativo libre GNU/Linux, surgieron unas cuantas dudas y confusiones.

Entonces, decidí escribir un post tan breve como sea posible, para que leyendo unas pocas líneas, puedas entender mejor, de qué hablamos cuando hablamos de Software Libre.

Entendiendo de qué hablamos cuando hablamos de Software Libre

SOFTWARE LIBRE = LIBERTAD DE HACER
Libertad de ejecutar, modificar, copiar y distribuir el software.

Software Libre se refiere a la LIBERTAD de:
- Ejecutar el software con cualquier propósito
- Modificar el software (y acceder al código fuente)
- Copiar y distribuir el software
- Copiar y distribuir la versión modificada del software

SOFTWARE LIBRE NO SIGNIFICA GRATIS

El «software libre» es una cuestión de libertad y no de precio. Para entender el concepto, se debería pensar en «libre» como cuando nos referimos a la «libre expresión» y no, como cuando hablamos de «barra libre» o «muestras gratis».

SOFTWARE LIBRE NO ES LO MISMO QUE OPEN SOURCE

El Software Libre es una corriente que promueve la Free Software Foundation, cuyo presidente (y principal promotor de la misma) es Richard Stallman. Open Source, es otra corriente que nada tiene que ver con el Software Libre y solo hace referencia al libre acceso al código fuente de un programa.
Ver diferencias entre Open Source y Software Libre.

La Free Software Foundation es la
ÚNICA FUENTE DE REFERENCIA LEGÍTIMA

La Free Software Foundation (FSF) es la entidad sin fines de lucro, que promueve el Software Libre de la mano de su presidente Richard Stallman. Muchas entidades, organismos y personas, ayudan a la FSF a promover el Software Libre, mediante diferentes actividades. La Free Software Foundation es la única fuente de referencia válida en cuanto a Software Libre se refiere. NO TE DEJES ENGAÑAR. Recurre a la única fuente válida!

EL SOFTWARE LIBRE PUEDE SER COMERCIAL

«Software libre» no significa «que no sea comercial». Un programa libre debe estar disponible para el uso comercial, la programación comercial y la distribución comercial. [...] Puede haber pagado dinero para obtener copias de software libre, o puede haber obtenido copias sin costo. Pero sin tener en cuenta cómo obtuvo sus copias, siempre tiene la libertad de copiar y modificar el software, incluso de vender copias.

GNU ES EL SISTEMA OPERATIVO LIBRE
Linux, es el kernel (núcleo) del Sistema Operativo GNU

GNU es un Sistema Operativo libre (Software Libre) que utiliza el Kernel Linux.

La Free Software Foundation es la principal organización que patrocina el Sistema Operativo GNU. Su misión es preservar, proteger y promover la libertad de usar, estudiar, copiar, modificar y distribuir programas de ordenador; así como defender los derechos de los usuarios de software libre.

¡Apoya a GNU y a la FSF!

Aprende a prescindir del entorno gráfico en Linux

2011-10-22T16:49:00.000-03:00

Aprende a prescindir del entorno gráfico
Comparto este artículo publicado en DesdeLinux.net que incluye muchísimos ejemplos de como utilizar rápidamente Linux, por línea de comandos [...]

–» Como crear enlace entre archivos
–» Como crear enlace entre carpetas
–» Crear una imagen de un CD/DVD
–» Comprobar el UUID de alguna partición
–» Montar y desmontar un ISO desde una carpeta hacia otra carpeta
–» Para comprobar los datos de un CD/DVD
–» Buscando archivos
–» Conocer tipo de un archivo
–» Borrar completamente una carpeta
–» Borrar completamente un tipo de archivos dentro de una carpeta
–» Picar o dividir archivos
–» Unir archivos divididos con split
–» Para cambiar resolución de pantalla y tiempo de refresco
–» Hacer un screenshot o pantallazo
–» Convertir imágenes de un formato hacia otro
–» Cambiar dimensiones de una imagen
–» Convertir una imagen de colores a blanco y negro
–» Crear un gif animado con varias imágenes
–» Extraer el audio de un video
–» Convertir un archivo MPEG a un AVI
–» Para apagar la PC
–» Para apagar la PC luego de un tiempo determinado
–» Para apagar la PC a una hora determinada
–» Para reiniciar la PC
–» Para reiniciar la PC luego de un tiempo determinado
–» Para reiniciar la PC a una hora determinada
-» Usando la calculadora.
-» Muestra las propiedades y características de una imagen.
-» Como configurar la red.
-» Revisa tu email.
-» Navegar por internet.
-» Comprime y descomprime todo tipo de archivos.

Database Integration Testing With Enhance PHP

2011-10-13T16:40:00.000-03:00

Database Integration Testing With Enhance PHP: When I write an integration test, I want to test that my data access works with my database engine - that is the test! But how do you deal with the problem of needing data in the correct state? You can try to keep a copy of a database that is in the correct state, but it is very hard to keep it in the right state and also keep the tables in step with any changes. It is also possible that if some of your tests fail, the database will be left in a mess, so you would need to restore a previous snapshot of the data. I think that there is a better way, so here is how I do integration tests for my database layer. [see more]

Curso gratis de Python

2011-10-13T15:41:00.002-03:00

Ya se encuentra publicado el primer capítulo de la guía Aprender Python Programando, un curso gratuito de Python para quienes deseen iniciarse en este lenguaje de una manera rápida, eficaz y profesional.

Invito a todos/as a participar de este desafío, desde el 11 de Octubre, todos los martes a través de Maestros del Web.

Dudas / consultas sobre la guía, pueden realizarse a través de Maestros del Web o aquí mismo. ¡Gracias!

Curso: Aprender Python Programando
Fecha: desde el 11.10.2011 (todos los martes)
Modalidad: a distancia
Duración: -
Lugar: Maestros del Web
Precio: $0.00.-

8. Write controllers for your models

2011-10-07T18:23:00.002-03:00

How event handler works?

In order to write a controller, first, you must know how Europio works.
In Europio, the user events are handled by a event handler that catchs:

What module is being called
What model must be invoked, and
What action (event) is required by the user.

All these events are handled from the URL requested by the user.

For example:
If the URL that is being called looks like that: http://servername/myapp/store/product/new/
The event handler answers these questions:
What module is being called? store
What model must be invoked? product
What action (event) is required by the user? new
Then, the event handler calls to the general controller of this model and sends the action that is required: product_controller('new')

What do you need in order to write controllers?

Write controllers on Europio is very simple. You can write a controller in just two simple steps.

Step #1: write the general controller

function model_name_controller($event) {
    $controller_name = "model_name_{$event}_controller";
    call_user_func($controller_name);
}

model_name must be the lowercase model name and separate words by a underscore. For example, if the model name is ShoppingCart, the controller name must be shopping_cart_controller( ).

Step #2: write your own controllers

The next step is write your own controller. In the previous step, the general controller calls to a next controller.

The controller name must be written by following this pattern: [model_name]_[event_name]_controller

For example:
function shopping_cart_view_cart_controller() {
}

Complete example

// General controller for Product model
function product_controller($event) {
    $controller_name = "product_{$event}_controller";
    call_user_func($controller_name);
}

// Insert a new product
function product_addnew_controller() {
    // call to model
    $product = new Product();
    // change model
    $product->product_name = $_POST['product_name'];
    $product->price = $_POST['price'];
    $product->description = $_POST['description'];
    // call to model method
    $response = $product->add_new();
    // send response to the view
    $product_view = new ProductView('addnew', $response);
}

Europio + Enhance PHP User Guide
Back to the table of contents

[off-topic] Phixr - Editor online de fotos

2011-10-07T13:46:00.000-03:00

Para quienes no somos front-end developers, muchas veces nos vemos en la tediosa tarea de tener que realizar algún tipo de actividad, relacionada con el diseño de interfaces gráficas o similar, y es allí donde cual si fuéramos un comic, comienzan a flotar a nuestro alrededor, frases como "Recórcholis Batman!" o "Ay! Mamá pulpa! santos calamares", solo que surgen así, tras pasar por la censura del "buen gusto"... originalmente... convengamos en que suelen ser un poco más "elevedas de tono" ;)

En mi caso, la más tediosa de todas las tareas, es tener que editar fotografías de cientos de megas, reducirlas, mejorarles brillo, contraste y demás cuestiones, que realmente, no las domino en lo absoluto y tampoco tengo un software apropiado (y si lo tuviese, me daría mucha "palma" tener que aprender a usarlo, pues lo mío, es "codear").

Gracias a la maravillosa Internet que nos alimenta, me encontré con Phixr, un editor de fotos online que me salvó la vida (exagero: pero realmente, logra que editar una foto sea solo cuestión de segundos). Phixr tiene muchísimas funcionalidades para editar fotos e imágenes:

Ajustar brillo, contraste, tono, saturación, color y otras que no se ni que son
Cambiar tamaño, reducir, escalar, rotar y demás
Dar decenas de efectos como blanco y negro, sepia, solarizar y esas cosas extrañas que hacen los diseñadores gráficos
Dibujar formas geométricas, agregar texto (incluso marcas de agua), globos tipo comic, marcos, texturas, dibujos varios, etc.
Mezclar fotografías
Redondear esquinas
Corregir ojos rojos, etc..
Guardar la imagen en diferentes formatos (JPG, GIF, PNG y PDF), optimizando la calidad (más alta o más baja) y el tamaño (más pequeña o más grande)

Y todo ello, con la posibilidad de aplicar cada efecto o herramienta en una zona seleccionada o en toda la imagen.

Algo que para un diseñador gráfico seguramente es obsoleto e inútil, para un programador que nada entiende de diseño, puedo asegurarles que es una salvación. Un off-topic que tal vez les sirva para salir del paso.

Por cierto: la de la foto es Burbuja, mi gata :)

7. Test-first your model methods with Enhance PHP

2011-10-06T15:44:00.000-03:00

With Enhance PHP and Europio you can making TDD, easily. But, Why write TDD? All responses are here (or aquí en español).

Enhance PHP is an unit testing framework that provides several methods that helps to test our class methods. Moreover, Europio includes a RunTest function which runs all tests automatically by the command line and in turn helps to write less test-code.

Write TDD with Enhance PHP on Europio

1. Create a php file named like the model file to be tested and save file in the test folder.

For example, if your model file is /app/module/models/user.php the test file must be /app/module/test/user.php

2. In the test file, write the class test like that:

include_file('../models/model_name.php');
// model_name.php must be the filename of the model to be tested

class ModelNameTests extends EnhanceTestFixture {
// ModelName must be the name of the class to be tested
}

3. Write the test methods like that:

    public function name_of_functionTest() {
    // name_of_function could be the method name to be tested
        $target = Enhance::getCodeCoverageWrapper('ModelName');
        // call at the method to be tested
        $result = $target->name_of_function(params);

        // Assert results
        Assert::assertion_method(your_expect, $result);
        /* where assertion_method is an EnhancePHP assert method
          and your_expect will be the result that you are expecting
        */
    }

You can see more about unit testing with EnhancePHP

Europio + Enhance PHP User Guide
Back to the table of contents

6. Making a standard model (Europio User Guide)

2011-10-04T21:38:00.002-03:00

In the previous chapters we were created the folders needed to our app. Now, is time to begin writing the models.

Model structure

A model created with Europio must have a class structure like that:

// class definition
class ClassName implements DataModel {

    // set_data_model public method
    public function set_data_model($DataModel) {
        // set data types
    }

    // your own methods from here
}

The ClassName must be the singular model name with CamelCase style.
The data types can be whichever of data-types provided by Europio (see "Europio Data types")

Europio Data Types

Europio DataModel is a global object that provides some data types that can be used in order to create your own models and to set its properties.

You don't have to think about the database structure: you must think about how the models are related between itself.

When you are ready to think about models and not to think about databases, you will be able to make a robust app based on related objects.

Forget the databases! You can try it! It's very easy and simple!

The data-type methods provides by Europio are:

String types

set_char

two characters

set_char(string $property_name[, string $null])

set_varchar

0 to 255 characters

set_varchar(string $property_name[, int $max_len, string $null])

set_text

long text string

set_text(string $property_name[, string $null])

Numeric types

set_int

integer number

set_int(string $property_name[, int $max_len, string $null])

set_float

float number

set_float(string $property_name[, string $null])

set_boolean

true/false

set_boolean(string $property_name)

Date and time types

set_date

date

set_date(string $property_name[, string $null])

set_time

time

set_time(string $property_name[, string $null])

set_datetime

date and

set_datetime(string $property_name[, string $null])

Rrelated types
- ```
foreign_key
```
  relation between a model property and another entire model
```
foreign_key(string $model_name)
```

Index types

set_index

make a index with the indicated properties

set_index(string $property_name[, string $property_name_2, string $property_name_3])

set_unique

make a unique index with the indicated properties

set_unique(string $property_name[, string $property_name_2, string $property_name_3])

Please, note that the ID property mustn't be created!! It will be created by the Europio DataModel.

Data type sintax

$DataModel->data_type(params);

The $null parameter

You can set the $null parameter as null or notnull. The "null" value is not necessary because the default value allways is "null".

Here are some examples:

$DataModel->set_char("state"); // it's equal to $DataModel->set_char("state", "null");
$DataModel->set_varchar("country", 125, "notnull"); // it's right too!

A Model example

/* 
===============================
   user_type.php file
===============================
*/
class UserType implements DataModel {

    public function set_data_model($DataModel) {
        $DataModel->set_varchar("user_type", 25, "notnull");
        $DataModel->set_boolean("active");
    }

    // your own methods from here
}


/* 
===============================
   user.php file
===============================
*/
class User extends UserType implements DataModel {

    public function set_data_model($DataModel) {
        $DataModel->set_varchar("username", 50, "notnull");
        $DataModel->set_varchar("pass", 24, "notnull");
        $DataModel->set_varchar("email", 125, "notnull");
        $DataModel->set_varchar("name", 255, "notnull");
        $DataModel->set_date("birthday");
        $DataModel->set_boolean("active");
        $DataModel->set_text("resume");
        $DataModel->set_index("username", "email");
        $DataModel->set_unique("email");
        $DataModel->foreign_key("UserType");
    }

    // your own methods from here
}

Please, note again that the ID property mustn't be created!! It will be created by the Europio DataModel.

The model file names

The name of the model file must be the name of the model in lowercase. When the model name has two or more words, these words must be separated by a _
For example: if the model name is UserType the file name must be user_type.php.

Please, note that if you don't follow these style rules, you get a fatal error warning.

Europio + Enhance PHP User Guide
Back to the table of contents

5. Making the first module (Europio User Guide)

2011-10-04T15:04:00.002-03:00

The module folder

The first step in order to make an app, is create a module. So, we must create a folder for our module by following these rules:

The module folder must be put into the app dir
The folder name must be equal to the module name but in lowercase
If the module name has more of one word, you must separate the words by a medium hyphen (-)

For example: if the name of the module is "Shopping Cart" the name of the module folder must be "shopping-cart"

The module sub-folders

You must make four sub-folders: models, views, controllers and test. In this way, you can see the follow similar structure:

[+] myapp
    [+] shopping-cart
        [+] controllers
        [+] models
        [+] views
        [+] test

Please, note that you can't put other folders here.
Click here, to Learn more about folders structure

File initialize module

You must to know that all modules must to have an initialize file. This file is named __init__.php.
Into this file, you must set some necessary data to run the module.

First, you must include the architecture config manager:

require_once('../core/europio/__architect_config.php');

Then, you must set the module name at the $modulo var:

$modulo = 'shopping-cart';

Please, don't change the name of the $modulo var. It's a global var that is used by Europio in order to know what module is currently working.

Then, will be necessary to set an array with the name of each model in your module.

$modelos = array('category', 'product',);

If you don't have any model yet, please leave the array initialized without values.

$modelos = array();

Please, don't change the name of the $modelos array. It's a global array that is used by Europio in order to know what models could be working in your currently module.

Now, you must create a MVC object by passing the global params ($modulo and $modelos).

$mvc = new MissArchitectModule($modulo, $modelos);

Finally, must be necessary to create a default controller for the module.

// default controller example
function default_controller($fu=array()) {
    print '<h1>This links will be available for this module</h1>';
    foreach($fu as $name=>$url) {
        print "<a href='{$url}'>{$url}</a><br/>";
    }
}

Please, note that the name of the default controller must be default_controller()

If you want, you can use the $fu param in the default controller. The $fu param is passed by default from Europio at the default controller . This param contains an array with all the friendly URLs for your module.

Europio + Enhance PHP User Guide
Back to the table of contents

2. Install Europio + Enhance PHP on Linux (Europio User Guide)

2011-10-03T20:49:00.000-03:00

First step

Download europio_v2_0_18.tar.gz from https://launchpad.net/europio/+download

Second step

Decompress tarball and rename europio_2_0 folder by the name of your new app. You must be sure that the new app folder is into the root folder server.

You can use the root folder like folder for your app.
In this case, you must move the europio_2_0 folder content to the root server folder.

Third step

Enable Apache mod_rewrite by writing

sudo a2enmod rewrite

in the command line. Then, restart Apache by writing

sudo /etc/init.d/apache2 restart

(You note that the

/etc/init.d/apache2

path could be different in your server).

Final step

Edit the

/etc/apache2/sites-available/<sitename>

file by changing this:

AllowOverride None

for:

AllowOverride All

and restart Apache again.

Europio + Enhance PHP User Guide
Back to the table of contents

4. Configure the settings.php file (Europio User Guide)

2011-10-03T19:22:00.000-03:00

The ./core/settings.php file has information about central data that are used by Europio in order to run the entire app. You must be sure that its information are correctly before to run the app.

Please, take a look at the below documentation in order to configure the settings.php file correctly.

Configure the database constants

These constants must be look like that:

const DB_HOST = 'localhost'; // host of the database
const DB_NAME = 'mydbone'; // name of the primary database
const DB_USER = 'root'; // user of the database
const DB_PASS = 'pass'; // password of the database

Note that if the database not exists will be created by the ORM at the first time that it runs by the command line.

Set the app folder

The app folder must be setting in the APPLICATION_DIR constant:

// your app folder here
const APPLICATION_DIR = '/mynewapp';

Installed modules

Europio was planned in order to write modular apps. It suppose that your app has one or more modules developed.
If you have only one module anyway, you must keep the modulars folder structure. In this way, you must set the name of each installed modules in the $modulos array (even if you have only one).

For example:
If you have an "users" module, the $modulos array must be look like that:

$modulos = array('users',);

But, if you have two or more modules (for example: users, store, blog) the $modulos array will look like that:

$modulos = array('users', 'store', 'blog',);

Set the app resources

The resources are all actions or functions that can be executed by each model in your app.

For example, your models could have some resources like as create, read, update and/or delete methods. Also, these methods could have another actions like show-form-update, show-form-search, etc.

All resources must be defined in a own constant. Each resource-constant must start with the __FU__ prefix in order to be automaticly identified by Europio. Europio will be using these constants in order to get all the friendly URL of your app and then, will be returned a global array with them.

The friendly URLs are formed by the following pattern:

/app_dir/module/model/resource/

Where resource will be replaced by the value of each constant.

See this example:

const __FU__SHOW_FORM_NEW_ROW = 'new';
const __FU__SAVE_NEW_ROW = 'insert';

/*

Friendly URLs retorned:

$__FU__ = array(
 'USERS_PROFILE_SHOW_FORM_NEW_ROW' => '/mynewapp/users/profile/new/',
 'USERS_PROFILE_SHOW_SAVE_NEW_ROW' => '/mynewapp/users/profile/insert/',
 'USERS_PICTURE_SHOW_FORM_NEW_ROW' => '/mynewapp/users/picture/new/',
 'USERS_PICTURE_SHOW_SAVE_NEW_ROW' => '/mynewapp/users/picture/insert/',
);

*/

The previous example returns an array based-on an app that has only one module called "users" and it has two models: "profile" and "picture".
Like you see, the defined resources are generic and are used on each module for each model. But then, you may can to use only those what you need.

Europio + Enhance PHP User Guide
Back to the table of contents

1. About Europio (Europio User Guide)

2011-10-02T16:59:00.001-03:00

What is Europio?

Europio is a suite of tools and libraries that can be used as core by any modular app, developed in PHP object orientated under a MVC architecture.

Europio can be used like a framework that it help you to keep coherency in your MVC architecture by writing standard code with predefined style rules.

Also, Europio has included some additional helpers that are useful in order to write less code and to test your classes through Enhance PHP, a unit testing framework, that was incorporated since the 2.0 release.

Download Europio v2.0.18 Now!

Features summary

Keep a standard-fixed MVC architecture
Easy maintainability and scalability of modular apps
DB abstraction layer to keep clean models
Predefined style rules to write standard code
Set data model interface to create relational models easily
Creating relational databases by object relational mapping (ORM) of all your app models
Easy data validation based on common regular expressions
Write TDD, mocks and stubs for your entire app with Enhance PHP
Abstraction views layer to avoid blending programming languages
Dynamic data rendering of HTML templates

Download Europio v2.0.18 Now!

About Europio and Enhance PHP Projects

Europio and Enhance PHP are free software distributed under GNU / LGPL and Apache 2.0 licence, respectively.

Europio, developed by Eugenia Bahit in Argentina and Enhance PHP, developed by Steve Fenton in England were joined in September 2011 by its developers in order to make the europio-enhance project, hosted in Launchpad at code.launchpad.net/europio.

Download Europio v2.0.18 Now!

Europio + Enhance PHP User Guide
Back to the table of contents

3. Folders Structure (Europio User Guide)

2011-10-02T00:00:00.000-03:00

You must have the following folder structure in your app:

One folder for your app

[+] mynewapp

One folder for each app module into the app folder

[-] mynewapp
    [+] module-1
    [+] module-2
    [+] module-3

Inside each of the modules must be the following four folders: models, views, controllers and test

[-] mynewapp
    [-] module-1
        [+] models
        [+] views
        [+] controllers
        [+] test
    [-] module-2
    [-] module-3

The Europio core folder must be into the app folder

[-] mynewapp
    [+] core
    [-] module-1
        [+] models
        [+] views
        [+] controllers
        [+] test
    [-] module-2
    [-] module-3

Files inside the app folder

The __init__.php app file and an .htaccess file.

[-] mynewapp
    [+] module-1
    [+] module-2
    [+] module-3
    __init__.php
    .htaccess

One init.php module file inside each module

Note that the __init__.php module file is different that the __init__.php app file.

[-] mynewapp
    [-] module-1
        [+] models 
        [+] views 
        [+] controllers 
        [+] test
        __init__.php

Europio + Enhance PHP User Guide
Back to the table of contents

Europio + Enhance PHP

2011-09-27T12:43:00.001-03:00

Se suma EnhancePHP, Framework para Unit Testing a la versión 2.0.18 de Europio

Desde la versión 2.0.18 de Europio, el core para arquitecturas MVC en PHP, se suma EnhacenPHP. Un Framework para test unitarios con soporte para mocks, creado por Steve Fenton.

Download the latest stable version, now!

Download Europio + EnhancePHP (version 2.0.18)
Download EnhancePHP only

Documentación (inglés / español)

Desde aquí puedes acceder a la documentación completa tanto en español como en inglés:

Enhance PHP: Acerca de los Test Unitarios (traducción al español)

2011-09-26T17:18:00.000-03:00

Traducción al español de enhance-php.com/Content/About-Unit-Testing/ (por Eugenia Bahit)

Si eres nuevo en las pruebas unitarias y quieres saber de qué se trata todo esto, este es definitivamente el lugar. Hablamos de las bases de las pruebas unitarias y algunos de los principios generales, incluyendo el desarrollo guiado por pruebas o TDD (test-driven development).

También vamos a añadir algunas recomendaciones de libros si quieres saber más!

¿Qué es un test unitario (o prueba unitaria)?

Un test unitario es una forma rápida y automática de probar que tu código hace lo que se supone que debe hacer. Confirma que tu código continúa trabajando después de realizar cambios o te alerta desde el comienzo que algo se ha roto. Al escribir test unitarios que cubren todo nuestro código, podemos ejecutarlos rápidamente y verificar nuestra aplicación completa en pocos segundos.

Un test unitario, actúa incluso como parte de la documentación, descibiendo cómo tu código debe ser utilizado.

¿Por qué deberías escribir test?

Antes que la comunidad de programadores estuviese convencida de los beneficios, algunas personas pensaban que los test unitarios eran una pérdida de tiempo. Algunos programadores pensaban que su trabajo era escribir código de producción, por lo cual, emplear tiempo en los test los cuales no eran código de producción, no era por lo que ellos habían recibido un pago.

Hoy en día, la mayoría de los programadores profesionales saben que los test unitarios son una parte importante de la escritura del código para producción. Esto significa que se ofrece una mejor calidad de código y se realizan trabajos como refactorización de código o agregado de nuevas características con facilidad.

El equipo de investigación, encontró que los equipos que desarrollaban con TDD producían código entre un 60% y 90% mejor, en cuanto a la densidad de defectos que los equipos que desarrollaban sin TDD – vía Phil Haack

Si tu código no está cubierto por test unitarios, es código antiguo.

Diferencia entre test unitarios y test de integración

Un test unitario aísla una pequeña parte de tu código para realizar las pruebas. Los componentes de los cuales depende tu código, son reemplazados con versiones falsas (simuladas) para hacer tus tests más estables. Un test de integración, cubre muchos componentes en un único test.

Generalmente un test unitario llama a un método único en una clase única y prueba una parte única de la lógica en el método, mientras que un test de integración garantiza que dos componentes interactúan como se esperaba.

Debes tener una cobertura de test tan amplia como sea posible para asegurar que el comportamiento de tu código, es lo que esperas que sea. La cobertura de los test de integración no debe abarcar el detalle del compartamiento del código (puesto que esto ya está cubierto por las pruebas unitarias) pero centraliza su foco en comprobar que los componentes están presentes, conectados e interactúan.

Puedes realizar los Test Unitarios y los Test de Integración con Enhance PHP.

Buenas prácticas

Un test solo debe probar una única unidad lógica. Si estás haciendo múltiples asserts en un único test, deberías considerar si en su lugar, debería haber varios tests con un solo assert. Si un test falla, debería dejar en claro qué lógica está rota; si realizadas demasiadas pruebas en un solo test, será difícil discernir la causa del fallo.

Métodos públicos:

Sólo debes probar los métodos públicos. Si el método público llama a un método privado, puedes diseñar tus tests ejercitando las diferentes partes de las lógicas contenidas en el método privado, llamando al método público con la combinación correcta de argumentos.

Dependencias:

Si la clase o función que estás testeando se basa en algún otro componente, debes proporcionar una versión falsa (simulada) de ese componente para aislar el test. No deseas cambios en otro componente para afectar tus tests.

Sobre los nombres:

El nombre de tu test debe ser lo suficientemente descriptivo para decirte que ha ido mal si éste falla. Por ejemplo:

[NombreDelMétodo]con[condición]esperando[Resultados]

Un ejemplo real sería:

SumarDosNumerosCon3y5Esperando8

Algunas personas utilizan el guión bajo en vez de “con” y “esperando”.

[NombreDelMétodo]_[condición]_[Resultados]

Un test de ejemplo

public function SumarDosNumerosCon3y2Esperando5() {
        $destino = Enhance::getCodeCoverageWrapper('ExampleClass');
        $resultado = $destino->SumarDosNumeros(3, 2);
        Assert::areIdentical(5, $resultado);
}

Este test es para un método llamado "SumarDosNumeros", el cual es una función de suma simple. Lo probamos pasándole 3 y 2 esperando que la respuesta (resultado) sea 5. Si el método retorna otro valor el test fallaría.

¿Qué son los fakes, los mocks y los stubs?

Un "fake" es una clase ficticia u objeto que usas en lugar de uno real con el propósito de realizar el test. Por ejemplo, si tenías un código basado en una clase llamada "CalcularImpuesto", no querrías usar la Calculadora de Impuestos real en tus tests ya que esto haría que los test sean frágiles. Si la calculadora de impuestos cambia, podría causar que tus test fallen a pesar de que le código y el comportamiento de tu código en el test esté correcto. Así que en vez de usar la calculadora de impuestos real, que actualmente determina el impuesto al 22%, pero el próximo año podrá ser de 20% o 25%, crearemos una versión falsa (un fake) que siempre utilice el mismo porcentaje. Ahora nuestros test no serán afectados por los cambios en la calculadora de impuestos y será menos frágil.

Los “Mocks” y “Stubs” son dos tipos de versiones falsas (fakes) usados en los test unitarios. Un stub simplemente actúa como un comodín para permitir que los test se ejecuten mientras que un mock es usado para verificar que se llama a ciertos hechos con determinados argumentos. Así que un stub está justo allí para hacer que tus tests transcurran fuera de las clases sin depender de ella y un mock es usado para pasar o fallar un test (es decir, no llama a un método que debería llamar o, si llama a un método que no debería haber llamado, puedes hacer fallar el test).

Puedes reproducir un mock o un stub escribiendo una clase con la misma interfaz como en la clase real y hardcodear los valores devueltos. Sinembargo, para ahorrarte el trabajo, Enhance PHP la generará por ti.

¿Cómo utilizar un mock?

Crear un mock y agregar una expectativa (el resultado que esperas):

$mock = MockFactory::createMock('ExampleClass');
$mock->addExpectation(
	Expect::method('SumarDosNumeros')->with(3, 5)->returns(8)->times(1)
);

Pasarlo a la clase como una dependencia:

$myClass = new MyClass($mock);

Comprobar que le método fue llamado el número de veces exacto con los argumentos correctos:

$mock->verifyExpectations();

¿Cómo usar un Stub?

Crear un stub y agregar los valores de retorno requeridos:

$stub= MockFactory::createStub('ExampleClass');
$stub->addExpectation(
	Expect::method('SumarDosNumeros')->with(3, 5)->returns(8)
);

Pasarlo a una clase como una dependencia:

$myClass = new MyClass($stub);

No verificas las expectativas sobre un stub – éste justamente está allí para ayudarte a evitar realizar varios tests de dependencias de una clase cuando en realidad intentas testar la clase en sí misma.

¿Qué es el desarrollo guiado por pruebas (TDD)?

El desarrollo guiado por pruebas es el proceso de solo escribir el código de producción una vez que hayas hecho fallar el test. Primero escribes el test para verificar una sola parte de la funcionalidad de tu aplicación, entonces, escribes la mínima cantidad de código requerida para hacerlo trabajar.

Aquí hay un ejemplo rápido:

Paso 1:
Primero que todo, crearemos nuestra clase de suma simple, y vamos a escribir una función que sume dos números, teniendo dos argumentos que serán los números a ser sumados. Antes de pensar en el código que habrá que implementar, escribiremos un test que esperamos que falle. Este es un ejemplo completo:

<?php
// Ejemplo construido usando TDD
include('../EnhanceTestFramework.php');
class ExampleClass {
        public function SumarDosNumeros($a, $b) {
        }
}

class ExampleTestFixture extends EnhanceTestFixture {
        private $target;
        
        public function setUp() {
                $this->target = Enhance::getCodeCoverageWrapper('ExampleClass');
        }
        
        public function SumarDosNumerosCon3y2Esperando5() {
                $result = $this->target->SumarDosNumeros(3, 2);
                Assert::areIdentical(5, $result);
        }
}
Enhance::runTests();
?>

Desde éste, tenemos el siguiente resultado - ya que el método no devuelve nada.

SumarDosNumerosCon3y2Esperando5 - Failed
Expected 5 but was

Paso 2:
Nuestro siguiente paso es implementar la mínima cantidad de código necesaria para hacer pasar el test, para lo cual cambiaremos nuestro método:

	public function SumarDosNumeros($a, $b) {
       }

por:

	public function SumarDosNumeros($a, $b) {
		return 5;
       }

Cuando ejecutemos nuestro test, pasará la prueba:

SumarDosNumerosCon3y2Esperando5 - Passed

Al comienzo, puede parecer extraño escribir una pequeña cantidad de código para hacer pasar el test, pero el punto es, que si hubiésemos escrito más código que ese, el código adicional escrito más allá del mínimamente requerido en realidad no estaría completamente testeado.

Escribiendo una mínima cantidad de código para hacer que el test pase, nos obligamos a escribir el siguiente test para exponer el error en la función que estamos probando.

Paso 3:
Por lo tanto, ya que queremos escribir más código de producción, necesitamos provocar una falla en lo que tenemos, usando un test. Éste, es el test que podríamos añadir:

public function SumarDosNumerosCon4y2Esperando6() {
    $result = $this->target->SumarDosNumeros(4, 2);
    Assert::areIdentical(6, $result);
}

Debido a que previamente hardcodeamos el valor devuelto para pasar el test anterior, este test fallará:

SumarDosNumerosCon4y2Esperando6 - Failed
Expected 6 but was 5

Paso 4:
Y hacemos pasar este test, escribiendo la mínima cantidad de código una vez más – sólo que esta vez, necesitamos hacer pasar nuestros dos test, así que en vez de hardcodear el valor devuelto a 6, haremos algo así:

public function SumarDosNumeros($a, $b) {
    return $a + $b;
}

SumarDosNumerosCon3y2Esperando5 - Passed
SumarDosNumerosCon4y2Esperando6 - Passed

Paso 5:
Repetimos este proceso hasta que tengamos toda nuestra funcionalidad desarrollada por completo. Podemos tener mucha confianza en que nuestros tests son ejercicios de todo el recorrido lódigo através de nuestro código y podemos ejecutar nuestros tests, cada vez que hacemos un cambio para asegurar que no se ha afectado el comportamiento de nuestra aplicación.

El punto final para recordar para el desarrollo guiado por pruebas, es que si un bug es reportado, deberás escribir un test que exponga el bug antes de corregirlo. Al comienzo, tu motivación para este proceso será que si tienes un test que exponga el bug, puedes tener la certeza de que el mismo bug jamás volverá a ocurrir nuevamente.

Lectura recomendada: Si deseas ampliar tus conocimientos sobre TDD, te recomiendo el libro Diseño Ágil con TDD (en español) de Carlos Blé. Puedes acceder a este libro de forma gratuita visitando el siguiente enlace: http://eugeniabahit.blogspot.com/2011/08/diseno-agil-con-tdd-por-carlos-ble.html

Enhance PHP: Guía de Inicio Rápido

2011-09-25T19:14:00.002-03:00

Instalar Enhance PHP y escribir tu primer test es verdaderamente fácil. Es probable que sea el framework para test unitarios en PHP, más fácil de instalar, pero esto, no ha sido “clínicamente” comprobado.

Instalación

Descargar y descomprimir el ZIP con el archivo EnhanceTestFramework.php y colocarlo en algún lugar donde pued ser importado desde tus test.

Tu primer test

Aquí hay un ejemplo para tu primer test, con una gran cantidad de comentarios que le ayudarán a empezar. Puede copiar este ejemplo en un archivo .php para probarlo.

<?php
// Importar Enhance PHP
include_once('EnhanceTestFramework.php');

/*
   Crear las clases de la aplicación
   éstas, podrán lógicamente, estar en archivos y directorios separados
   y luego ser importadas en los test
*/
class ExampleClass {
    public function addTwoNumbers($a, $b) {
        return $a + $b;
    }
}

/*
   Los test deben ser clases extendidas de EnhanceTestFixture
   El nombre de la clase será NombreDeMiClaseTest
*/
class ExampleClassTests extends EnhanceTestFixture {

    /*
        Método setUp:
        Es un método opcional. Los métodos setup en los test unitarios son
        utilizados para pre-configurar todo aquello que necesite ser utilizado
        en todo el test (por ejemplo, setear el valor de una propiedad)
    */
    public function setUp() {
        //...
    }

    /*
        Método tearDown:
        Es también un método opcional. Los métodos tearDown en los test
        unitarios, cumplen la función inversa a los métodos setup, es decir,
        sirven para reestablecer aquellas configuraciones realizadas, que sean
        requeridas al finalizar el test.
    */
    public function tearDown() {
        //...
    }

    /*
        El test:
        Puede tener el nombre que desees, pero ten cuenta que debe ser un método
        público.
    */
    public function addTwoNumbersWith3and2Expect5Test() {
        // Crear el objeto a ser testeado
        $target = Enhance::getCodeCoverageWrapper('ExampleClass');

        // Llamar al método que será testeado
        $result = $target->addTwoNumbers(3, 2);

        // Verificar los resultados mediante un método assert
        Assert::areIdentical(5, $result);
    }
}

// Correr el test
Enhance::runTests();
?>

Presentación de Enhance PHP - Framework para test unitarios en PHP

2011-09-25T18:41:00.000-03:00

Enhance PHP es un framework liviano de código abierto, para realizar test unitarios en PHP, con soporte para mocks y stubs, escrito en PHP, para PHP.

Utilizando una sintaxis de test unitarios, simple y natural, Enhance PHP asegura ser la mejor opción para programadores que deseen comenzar rápidamente con test unitarios, mocks y stubs.

Enhance PHP planea cumplir los siguientes objetivos:

Ser el más rápido para comenzar a utilizar
Tener un estilo y sintaxis más familiar comparado con otros lenguajes
Inclusión de las características más necesarias
Arrojar reportes en formato HTML y XML

Los creadores de Enhance PHP, utilizan actualmente el framework para realizar los auto-test del proyecto. Las características principales del proyecto son:

Framework para test unitarios
Amplio rango de métodos assert
Mocks y Stubs que puedan ser verificados
Método simple de cobertura de las estadísticas integrado, que no requiere debugger

Sobre el Proyecto: Miembros del equipo

Diseño del logotipo, del sitio Web - Steve Fenton
Gestión de contenidos / Hosting - Swift Point
Framework Developer - Steve Fenton
Framework Advisor - Mark Jones

Visitar la Web del proyecto: http://www.enhance-php.com/

Europio v1.0 Final - Núcleo para Arquitecturas MVC Modulares en PHP 5 Orientado a Objetos

2011-09-07T21:51:00.000-03:00

Presentación de Europio

Europio V1.0 Final - Núcleo para Arquitecturas MVC Modulares en PHP 5 Orientado a Objetos:
Europio es un conjunto de Librerías PHP liberadas bajo licencia LGPL v3.0, compuestas de helpers, handlers, clases, funciones agregadas, un dispatcher de URLs y un ORM, diseñadas para actuar como núcleo (core) de aplicaciones modulares desarrolladas bajo el patrón arquitectónico Modelo-Vista-Controlador y programadas en PHP 5.3+ orientado a objetos.

Descargar Europio v1.0 final >>
Archivos 100% operativos y funcionales
(Todos los archivos + manual de referencias)

Descargar Manual de Europio 1.0 >>
Manual de referencias y guía de uso de Europio v1.0 final
(formato PDF)

Foro de Soporte de Europio v1.0 final >>
Acceso al soporte ténico sobre todo el core de Europio.
(foro abierto - no requiere registro)

Europio es Software Libre

Europio NO ES un framework, sino un "core", pensado y desarrollado para Arquitectos de Software avanzados y Analistas Programadores expertos, cuyo manejo del lenguaje PHP, el patrón arquitectónico MVC y la Programación Orientada a Objetos, sea altamente fluido, siendo su única finalidad, brindar un core básico y elemental, común a cualquier aplicación modularmente evolutiva y escalable, que permita no perder el tiempo en tareas repetitivas, facilitando así, la atención en la arquitectura propia de la aplicación (aquella única e irrepetible en cada software), en la creación de modelos que definan el comportamiento y característica de cada objeto, al tiempo de brindarles el apoyo necesario para centrarse únicamente en la ingeniería del sistema, dejando el diseño de interfaces, en manos de diseñadores especializados.

Europio está compuesto una suite de herramientas y librerías, preparadas para funcionar como núcleo de una aplicación modular. Las librerías y herramientas que lo componen son:

MissArchitect: Manejador de eventos para arquitecturas MVC y Despachador de URLs Amigables

MissArchitect es una mezcla de helpers, handlers y dispatcher de URLs, con “estandarizador de estilos”, diseñada para guiar la arquitecturas de aplicaciones PHP modulares, cuando se trabaja bajo el patrón arquitectónico MVC. En cierta forma, MissArchitect se comporta de forma similar a un Singleton sin serlo, ya que está integrado por dos clases finales, que solo podrán instanciarse una única vez. La finalidad de MissArchitect, es guiar las arquitecturas MVC, proveyendo un manejo absoluto de URL amigables, para controlar las vistas e invocar modelos, sumado a un manejador de peticiones de usuario que actúa de forma automáticamente con cada petición, invocando al controlador correspondiente, y ahorrando al programador, la tarea de tener que manejar dichos eventos.

MissArchitect ORM: Herramienta de mapeo relacional de datos

MissArchitect ORM es un ORM que se encarga de mapear relacionalmente los modelos de toda la aplicación (módulo por módulo) y generar el query necesario, para la creación íntegra de la base de datos relacional. Es la librería más nuevo del núcleo Europio, y pretende avanzar en la provisión de métodos CRUD para todos los módelos. Con la ayuda de MissArchitect ORM, solo bastará con crear los modelos de la aplicación y correr el ORM, para obtener el script de creación de la base de datos relacional, para toda la aplicación. MissArchitect ORM opera con el motor InnoDB permitiendo bases de datos datos relacionales robustas, a través de referencias con claves foráneas.

DBAbstractModel: Manejador de conexiones y consultas a MySQL

DBAbstractModel es una clase abstracta que permite manejar conexiones a bases de datos MySQL, proveyendo los métodos necesarios para ejecutar consultas de cualquier tipo, con solo indicar el query. DBAbstractModel utiliza el objeto mysqli de PHP 5.

PHPAggregate: Funciones agregadas para la validación de datos

PHPAggregate es una librería de funciones agregadas para PHP 5, destinadas a la validación de datos por medio de expresiones regulares. Entre sus funciones agregadas, pueden encontrarse:
Funciones para validación de correo electrónico
Validación de direcciones de IP
Validación de nombres personales, etc.

PHPValidator: Ayudante para PHPAggregate

PHPValidator es el complemento ideal para PHPAggregate ya que permite validar múltiples POST o GET datas, con las funciones agregadas de PHPAggregate, en un solo paso, con tan solo ser instanciado.

PHPTemplate: Métodos de renderización de diccionarios dinámicos

PHPTemplate es una clase PHP que permite la renderización de datos, basada en diccionarios dinámicos, permitiendo una abstracción absoluta de la lógica y el layout de las vistas, logrando una independencia absoluta de lenguajes de programación de los de diseño. Al ser una clase pública, puede ser heradada por la lógica de las vistas o instanciada.

EnhancePHP: Framework para Unit Testing

Agregado a la versión Alfa 7 de Europio, se suma EnhacenPHP. Un Framework para test unitarios con soporte para mocks, creado por Steve Fenton.

Branch a la versión Alfa 7: bzr branch lp:~eugeniabahit/europio/alfa-7.0
Descarga de EnhacenPHP: Descargar EnhancePHP desde LaunchPad
Documentación en español:

Documentación completa
Acceder a la Guía de Inicio rápido

Documentación completa en inglés: www.enhance-php.com

MissArchitect - core para arquitecturas MVC en PHP

2011-09-03T21:38:00.000-03:00

MissArchitect es una “mezcla” de helper, handler y dispatcher con “estandarizador de estilos” para arquitecturas MVC en PHP 5. Tal vez el objetivo más fuerte del proyecto MissArchitect, es simplemente, este último, y con poco código, obligar a mantener una arquitectura homogénea con reglas de estilo estandarizada, cuando se trabaja con el patrón modelo-vista-controlador en PHP 5 orientado a objetos.

Autor: Eugenia Bahit
Versión actual: Europio v1.0 Final (estable)
Licencia: LGPL v3 (software libre)
Descarga y Documentación completa:
https://launchpad.net/europio/+download

MissArchitect está desarrollado en PHP 5. Se encuentra integrado por dos clases finales, las cuales no pueden ser heradadas. Tanto sus métodos como propiedades, son privadas, por lo cual no pueden ser accedidas desde ninguna parte de la aplicación. Ambas clases cuentan con su método constructor correspondiente, motivo por el cual, solo requieren ser instanciadas para que cumplan su función.

MissArchitect, está especialmente diseñada, para manejar la arquitectura de aplicaciones modulares.

De forma automática, el core del framework, MissArchitectModule, se encarga de:

Generar las URL amigables (Friendly URLs) para todas las vistas del módulo
Importar todos los modelos, las lógicas de las vistas y los controladores del módulo
Manejar las peticiones del usuario
Invocar al controlador correspondiente
Normalizar la arquitectura y las reglas de estilo de la aplicación

Por otro lado, cuenta con MissArchitectApp: un helper que se encarga de retornar los paths de los módulos instalados en la aplicación, cuando ningún módulo ha sido invocado por el usuario.

Artículos escritos para otros sitios

2011-08-27T23:34:00.000-03:00

Debian Hackers

Test-First Programming ¿en Bash & Shell Scripting?
Reseña y mini-tutorial de shUnit. Un framework para Test Unitarios en Bash y Shell Scripting

Programación en Python

Guía de Programación Orientada a Objetos en Python
Completa guía en 9 capítulos, que enseña desde cero, como programar orientado a objetos en Python. Abarca desde los conceptos básicos y fundamentales de la POO, hasta interfaces gráficas y Unit Testing.
Publicado en Noviembre/2011 en MaestrosDelWeb.com

Manual de Metodologías Ágiles para el Desarrollo de Software

Introduciéndonos en el Desarrollo Ágil
Explicación de las metodologías de gestión de proyectos y en concreto del enfoque conocido como Agile.
Publicado el 25/08/2011 en DesarrolloWeb.com

Introducción al Desarrollo Ágil con Scrum
En este capítulo, haremos una vista general de Scrum, definiendo su enfoque y la propuesta al tiempo que lograremos un primer acercamiento a los pilares de sus pautas organizativas.
Publicado el 05/09/2011 en DesarrolloWeb.com

Los Roles en Scrum
Nos insertamos a fondo, en los roles propuestos por Scrum. Hablaremos sobre el Dueño de Producto, el Scrum Master y el Scrum Team. Cuáles son sus tareas y que aspectos deben cuidar cada uno de los roles.
Publicado el 14/09/2011 en DesarrolloWeb.com

Artefactos en Scrum
Hablamos sobre las herramientas que Scrum, propone para mantener organizado un proyecto de desarrollo de Software: el backlog de producto, el backlog de sprint y Scrum Taskboar, y el incremento de funcionalidad.
Publicado el 21/09/2011 en DesarrolloWeb.com

Ceremonias en Scrum
En este capítulo hablaremos sobre cómo llevar adelante, la planificación de un Sprint, las reuniones diarias del equipo con el Scrum Master, la revisión y la retrospectiva.
Publicado el 29/09/2011 en DesarrolloWeb.com

Artículos sobre programación en PHP

Introducción a la Programación Orientada a Objetos en PHP
Breve síntesis del libro "POO y MVC en PHP".
Publicado el 02/09/2011 en VitaminaWeb.com

Ordenar y filtrar resultados de consultas MySQL con PHP, sin saturar la base de datos
Ordenar y filtrar resultados de consultas MySQL con PHP, mediante la manipulación de arrays evitando consultas SQL anidadas y la saturación de la base de datos.
Publicado el 15/08/2011 en VitaminaWeb.com

Dos consejos para agilizar la escritura de código PHP (y su rendimiento)
Modificar valores de un array en un bucle foreach y Modificar variables globales evitando el uso de global y $GLOBALS.
Publicado el 15/08/2011 en VitaminaWeb.com

Opinión

Un médico a la derecha y un Freud a la Gerencia de Sistemas
Controversias e intercambio de roles en el área IT de las empresas. Un artículo de opinión que vale la pena ser leído para comprender mejor la diferencia real entre los diversos roles del área de la informática.
Publicado el 14/10/2011 en RootLinux.com.ar

Diseño Ágil con TDD (por Carlos Blé Jurado)

2011-08-04T21:30:00.001-03:00

Hace unos días, navegando por Internet y sin recordar qué estaba buscando con exactitud, me crucé con el libro Diseño Ágil con TDD del español Carlos Blé Jurado.

Apasionada como siempre por el Desarrollo Guiado por Pruebas - TDD - (al que al comienzo cuando lo conocí, me pareció que nunca iba a poder con él, pero luego, cuando "le tomé la mano" no me pude separar jamás) y por las metodologías ágiles como Scrum y XP, no puedo más que recomendar altamente este libro. Cuenta con unas 300 páginas e innumerable cantidad de códigos de ejemplo (lo siento "pehacheperos", pero esta vez, no hay PHP). Aún no terminé de leerlo, pero me ha "capturado" de una forma que no puedo desprenderme.

Si bien lo puedes descargar gratuitamente ya que es un aporte más con licencia Creative Commons, también puedes adquirir una versión impresa por solo US$ 26 y monedas, que recomiendo (obviamente si tienes una tarjeta de crédito y no como yo que me pierdo de toda compra por Internet por seguir resistiéndome "al plástico").

PHPFormValidator: Clase para validación automática de cualquier tipo de formulario

2011-07-26T20:37:00.005-03:00

Descripción: PHPFormValidator es una clase para PHP 5 que con tan solo instanciar al objeto PHPFormValidator y pasarle una matriz con el nombre de los campos del formulario con su tipo de datos correspondiente, lo validará exhaustivamente, devolviendo el resultado de la validación. PHPFormValidator trabaja en forma conjunta con PHPAggregate para la validación del tipo de datos.

Versión actual: Europio v1.0 Final (estable)
Autor: Eugenia Bahit
Licencia: LGPL v3 (software libre)
Requiere: Librería PHPAggregate

Descarga: https://launchpad.net/europio/+download

Importante!

Instanciar a PHPFormValidator pasándole los parámetros necesarios, tal cual se indica en Sintaxis

$fv = new FormValidator('POST', $array_field_list);

El objeto creado, retornará automáticamente dos propiedades públicas:
- $fv->invalid_fields una matriz con los nombres de los campos que no superaron la evaluación y el error correspondiente. $fv->invalid_fields devolverá NULL si todos los campos evaluados son correctos.
- $fv->form_data una matriz conteniendo el nombre de todos los campos y sus valores correspondientes.

Sintaxis:

$fv = new FormValidator('[GET|POST]', $array_field_list);

Parámetros:

string GET | string POST Método a través del cual, se envían los datos del formulario. El valor por defecto es POST, pero puede modificarlo, etableciéndolo en GET.

$array_field_list Matriz conteniendo el nombre de los campos a validar, su tipo de datos y parámetros opcionales para la validación (ver más abajo: "tipos de datos admitidos"). Su sintaxis es:
$array_field_list = array(
      'nombre_del_campo_1'=>array('tipo_de_datos', $requerid, [opciones]),
      'nombre_del_campo_5'=>array('tipo_de_datos', $requerid, [opciones]),
    );
Donde:
$requerid admite como valor TRUE o FALSE respondiendo a si es o no un campo obligatorio.
[opciones] (opcional) responde a los parámetros necesarios para validar el tipo de datos. Las opciones a pasar como parámetros adicionales responden al tipo de datos según las funciones de PHPAggregate

Tipos de datos admitidos:

A continuación, se muestra una tabla con los tipos de datos admitidos que pueden pasarse para ser validados:

Tipo de datos	Descripción	Parámetros
alphabetic	valida que una cadena contenga solo letras del alfabeto	is_alphabetic() (función de PHPAggregate)
alphanumeric	valida que una cadena contenga solo letras y números	is_alphanumeric() (función de PHPAggregate)
numeric	valida que una cadena contenga solo números	is_only_numbers() (función de PHPAggregate)
email	valida un e-mail	is_email() (función de PHPAggregate)
password	valida una contraseña estándar	is_password() (función de PHPAggregate)
secure_password	valida una contraseña segura	is_secure_password() (función de PHPAggregate)
ip	valida una dirección IP	is_ip() (función de PHPAggregate)
nickname username	valida un nickname (apodo, nombre de usuario)	is_nickname() (función de PHPAggregate)
personal_name	valida nombre y apellido completos de una persona	is_personal_name() (función de PHPAggregate)
spanish_date	valida una fecha con formato español (día, mes, año)	is_spanish_date() (función de PHPAggregate)
usa_date date	valida una fecha con formato americano (mes, día, año)	is_usa_date() (función de PHPAggregate)
iso_date canonical_date	valida una fecha con formato canónico (ISO: año, mes, día)	is_iso_date() (función de PHPAggregate)
string	valida que una cadena contenga entre n1 y n2 caracteres	is_strlen_between() (función de PHPAggregate)
boolean	valida que el dato sea de tipo booleano	is_bool() (función de PHP 4, PHP 5)

Valores devueltos:
El Objeto PHPFormValidator retorna dos propiedades públicas:

invalid_fields Array con el nombre de los campos evaluados como inválidos, con su correspondiente error.

form_data Array con el nombre de los campos evaluados y su correspondiente valor.

AVISO
invalid_fields retornará NULL cuando no existan campos evaluados como inválidos.

AVISO
PHPFormValidator retornará un error Warning: The execution was stopped! frenando la ejecución del script mediante una llamada a exit(), cuando un error de programación en la instancia al objeto sea encontrado.

Error Warning: The execution was stopped!
PHPFormValidator puede responder con el siguiente mensaje tras verse forzado a llamar al método exit() de PHP:

Warning: The execution was stopped!
validate_form() method said: I can not continue because I found an error programming in the received arguments: [error_description]

Los motivos retornados se detallan a continuación:

No $_GET data recived
Se produce cuando habiendo indicado a PHPFormValidator que el método de envío de datos del formulario es GET, el método constructor no recibe ninguna data vía $_GET

No $_POST data recived
Se produce cuando habiendo indicado a PHPFormValidator que el método de envío de datos del formulario es POST, el método constructor no recibe ninguna data vía $_POST

Arguments are not sufficient in the fields options
Se produce cuando la función de validación de datos llamada para comprobar un determinado campo, no encuentra los argumentes suficientes para ejecutarse.

Arguments are wrong
Para cada campo, PHPFormValidator espera una string con el nombre del tipo de datos y una variable booleana (TRUE o FALSE) para saber si el campo es o no obligatorio (es decir, si el usuario tiene la obligación de rellenar dicho campo). Cuando PHPFormValidator se encuentra con que el primer argumento del campo, no es una string o el segundo, no es boolean, retornará el error "Arguments are wrong"

[data_type] is an unknown data type
Se produce cuando el tipo de datos indicado para un determinado campo, no es un tipo de datos conocido (ver más arriba, la tabla: "Tipos de datos admitidos").

[field_name] was not found in the received array data
Se produce cuando se ha indicado el nombre de un campo inexistente. En este caso, se recomienda verificar la ortografía del nombre del campo indicado en [field_name], pues frecuente que este error se produzca por un error de tipeado.

$lista_de_campos = array(
    'nombre'=>array('personal_name', true), // llamará a is_personal_name.
    'email'=>array('email', true), // true indica que es campo obligatorio
    'telefono'=>array('numeric', true, false),
    'empresa'=>array('string', false, 3, 25), // 3 y 25 responden a argumentos adicionales de is_strlen_between de PHPAggregate
    'cargo'=>array('string', false, 3, 25),
    'fecha_nac'=>array('spanish_date', true, '-'),
    'newsletter'=>array('boolean', false),
    'asunto'=>array('string', true, 3, 50),
    'mensaje'=>array('string', true, 3, 1500)
);

include_once('phpformvalidator');

$fv = new PHPFormValidator('POST', $lista_de_campos);

// Obtener campos con errores
$errores = $fv->invalid_fields;

// Obtener los campos con sus datos
$data = $fv->form_data;

// Continuar el script de acuerdo a lo retornado por PHPFormValidator
if($fv->invalid_fields) { // si invalid_field NO es NULL
    print 'hubo errores en los siguientes campos:'.chr(10);
    foreach($fv->invalid_fields as $campo=>$error) {
        print '   * '.$campo.': '.$error.chr(10);
    }
} else {
    print 'Datos OK!!';
}

// Imprime en pantalla los datos recibidos
print chr(10).'Data recibida:'.chr(10);
foreach($fv->form_data as $nombre_campo=>$valor) {
    print $nombre_campo.': '.$valor.chr(10);
}

PHPTemplate - Clase PHP para manejar la lógica de las vistas en MVC

2011-07-24T06:30:00.011-03:00

Descripción: PHPTemplate es una clase para PHP 4 y PHP 5 que permite renderizar datos dinámicamente encargándose de manejar la lógica de las vistas cuando se trabaja con el patrón arquitectónico MVC. PHPTemplate, puede renderizar tanto datos individuales como patrones iterativos, lo cual permite una abstracción absoluta de la vista, facilitando la individualización de archivos y lenguajes de programación. PHPTemplate ha sido incluida como parte del proyecto Europio PHPLibraries.

Versión actual: Europio v1.0 Final (estable)
Autor: Eugenia Bahit
Licencia: LGPL v3 (software libre)

Descarga: https://launchpad.net/europio/+download

Métodos de la clase PHPExtendableTemplate

Métodos públicos	Métodos protegidos
get_content	get_file
get_loop_content	render_data
-	render_loop_data

get_content
Renderizar datos individuales. Método público accesible desde cualquier instancia de PHPExtendableTemplate.

Sintaxis:

get_content($array_diccionario, $file, $folder);

Parámetros:

$array_diccionario Array conteniendo el diccionario de datos a renderizar, donde las claves son los datos a ser reemplazados y los valores, el dato dinámico por el cual se reemplazarán las claves. Un ejemplo de ello, es el siguiente:
$array_diccionario = array(
    '{clave_1}'=>'reemplazar por este dato',
    '{clave_2}'=>'reemplazar por este otro dato',
  );

$file (opcional) Nombre del archivo que contiene el template html. Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE

$folder (opcional) Localización del archivo que contiene el template html (es decir, la ruta de las carpetas). Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE_FOLDER

Valores devueltos:
Devuelve el código HTML del archivo pasado con los datos renderizados.

// crear diccionario de datos
$dict = array(
     '{title}'=>'PHPExtendableTemplate para PHP 5',
     '{subtitle}'=>'Ejemplo de uso'
    );

// nombre del archivo html del template
$file = 'my_template.html';

// localización del archivo
$folder = '/any_folder/templates_folder/';

// importar la clase PHPExtendableTemplate
require_once('phpextendabletemplate.php');

// instanciar a PHPExtendableTemplate
$PHPExtendableTemplate = new PHPExtendableTemplate();

// llamada al método get_content
$content = $PHPExtendableTemplate->get_content($dict, $file, $folder);
/*
    get_content() reemplazará todas 
    las insidencias de {title} por 
    PHPExtendableTemplate para PHP 5
    y las de {subtitle} por
    Ejemplo de uso
*/

// imprimir la vista renderizada en pantalla
print $content;

get_loop_content
Renderizar diccionario de datos individuales y datos iterativos. Método público accesible desde cualquier instancia de PHPExtendableTemplate.
Este método es una extensión/ampliación del método get_content. Si get_loop_content es llamado, get_content no necesita ser llamado.

IMPORTANTE:
get_loop_content debe identificar los "bloques" de código HTML que deben ser renderizados cíclicamente.
A fin de lograr una abstracción e individualización absoluta de lenguajes (evitando colocar código PHP con HTML en el mismo archivo), get_loop_content utiliza "identificadores" para localizar los patrones.
Estos identificadores de patrones de código HTML deben escribirse a modo de comentarios HTML y su sintáxis es la siguiente:

<!--iniloop:nombre_del_identificador-->
write your HTML code here! 
And replace {this_data} iteratively


<!--endloop:nombre_del_identificador-->

nombre_del_identificador debe ser cualquier string con la que desees identificar el fragmento de código HTML que será renderizado iterativamente.

Sintaxis:

get_loop_content($array_iterative_data, $array_diccionario, $file, $folder);

Parámetros:

$array_iterative_data Array conteniendo el diccionario de datos iterativos a renderizar, donde:
las claves son los nombres de los identificadores de los patrones HTML a renderizar (ejemplo: identificador_1)
el valor de cada clave-identificador será otro array
dentro de éste, habrá tantos array como iteraciones a realizar. Cada uno de estos array, estará formado por:
clave: los datos a ser reemplazados
valor: el dato dinámico por el cual se reemplazarán las claves.
Un ejemplo de ello, es el siguiente:
$array_iterative_data = array(
    'identificador_1'=>array(
        array('{site_name}'=>'Google',
              '{site_url}'=>'www.google.com'
             ),
        array('{site_name}'=>'Yahoo!',
              '{site_url}'=>'www.yahoo.com'
             )
        ),
    'identificador_2'=>array(
        array('{name}'=>'Creedence Clearwater Revival',
              '{song}'=>'Fortunate Son',
              '{id}'=>127587
             ),
        array('{name}'=>'Bob Seger',
              '{song}'=>'Fire Lake',
              '{id}'=>987492
             )
        )
    );
Nótese que el formato del array de cada identificador, es el formato de salida de consultas SQL que son almacenadas en una matriz. Esto significa, que dichos datos, pueden ser traídos desde una consulta a base de datos. Suponiendo que la consulta SQL arroje los datos en una variable llamada $results, usted podría formar el array, de la siguiente manera:
$array_iterative_data = array(
        'identificador_1'=>$results,
    );
Si tuviese varias consultas SQL, el procedimiento continuaría siendo igual de sencillo:
$array_iterative_data = array(
        'identificador_1'=>$results_sql_1,
        'identificador_2'=>$results_sql_2,
        'identificador_3'=>$results_sql_3,
    );
Tenga en cuenta, que la finalidad del método get_loop_content, es permitirle renderizar datos iterativos habiendo sido diseñado primordialmente para renderizar datos extraídos de consultas SQL.

$array_diccionario Array conteniendo el diccionario de datos a renderizar, donde las claves son los datos a ser reemplazados y los valores, el dato dinámico por el cual se reemplazarán las claves. Un ejemplo de ello, es el siguiente:
$array_diccionario = array(
    '{clave_1}'=>'reemplazar por este dato',
    '{clave_2}'=>'reemplazar por este otro dato',
  );

$file (opcional) Nombre del archivo que contiene el template html. Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE

$folder (opcional) Localización del archivo que contiene el template html (es decir, la ruta de las carpetas). Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE_FOLDER

Valores devueltos: Devuelve el código HTML del archivo pasado con los datos renderizados. CÓDIGO HTML DE EJEMPLO

<!doctype html>
<html>
  <head>
    <title>{title}</title>
  </head>
  <body>
    <h1>Sites</h1>
    <ul>
      <!--iniloop:identificador_1-->
      <li><b>{site_name}</b><br />
        <a href="http://{site_url}" title="go to {site_name}">{site_url}</a>
      </li>
      <!--endloop:identificador_1-->
    </ul>
    <h1>Songs</h1>
    <ul>
      <!--iniloop:identificador_2-->
      <li><b>{song} (ID: {id})</b><br />
        {name}
      </li>
      <!--endloop:identificador_2-->
    </ul>
  </body>
</html>

CÓDIGO PHP DE EJEMPLO

// crear diccionario de datos simples
$dict = array(
     '{title}'=>'Example'
    );

// arma diccionario de datos iterativos

// diccionario identificador_1
$web_sites = array(
    array('{site_name}'=>'Google',
          '{site_url}'=>'www.google.com'
         ),
    array('{site_name}'=>'Yahoo!',
          '{site_url}'=>'www.yahoo.com'
         ),
    array('{site_name}'=>'Facebook',
          '{site_url}'=>'www.facebook.com'
         )
    );

// diccionario identificador_2
$rock_bands = array(
    array('{name}'=>'Creedence Clearwater Revival',
          '{song}'=>'Fortunate Son',
          '{id}'=>127587
         ),
    array('{name}'=>'Bob Seger',
          '{song}'=>'Fire Lake',
          '{id}'=>987492
         ),
    array('{name}'=>'Bachman-Turner Overdrive',
          '{song}'=>'Life Still Goes On',
          '{id}'=>323274
         ),
    array('{name}'=>'Johnny Rivers',
          '{song}'=>'Sunny',
          '{id}'=>300598
         )
    );

// array identificadores
$array_iterative_data = array(
    'identificador_1'=>$web_sites,
    'identificador_2'=>$rock_bands
    );


// nombre del archivo html del template
$file = 'base_template.html';

// localización del archivo
$folder = 'site_media/html/';

// importar la clase PHPExtendableTemplate
require_once('core/phpextendabletemplate.php');

// instanciar a PHPExtendableTemplate
$PHPExtendableTemplate = new PHPExtendableTemplate();

// llamada al método get_content
$content = $PHPExtendableTemplate->get_loop_content(
                $array_iterative_data,
                $dict, $file, $folder);

// imprimir la vista renderizada en pantalla
print $content;

get_loop_content imprimirá la siguiente pantalla:

get_file
Método protegido. Devuelve el código HTML del archivo especificado sin renderizar. Solo puede ser llamado desde clases que hereden de PHPExtendableTemplate.

Sintaxis:

get_file($file, $folder);

Parámetros:

$file (opcional) Nombre del archivo que contiene el template html. Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE

$folder (opcional) Localización del archivo que contiene el template html (es decir, la ruta de las carpetas). Este valor es opcional ya que de no indicarse, tomará por defecto el valor asignado en la constante de clase DEFAULT_TEMPLATE_FOLDER

Valores devueltos:
Devuelve una string con el código HTML del archivo especificado sin renderizar.

render_data
Método protegido. Devuelve código HTML renderizado, del contenido que se le haya pasado como parámetro. Solo puede ser llamado desde clases que hereden de PHPExtendableTemplate.

Sintaxis:

render_data($array_diccionario, $string_contenido);

Parámetros:

$array_diccionario Array conteniendo el diccionario de datos a renderizar, donde las claves son los datos a ser reemplazados y los valores, el dato dinámico por el cual se reemplazarán las claves. Un ejemplo de ello, es el siguiente:
$array_diccionario = array(
    '{clave_1}'=>'reemplazar por este dato',
    '{clave_2}'=>'reemplazar por este otro dato',
  );

$contenido String conteniendo el código HTML a ser renderizado (generalmente, el código devuelto por get_file()

Valores devueltos:
Devuelve una string con el código HTML renderizado, del contenido que se le haya pasado como parámetro.

render_loop_data
Método protegido. Devuelve código HTML renderizado, del contenido iterativo que se le haya pasado como parámetro. Solo puede ser llamado desde clases que hereden de PHPExtendableTemplate.

Sintaxis:

render_loop_data($string_nombre_del_identificador, $string_contenido, $array_diccionario);

Parámetros:

$string_nombre_del_identificadorString. Nombre del identificador del bloque HTML a renderizar iterativamente. El nombre del identificador es el que se asigna con la sintaxis:

$string_contenido String conteniendo el código HTML que contiene el bloque a ser renderizado (generalmente, el código devuelto por get_file(). Este contenido debe contener al menos un bloque HTML inicializado por los tags-comentados  y

$array_diccionario Array conteniendo sub-arrays con los datos iterativos a ser reemplazos:

$array_diccionario = array(
    array('{clave_1}'=>'Valor 1',
          '{clave_2}'=>'valor 2'
         ),
    array('{clave_1}'=>'Valor 3',
          '{clave_2}'=>'valor 4'
         ),
    );

Valores devueltos:
Devuelve una string con el código HTML renderizado, del contenido iterativo que se le haya pasado como parámetro

DBAbstractModel - Clase PHP 5 para insertar, eliminar, actualizar y seleccionar datos de una DB MySQL

2011-07-24T01:43:00.005-03:00

Descripción: DBAbstractModel es una clase abstracta sencilla, para PHP que opera en forma conjunta con la clase mysqli() de PHP 5, permitiendo insertar, actualizar, eliminar y seleccionar datos de bases de datos MySQL.

Versión actual: Europio v1.0 Final
Autor: Eugenia Bahit
Licencia: LGPL v3 (software libre)

Descargar archivos: https://launchpad.net/europio/+download
Manual de referencias: https://launchpad.net/europio/+download

Entendiendo la clase
DBAbstractModel declara cuatro métodos abstractos: insert(), delete(), update() y select(), que deben ser re-definidos en la/s clase/s que la hereden (o comentados en la propia clase a fin de evitar errores).

Esta clase abstracta pretende servir como modelo a clases cuyos objetos, requieran de métodos donde sea necesario realizar consultas a bases de datos. No es una librería para conectarse a una base de datos desde cualquier ámbito. Es una clase abstracta que no puede ser instanciada, sino que necesita ser heredada por otra clase.

DBAbstractModel declara y define el algoritmo de cuatro métodos no abstractos, de los cuales, uno de ellos permite ejecutar cualquier sentencia SQL INSERT, UPDATE o DELETE y otro, sentencias SELECT.

Las clases que hereden de DBAbstractModel, además de re-definir los cuatros métodos abstractos, podrá llamar a cualquiera de los dos métodos no abstractos (mencionados en el párrafo anterior), redifiniendo el valor de las propiedades $this->query (sentencia SQL a ser ejecutada) y $this->db_name (base de datos a utilizar).

Si necesita saber más sobre el uso de clases abstractas en PHP 5, le recomiendo descargar gratuitamente el libro POO y MVC en PHP.

Modificar HOST, USUARIO y/o CONTRASEÑA
DBAbstractModel necesita que le sean modificados los valores de tres de sus propiedades estáticas: $db_host, $db_user y $db_pass, con el host de la base de datos, el usuario y contraseña respectivamente.

Si necesita modificar host, usuario y contraseña de la base de datos en las clases que hereden de DBAbstractModel, deberá cambiar (en DBAbstractModel) la visibilidad de las propiedades que necesite modificar, de privadas a protegidas y además, quitarles el atributo de estáticas, de modo tal que el bloque:

private static $db_host = 'localhost';
private static $db_user = 'usuario';
private static $db_pass = 'clave';

se vea de la siguiente forma:

protected $db_host = 'localhost';
protected $db_user = 'usuario';
protected $db_pass = 'clave';

Creando una clase heredada de DBAbstractModel
Recuerde que por defecto, usted debe re-definir los cuatro métodos que se muestran a continuación. Si alguno de los métodos no fuese a utilizarlos en NINGUNA clase de las que heredan de DBAbstractModel, podrá comentarlos en dbabstractmodel.php o re-definirlos sin un algoritmo. Rcuerde tambien, establecer la visibilidad de cada método. Por defecto, los cuatro métodos son declarados con visibilidad protegida.

require_once('dbabstractmdel.php');
class MiClase extends DBAbstractModel {

    // métodos obligatorios. 
    // deberá comentarlos en DBAbstractModel si no desea utilizarlos
    protected function insert() {
        $this->query = "INSERT INTO tabla (campo) VALUES (1)";
        $this->execute_single_query();
    }

    protected function delete() {
        $this->query = "DELETE FROM tabla WHERE campo=1";
        $this->execute_single_query();
    }

    protected function update() {
        $this->query = "UPDATE tabla SET campo=7 WHERE campo=1";
        $this->execute_single_query();
    }

    public function select() {
        $this->query = "SELECT * FROM tabla";
        $this->get_results_from_query();
        // retorna un array con los resultados $this->rows;
    }

}

PHPAggregate - Librería GPL de funciones agregadas de validación de datos para PHP

2011-07-19T00:06:00.028-03:00

Descripción: PHPAggregate es una librería para PHP 4 y PHP 5, de funciones de validación de datos básicos como direcciones de correo electrónico, cadenas de texto, direcciones IP, nombres de usuario y contraseñas, fechas, entre otros. La librería PHPAggregate, está basada en expresiones regulares y utiliza mayormente, la función preg_match() de PHP 4 para evaluar dichas expresiones.

DESCARGA: https://launchpad.net/europio/+download

Funciones incluidas
is_email valida un e-mail
is_password valida una contraseña estándar
is_secure_password valida una contraseña segura
is_ip valida una dirección IP
is_alphabetic valida que una cadena contenga solo letras del alfabeto
is_alphanumeric valida que una cadena contenga solo letras y números
is_only_numbers valida que una cadena contenga solo números
is_nickname valida un nickname (apodo, nombre de usuario)
is_personal_name valida nombre y apellido completos de una persona
is_strlen_between valida que una cadena contenga entre n1 y n2 caracteres
is_spanish_date valida una fecha con formato español (día, mes, año)
is_usa_date valida una fecha con formato americano (mes, día, año)
is_canonical_date valida una fecha con formato canónico (ISO: año, mes, día)

is_email: Valida direcciones de correo electrónico tradicionales. Sintaxis:

is_email($string);

Parámetros:

$string Cadena a evaluar

Valores devueltos: Devuelve TRUE si la cadena evaluada es una dirección de e-mail con formato válido. De lo contrario, devuelve FALSE.

$email = 'nombre.apellido_78@algundominio.com';
if(is_email($email) == true) {
    print $email . ' es un e-mail válido';
} else {
    print $email . ' no es un e-mail válido';
}

// Imprime:
// nombre.apellido_78@algundominio.com es un e-mail válido

is_password: Valida contraseñas alfanuméricas convencionales. Permite letras minúsculas de la "a" a la "z"; mayúsculas de la "A" a la "Z" y números. No acepta otros caracteres. Sintaxis:

is_password($string, $int_min, $int_max);

Alias: La función is_password puede ser llamada también, como:

is_aZ9_between is_aZ9_password

Parámetros:

$string Cadena a evaluar

$int_min (opcional) Número entero. Indica la cantidad mínima de caracteres que puede tener. El valor por defecto es 6.

$int_max (opcional) Número entero. Indica la cantidad máxima de caracteres que puede tener. El valor por defecto es 18.

Valores devueltos: Devuelve TRUE si la cadena evaluada es una contraseña válida. De lo contrario, devuelve FALSE.

$passwords = array('clave 1'=&amp;gt;'aKgt67',
                   'clave 2'=&amp;gt;'holamundo',
                   'clave 3'=&amp;gt;'incorrect_pass',
                   'clave 4'=&amp;gt;'h5Tm',
                   'clave 5'=&amp;gt;'*v*765-la'
                  );

foreach($passwords as $clave=&amp;gt;$valor) {
    if(is_password($valor) == true) {
        print $clave . ' es correcta';
    } else {
        print $clave . ' no es correcta';
    }
}

/*
Salida:

clave 1 es correcta
clave 2 es correcta
clave 3 no es correcta
clave 4 no es correcta
clave 5 no es correcta

*/

is_secure_password: Valida contraseñas seguras que deban incluir al menos una letra mayúscula (A-Z), una minúscula (a-z), un número (0-9) y al menos 1 de los siguientes caracteres especiales: !, ¡, #, $, %, &amp;, /, ?, ¿, *, +, -, _, @

Sugerencia:Para que una contraseña sea almacenada de forma segura, lo mejor es proceder a su cifrado MD5 o similar.

Sintaxis:

is_secure_password($string, $int_min, $int_max)

Parámetros:

$string Cadena a evaluar

$int_min (opcional) Número entero. Indica la cantidad mínima de caracteres que puede tener. El valor por defecto es 8.

$int_max (opcional) Número entero. Indica la cantidad máxima de caracteres que puede tener. El valor por defecto es 64.

Valores devueltos: Devuelve TRUE si la cadena evaluada es una contraseña segura válida. De lo contrario, devuelve FALSE.

$passwords = array('clave 1'=&amp;gt;'aKgt67',
                   'clave 2'=&amp;gt;'hola*mundo',
                   'clave 3'=&amp;gt;'Any_paSsw0rd',
                   'clave 4'=&amp;gt;'h5Tm*',
                   'clave 5'=&amp;gt;'*v*765-lA'
                  );

foreach($passwords as $clave=&amp;gt;$valor) {
    if(is_secure_password($valor) == true) {
        print $clave . ' es una clave segura'.chr(10);
    } else {
        print $clave . ' no es una clave segura'.chr(10);
    }
}

/*
Salida:


clave 1 no es una clave segura
clave 2 no es una clave segura
clave 3 es una clave segura
clave 4 no es una clave segura
clave 5 es una clave segura

*/

is_ip: Valida direcciones IP. Sintaxis:

is_ip($string);

Parámetros:

$string Cadena a evaluar

Valores devueltos: Devuelve TRUE si $string es una dirección IP váida. De lo contrario, devuelve FALSE.

$ip_addresses = array('IP 1'=&amp;gt;'20064390',
                      'IP 2'=&amp;gt;'200.64.3.90',
                      'IP 3'=&amp;gt;'0.0.1.10'
                     );

foreach($ip_addresses as $ip=&amp;gt;$valor) {
    if(is_ip($valor) == true) {
        print $ip . ' es correcta'.chr(10);
    } else {
        print $ip . ' no es correcta'.chr(10);
    }
}

/*
Salida:


IP 1 no es correcta
IP 2 es correcta
IP 3 es correcta

*/

is_alphabetic: Valida que una cadena de texto contenga únicamente letras mayúsculas y minúsculas entre la "a" y la "z". Sintaxis:

is_alphabetic($word);

Parámetros:

$word Palabra/cadena a ser evaluada

Valores devueltos: Devuelve TRUE si la cadena contiene solo letras del abecedarios (mayúsculas y/o minúsculas). De lo contrario, devuelve FALSE.

$words = array('Palabra 1'=&amp;gt;'esto es una oración pero no una palabra',
               'Palabra 2'=&amp;gt;'Palabra',
               'Palabra 3'=&amp;gt;'PostgreSQL',
               'Palabra 4'=&amp;gt;'PHP',
               'Palabra 5'=&amp;gt;'PHP4',
               'Palabra 6'=&amp;gt;'PHP 5',
              );

foreach($words as $word=&amp;gt;$valor) {
    if(is_alphabetic($valor) == true) {
        print $word . ' tiene solo letras'.chr(10);
    } else {
        print $word . ' no tiene solo letras'.chr(10);
    }
}

/*
Salida:


Palabra 1 no tiene solo letras
Palabra 2 tiene solo letras
Palabra 3 tiene solo letras
Palabra 4 tiene solo letras
Palabra 5 no tiene solo letras
Palabra 6 no tiene solo letras

*/

is_personal_name: Valida nombres personales completos (nombres y apellidos / apellidos y nombres) siendo sensible a mayúsculas y minúsculas. Admite apóstrofos característicos en apellidos de origen italiano y francés. No admite abreviaciones, respondiendo afirmativamente solo a la consigna "nombre completo" (Juan C López retornaría una negación a is_personal_name, puesto que lingüísticamente no responde a "nombre completo" sino que la "C" es abreviación del segundo nombre. (véase ejemplo para una idea más amplia de los formatos de nombres admitidos y no admitidos) Sintaxis:

is_personal_name($string);

Parámetros:

$string Cadena a evaluar

Valores devueltos: Devuelve TRUE si $string es un nombre personal válido. De lo contrario, devuelve FALSE.

$names = array('Nombre 1'=&amp;gt;'Juan Carlos Lopez',
               'Nombre 2'=&amp;gt;'Juan Carlos Lopez y Planes',
               'Nombre 3'=&amp;gt;'Juan Lopez',
               'Nombre 4'=&amp;gt;'Juan Carlos D\'Alessando',
               'Nombre 5'=&amp;gt;'Juan Carlos D\'alessandro',
               'Nombre 6'=&amp;gt;'Juan C Lopez',
               'Nombre 7'=&amp;gt;'juan carlos lopez',
               'Nombre 7'=&amp;gt;'Juan carlos Lopez',
               'Nombre 8'=&amp;gt;'Juan',
               'Nombre 9'=&amp;gt;'Juan CL',
               'Nombre 10'=&amp;gt;'Juan C L',
               'Nombre 11'=&amp;gt;'J C Lopez',
               'Nombre 12'=&amp;gt;'JC Lopez',
               'Nombre 13'=&amp;gt;'Lopez Juan Carlos',
               'Nombre 14'=&amp;gt;'Lopez y Planes Juan Carlos',
               'Nombre 15'=&amp;gt;'Lopez Y Planes Juan Carlos',
               'Nombre 16'=&amp;gt;'D\'Alessandro Juan Carlos',
               'Nombre 17'=&amp;gt;'D\'alessandro Juan Carlos',
               'Nombre 18'=&amp;gt;'Juan Carlos D\' Alessandro'
              );

foreach($names as $name=&amp;gt;$valor) {
    if(is_personal_name($valor) == true) {
        print $valor . ' es un nombre personal valido';
    } else {
        print $valor . ' no es un nombre valido';
    }
}

/*
Salida:


Juan Carlos Lopez es un nombre personal valido
Juan Carlos Lopez y Planes es un nombre personal valido
Juan Lopez es un nombre personal valido
Juan Carlos D'Alessando es un nombre personal valido
Juan Carlos D'alessandro es un nombre personal valido
Juan C Lopez no es un nombre valido
Juan carlos Lopez no es un nombre valido
Juan no es un nombre valido
Juan CL no es un nombre valido
Juan C L no es un nombre valido
J C Lopez no es un nombre valido
JC Lopez no es un nombre valido
Lopez Juan Carlos es un nombre personal valido
Lopez y Planes Juan Carlos es un nombre personal valido
Lopez Y Planes Juan Carlos no es un nombre valido
D'Alessandro Juan Carlos es un nombre personal valido
D'alessandro Juan Carlos es un nombre personal valido
Juan Carlos D' Alessandro no es un nombre valido

*/

Nótese que is_personal_name también devolverá FALSE si $string comienza o finaliza con un espacio en blanco.

is_alphanumeric: Valida que una cadena solo contenga letras mayúsculas y/o minúsculas y/o números. Sintáxis:

is_alphanumeric($string);

Parámetros:

$string Cadena a evaluar

Valores devueltos: Devuelve TRUE si la cadena evaluada contiene únicamente letras (mayúsculas y/o minúsculas) y/o números. De lo contrario, devuelve FALSE.

$cadenas = array('Cadena 1'=&amp;gt;'abdgdt',
                 'Cadena 2'=&amp;gt;'aKjhP8Y',
                 'Cadena 3'=&amp;gt;'ahY lK7',
                 'Cadena 4'=&amp;gt;'JAHDG',
                 'Cadena 5'=&amp;gt;'Jkj_D2G'
                );

foreach($cadenas as $cadena=&amp;gt;$valor) {
    if(is_alphanumeric($valor) == true) {
        print $cadena . ' es alfanumerica
';
    } else {
        print $cadena . ' no es alfanumerica
';
    }
}

/*
Salida:


Cadena 1 es alfanumerica
Cadena 2 es alfanumerica
Cadena 3 no es alfanumerica
Cadena 4 es alfanumerica
Cadena 5 no es alfanumerica

*/

is_only_numbers: Valida que una cadena contenga solo números y opcionalmente puede permitir el ingreso de 1 guión medio (-) entre números. Sintaxis:

is_only_numbers($string, $allow_dash);

Parámetros:

$string Cadena a evaluar

$allow_dash (opcional). Boolean. True, para permitir un guión medio entre números. False, para no permitir guiones medios. Valor por defecto: FALSE

Valores devueltos: Devuelve TRUE si la cadena evaluada contiene solo números (y guiones medios si $allow_dash se indicó como true). De lo contrario, retorna FALSE.

$cadenas = array('Cadena 1'=&amp;gt;'65845',
                 'Cadena 2'=&amp;gt;'8 6584',
                 'Cadena 3'=&amp;gt;'656-9852',
                 'Cadena 4'=&amp;gt;'56+558',
                 'Cadena 5'=&amp;gt;'25.15',
                 'Cadena 6'=&amp;gt;'325_458',
                 'Cadena 7'=&amp;gt;'+54 (911) 0000-0000',
                 'Cadena 8'=&amp;gt;'+54 011 00000000',
                 'Cadena 9'=&amp;gt;'15-4444-9999'
                );

foreach($cadenas as $cadena=&amp;gt;$valor) {
    if(is_only_numbers($valor) == true) {
        print $cadena . ' contiene solo numeros
';
    } else {
        print $cadena . ' no contiene solo numeros
';
    }
}

/*
Salida:
Cadena 1 contiene solo numeros
Cadena 2 no contiene solo numeros
Cadena 3 no contiene solo numeros
Cadena 4 no contiene solo numeros
Cadena 5 no contiene solo numeros
Cadena 6 no contiene solo numeros
Cadena 7 no contiene solo numeros
Cadena 8 no contiene solo numeros
*/


$cadenas = array('Cadena 1'=&amp;gt;'65845',
                 'Cadena 2'=&amp;gt;'8 6584',
                 'Cadena 3'=&amp;gt;'656-9852',
                 'Cadena 4'=&amp;gt;'56+558',
                 'Cadena 5'=&amp;gt;'25.15',
                 'Cadena 6'=&amp;gt;'325_458',
                 'Cadena 7'=&amp;gt;'+54 (911) 0000-0000',
                 'Cadena 8'=&amp;gt;'+54 011 00000000',
                 'Cadena 9'=&amp;gt;'15-4444-9999'
                );

foreach($cadenas as $cadena=&amp;gt;$valor) {
    if(is_only_numbers($valor, true) == true) {
        print $cadena . ' contiene solo numeros
';
    } else {
        print $cadena . ' no contiene solo numeros
';
    }
}

/*
Salida:
Cadena 1 contiene solo numeros
Cadena 2 no contiene solo numeros
Cadena 3 contiene solo numeros
Cadena 4 no contiene solo numeros
Cadena 5 no contiene solo numeros
Cadena 6 no contiene solo numeros
Cadena 7 no contiene solo numeros
Cadena 8 no contiene solo numeros
Cadena 9 contiene solo numeros
*/

is_nickname: Valida apodos (nicknames o nombres de usuario) que solo puedan contener al menos una o más letras y/o uno o más números, permitiendo guiones bajos (_) consecutivos al inicio, final o entre medio de la cadena. Sintaxis:

is_nickname($string, $int_min, $int_max);

Parámetros:

$string Cadena a ser evaluada

$int_min (opcional) Número entero. Cantidad de caracteres mínimos que puede contener la cadena. El valor por defecto es 6.

$int_max (opcional) Número entero. Indica la cantidad de caracteres máximos que puede contener la cadena. El valor por defecto es 12.

Valores devueltos: Devuelve TRUE si $string es un nickname válido. De lo contrario, retorna FALSE.

$nicknames = array('Nick 1'=&amp;gt;'____jr___75',
                   'Nick 2'=&amp;gt;'cuervo72',
                   'Nick 3'=&amp;gt;'____TurKa_ar',
                   'Nick 4'=&amp;gt;'__^yop^__',
                   'Nick 5'=&amp;gt;'@myself',
                   'Nick 6'=&amp;gt;'juan carlos',
                   'Nick 7'=&amp;gt;'juan-carlos',
                   'Nick 8'=&amp;gt;'juan_carlos'
                  );

foreach($nicknames as $nick=&amp;gt;$valor) {
    if(is_nickname($valor) == true) {
        print $nick . ' es valido
';
    } else {
        print $nick . ' no es valido
';
    }
}

/*
Salida:
Nick 1 es valido
Nick 2 es valido
Nick 3 es valido
Nick 4 no es valido
Nick 5 no es valido
Nick 6 no es valido
Nick 7 no es valido
Nick 8 es valido
*/

is_strlen_between: Evalúa si una cadena tiene entre n1 y n2 caracteres permitiendo o no espacios en blanco. Sintaxis:

is_strlen_between($string, $int_min, $int_max, $allow_white_spaces);

Parámetros:

$string Cadena a ser evaluada

$int_min (opcional) Numero entero. Cantidad mínima de caracteres que debe tener la cadena. Valor por defecto: 1.

$int_max (opcional) Numero entero. Cantidad máxima de caracteres permitidos. Valor por defecto: 255.

$allow_white_spaces (opcional) Boolean. True para permitir espacios en blanco. False para no permitir espacios en blanco. Valor por defecto: FALSE

Valores devueltos: Devuelve TRUE si si la cantidad de caracteres de la cadena está entre n1 y n2. De lo contrario, devuelve FALSE.

$cadena = 'Esta es una cadena que tiene más caracteres de los permitidos';

if(is_strlen_between($cadena, 6, 25, true) == true) {
    print 'Cadena es correcta';
} else {
    print 'Cadena es incorrecta';
}

/*
Salida:
Cadena es incorrecta
*/

is_spanish_date: Evalúa si una fecha tiene formato español día, mes, año, aceptando como separador: /, - y . (25/10/2008, 25-10-2008, 25.10.2008). Además del formato, evalúa que sea una fecha válida llamando a la función checkdate() de PHP (tiene en cuenta años bisiestos).

Incluida a partir de la versión Beta 1.1

Sintaxis:

is_spanish_date($string_date, $string_separador);

Parámetros:

$string Cadena a ser evaluada como fecha

$string_separador (opcional) Separador para día, mes, año. Acepta: barra (/), guión medio (-) y punto (.). Valor por defecto: '/'.

Valores devueltos: Devuelve TRUE si si la cadena es una fecha válida, con formato español válido. De lo contrario, devuelve FALSE.

$fecha = '25/02/1970';

if(is_spanish_date($fecha) == true) {
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

$fecha = '25-02-1970';

if(is_spanish_date($fecha, '-') == true) {
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

is_usa_date: Evalúa si una fecha tiene formato americano, mes, día, año, aceptando como separador: /, - y . (10/25/2008, 10-25-2008, 10.25.2008). Además del formato, evalúa que sea una fecha válida llamando a la función checkdate() de PHP (tiene en cuenta años bisiestos).

Incluida a partir de la versión Beta 1.1

Sintaxis:

is_usa_date($string_date, $string_separador);

Parámetros:

$string Cadena a ser evaluada como fecha

$string_separador (opcional) Separador para día, mes, año. Acepta: barra (/), guión medio (-) y punto (.). Valor por defecto: '/'.

Valores devueltos: Devuelve TRUE si si la cadena es una fecha válida, con formato americano válido. De lo contrario, devuelve FALSE.

$fecha = '02/25/1970';

if(is_usa_date($fecha) == true) {
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

$fecha = '02-25-1970';

if(is_usa_date($fecha, '-') == true) {
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

is_canonical_date: Evalúa si una fecha tiene formato canónico (ISO), año, mes, día, aceptando como separador: /, - y . (2008/10/25, 2008-10-25, 2008.10.25). Además del formato, evalúa que sea una fecha válida llamando a la función checkdate() de PHP (tiene en cuenta años bisiestos).

Incluida a partir de la versión Beta 1.1

Alias: is_iso_date Sintaxis:

is_canonical_date($string_date, $string_separador);

Parámetros:

$string Cadena a ser evaluada como fecha

$string_separador (opcional) Separador para día, mes, año. Acepta: barra (/), guión medio (-) y punto (.). Valor por defecto: '/'.

Valores devueltos: Devuelve TRUE si si la cadena es una fecha válida, con formato canónico (ISO) válido. De lo contrario, devuelve FALSE.

$fecha = '1970-25-02';

if(is_canonical_date($fecha, '-') == true) {
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

if(is_iso_date($fecha, '-') == true) { // alias de is_canonical_date
    print 'Es una fecha válida';
} else {
    print 'Fecha es incorrecta';
}

/*
Salida:
Es una fecha válida
*/

Scrum: Cartas para Planning Pocker

2011-07-16T03:32:00.004-03:00

Navegando en Internet, me encontré estas espectaculares cartas para Planning Pocker creadas por Autentia. Para descargar la baraja, simplemente ingresa en http://www.autentia.com y allí verás en la columna izquierda, el link directo para la descarga.

POO y MVC en PHP

2011-07-15T22:32:00.021-03:00

Título del libro: POO y MVC en PHP (primera edición no revisada)
Autor: Eugenia Bahit

Descripción: El paradigma de la programación orientada a objetos con PHP y el patrón arquitectónico MVC. Conceptos teóricos, códigos de ejemplo, ejercios, y más.

Licencia: Creative Commons BY-NC-ND (libre)
Páginas: 66 páginas
Formato: PDF
Fecha de publicación: 15.07.2011

Foro de Consultas sobre el libro >>
Realizar consultas sobre los archivos del ejemplo del libro o sobre conceptos teóricos (gentileza de VitaminaWeb.com)

Descargar los archivos del ejemplo del libro >>
Descargar todos los archivos PHP y HTML utilizados en el libro.
(incluye SQL para crear la tabla de la base de datos)

Descargar libro gratis o leer libro online:

safeCreative (descargar):
https://www.safecreative.org/work/1107229727073

Dropbox (descargar):
http://dl.dropbox.com/u/10247930/eugenia_bahit--poo_y_mvc_en_php.pdf

Bubok (descargar):
http://www.bubok.es/libros/205199/POO-y-MVC-en-PHP

Lulu (descargar):
http://www.lulu.com/product/ebook/poo-y-mvc-en-php/16314858

Scribd (leer online / descargar):
http://es.scribd.com/doc/60177735/POO-y-MVC-en-PHP

SlideShare (leer online / descargar):
http://www.slideshare.net/eugeniabahit/poo-y-mvc-en-php-por-euge...

Google Docs (leer online / descargar):
https://docs.google.com/viewer?a=v&pid=explorer...

LibroVirtual (leer online / descargar):
http://www.librovirtual.org/lectura.php?obra=N1311356485

WoBook (leer online / descargar):
http://www.wobook.com/infos/...POO-y-MVC-en-PHP.html

PHP: require() o include() ¿cuál uso?

2011-07-14T08:02:00.004-03:00

Si bien las funciones require() e include() de PHP realizan una acción similar (importar un archivo), no son iguales.

include() intenta importar al archivo indicado y en caso de no poder hacerlo, arroja un error y continúa ejecutando el resto del script.

Sin embargo, la función require(), cuando no logra importar el archivo indicado, arroja un error y finaliza sin permitir que el resto del script continúe ejecutándose.

Supongamos que require e include no existiesen y que solo existiese la función importar_archivo(). Y que esta función solo se encargara de importar un archivo y si lo encontrara lo retornaría y si no pudiese importarlo, simplemente no retornaría nada.

Para completar dicha función y, "pensar" como lo harían include y require, el algoritmo sería similar a este:

si pensáramos como include:

if (importar_archivo() == false) {
    print 'arrojo un error';
}

si pensáramos como require:

if (importar_archivo() == false) {
    print 'arrojo un error y finalizo';
    exit();
}

Fíjate que gran diferencia, habremos hecho llamando a exit().

Para saber cual de las dos funciones utilizar, simplemente tiene que plantearte el grado de importancia que tiene el archivo que deseas importar.

Si la ejecución que sigue, depende sí y solo sí de ese archivo, entonces, utilizarás require().

Pero en cambio, si el resto del script no depende únicamente de ese archivo y el hecho de no lograr importarlo, no afecta de forma directa el resto del script, podrás utilizar include().

Kanban y Scrum, obteniendo lo mejor de ambos (en español)

2011-07-14T04:42:00.010-03:00

De la mano de Henrik Kniberg (el autor de Scrum y XP desde las Trincheras) y Mattias Skarin y traducido al español por el equipo de Agile-Spain.com, llega Kanban y Scrum, obteniendo lo mejor de ambos.

Adoro a "Henrik", pero este libro me resultó algo denso. En realidad, no se si denso, pero tardé varios días en terminar de leer sus 123 pages (y no debería decirlo, pero algunos capítulos como que los pasé un poco de largo :D).

Así y todo, no puedo negar que es sumamente interesante. Otro libro más, distribuido con Licencia Creative Commons, que en este caso, puede descargarse desde proyectalis en la URL http://www.proyectalis.com/2010/01/28/scrum-vs-kanban-en-castellano/

Scrum y XP desde las Trincheras (en español)

2011-07-14T04:17:00.002-03:00

Scrum y XP desde las Trincheras (de Henrik Kniberg), traducido al español de la mano de Ángel Medinilla, es uno de mis favoritos. ¡No! ¿Cómo me atrevo? No es uno de mis favoritos... ¡Es mi favorito!
Este "muchacho" Henrik (si, parece que ya lo considero amigo), es algo así como "simpático" para escribir, a la vez de ser muy claro.

Si ya tienes conocimientos de Scrum (al menos una base), este libro, en 122 páginas, te servirá para conocer en detalle todos los artefactos de Scrum, cómo implementarlos y lo más importante, cómo combinar Scrum con las prácticas técnicas de Extreme Programming (XP).

InfoQ nos ofrece la descarga gratuita de Scrum y XP desde las Trincheras (en español) desde su sitio Web http://www.infoq.com/minibooks/scrum-xp-from-the-trenches

The Scrum Primer (en español)

2011-07-14T04:02:00.004-03:00

The Scrum Primer de los autores Pete Deemer, Gabrielle Benefield, Craig Larman y Bas Vodde, es uno de los mejores libros para introducirse en Scrum. Con solo 20 páginas y traducido al español por Leo Antoli, es sin lugar a dudas, la mejor forma de comenzar a entender el enfoque ágil de gestión de proyectos más utilizado por las empresas de desarrollo de Software.

The Scrum Primer se distribuyye con una licencia Creative Commons BY-NC-ND, motivo por el cual, podrás descargarlo gratuitamente desde el sitio Web de Scrum Foundation en la URL http://scrumfoundation.com/library

Manual de PHPUnit en español - Capítulo 4: Testeando errores PHP

2011-07-09T11:51:00.001-03:00

Por defecto, PHPUnit convierte los errores, advertencias y avisos de PHP que son desencadenados durante la ejecución de un test para una excepción.
Usando estas excepciones, puede, por ejemplo, esperar un test para desencadenar un error PHP como se muestra en el siguiente ejemplo.

Ejemplo 4.8: Esperando un error PHP usando @expectedException

class ExpectedErrorTest extends PHPUnit_Framework_TestCase
{
    /**
     * @expectedException PHPUnit_Framework_Error
     */
    public function testFailingInclude()
    {
        include 'not_existing_file.php';
    }
}

phpunit ExpectedErrorTest
PHPUnit 3.4.14 by Sebastian Bergmann.

.

Time: 0 seconds

OK (1 test, 1 assertion)

PHPUnit_Framework_Error_Notice y PHPUnit_Framework_Error_Warning representan avisos y advertencias de PHP, respectivamente.

Nota
Usted debería ser tan específico como sea posible cuando testea excepciones. El testeo para la clase Exception, por ejemplo, es muy general en la mayoría de los casos y puede tener efectos secundarios indeseables.

Manual de PHPUnit en español - Capítulo 4: Testeando Excepciones

2011-07-09T11:36:00.001-03:00

Muestra como usar la anotación @expectedException para probar si se produce una excepción en el código del test.

Ejemplo 4.5: Usando @expectedException

require_once 'PHPUnit/Framework.php';

class ExceptionTest extends PHPUnit_Framework_TestCase
{
    /**
     * @expectedException InvalidArgumentException
     */
    public function testException()
    {
    }
}

require_once 'PHPUnit/Framework.php';

class ExceptionTest extends PHPUnit_Framework_TestCase
{
    public function testException()
    {
        $this->setExpectedException('InvalidArgumentException');
    }
}

phpunit ExceptionTest
PHPUnit 3.4.14 by Sebastian Bergmann.

F

Time: 0 seconds

There was 1 failure:

1) testException(ExceptionTest)
Expected exception InvalidArgumentException

FAILURES!
Tests: 1, Assertions: 1, Failures: 1

Métodos provistos para el testing de excepciones

void setExpectedException(string $exceptionName)
Establece el nombre de la excepción esperada en $exceptionName.

String getExpectedException()
retorna el nombre de la excepción esperada.

Puede utilizar también el enfoque mostrado en el siguiente ejemplo para el testing de excepciones:

Ejemplo 4.7: Enfoque alternativo para el testing de excepciones

require_once 'PHPUnit/Framework.php';

class ExceptionTest extends PHPUnit_Framework_TestCase {
    public function testException() {
        try {
            // ... Code that is expected to raise an exception ...
        }

        catch (InvalidArgumentException $expected) {
            return;
        }

        $this->fail('An expected exception has not been raised.');
    }
}

En el ejemplo anterior, si el código que se espera arroje una excepción, no arroja la excepción esperada, la subsiguiente llamada a fail() detendrá el test e indicará un problema con la prueba. Si la excepción esperada es arrojada, el bloque de captura (catch) será ejecutado y el test finalizará satisfactoriamente.

Manual de PHPUnit en español - Capítulo 4: Proveedores de datos (data providers)

2011-07-09T11:32:00.001-03:00

Un método de prueba puede aceptar argumentos arbitrariamente. Estos argumentos serán provistos por un método proveedor de datos.

Un método proveedor de datos debe ser público y también retornar un array de arrays o un objeto que implemente la interfaz repetitiva y el rendimiento de un array para cada paso repetitivo. Para cada array que sea parte de la colección del test será llamado con el contenido del array como su argumento.

Ejemplo 4.4: Usando proveedores de Datos

class DataTest extends PHPUnit_Framework_TestCase
{
    /**
     * @dataProvider provider
     */
    public function testAdd($a, $b, $c)
    {
        $this->assertEquals($c, $a + $b);
    }

    public function provider()
    {
        return array(
          array(0, 0, 0),
          array(0, 1, 1),
          array(1, 0, 1),
          array(1, 1, 3)
        );
    }
}

phpunit DataTest
PHPUnit 3.4.14 by Sebastian Bergmann.

...F

Time: 0 seconds

There was 1 failure:

1) testAdd(DataTest) with data (1, 1, 3)
Failed asserting that matches expected value .
/home/sb/DataTest.php:21

FAILURES!
Tests: 4, Assertions: 4, Failures: 1.

Nota 1
Cuando un test recibe una entrada desde un método proveedor de datos y a la vez desde uno o más tests sus dependencias sobre los argumentos desde el proveedor de datos vendrán antes de una de los test de los cuales depende.

Nota 2
Cuando un test depende de otro que utiliza proveedores de datos, el test dependiente será ejecutado cuando el test del cual depende tenga éxito para al menos un set de datos. El resultado de un test que utiliza proveedores de datos no puede ser inyectado en un test dependiente.

Manual de PHPUnit en español - Capítulo 4: Dependencias

2011-07-09T11:10:00.016-03:00

Los Tests Unitarios son principalmente escritos como una buena práctica para ayudar a los desarrolladores a identificar y localizar errores (bugs), refactorizar código y servir como documentación para una unidad de software bajo test. Para obtener estos beneficios, los tests unitarioss deben abarcar todas las rutas posibles en un programa. Un test unitario usualmente abarcan una ruta específica en una función o método. De todos modos, un método de prueba no necesariamente es una entidad encapsulada independientemente (?) Con frecuencia, hay dependencias implícitas entre métodos de prueba ocultos en la implementación del escenario de un test. (Adrian Kuhn et. al.)

PHPUnit soporta la declaración de dependencias explícitas entre los métodos de prueba. Tales dependencias no definen el order en el cual los métodos de prueba serán ejecutados pero permiten el retorno de una instancia del test fijo de un productor pasándolo a los consumidores dependientes.

Un productor es un método de prueba que devuelve un valor de retorno.
Un consumidor es un método de prueba dependiente de uno o más productores y de sus valores retornados.

Ejemplo 4.2: Uso de la notación @depends para expresar una dependencia

class Stack extends PHPUnit_Framework_TestCase
{
    public function testEmpty()
    {
        $stack = array();
        $this->assertTrue(empty($stack));

        return $stack;
    }

    /**
     * @depends testEmpty
     */
    public function testPush(array $stack)
    {
        array_push($stack, 'foo');
        $this->assertEquals('foo', $stack[count($stack)-1]);
        $this->assertFalse(empty($stack));

        return $stack;
    }

    /**
     * @depends testPush
     */
    public function testPop(array $stack)
    {
        $this->assertEquals('foo', array_pop($stack));
        $this->assertTrue(empty($stack));
    }
}

En el ejemplo de arriba, el primer test, testEmpty(), crea un nuevo array y afirma que éste está vacío. El test, entonces, retorna el fixture como su resultado. El segundo test, testPush(), depende de testEmpty() y el resultado del que depende, le es pasado como argumento. Finalmente, testPop() depende de testPush().

Para localizar rápidamente los defectos, queremos que nuestra atención sea focalizada sobre las pruebas fallidas en cuestión. Esto es porque PHPUnit saltea la ejecución de un test cuando un test dependiente falla. Esto mejora la localización de defectos por explotar las dependencias entre los test como se muestra en el siguiente ejemplo.

Ejemplo 4.3: Explotando las dependencias entre tests

class DependencyFailureTest extends PHPUnit_Framework_TestCase
{
    public function testOne()
    {
        $this->assertTrue(FALSE);
    }

    /**
     * @depends testOne
     */
    public function testTwo()
    {
    }
}

phpunit --verbose DependencyFailureTest
PHPUnit 3.4.14 by Sebastian Bergmann.

DependencyFailureTest
FS

Time: 0 seconds

There was 1 failure:

1) testOne(DependencyFailureTest)
Failed asserting that is true.
/home/sb/DependencyFailureTest.php:6

There was 1 skipped test:

1) testTwo(DependencyFailureTest)
This test depends on "DependencyFailureTest::testOne" to pass.

FAILURES!
Tests: 2, Assertions: 1, Failures: 1, Skipped: 1.

Un test puede tener más de una dependencia. PHPUnit no cambia el orden en el cual los test son ejecutados. Debe asegurarse que las dependencias de un test puedan realmente ser reunidas antes de que el test corra.

Manual de PHPUnit en español - Capítulo 4: Escribiendo Test en PHPUnit

2011-07-09T11:04:00.001-03:00

Quienes me conocen, saben que si hay algo que no me gusta de este mundo, es el idioma inglés; que no me llevo bien con este idioma, es sabido; y que me molesta enormemente que me hablen en inglés, tampoco es novedad. Pero, de igual manera no es un secreto, que me gusta traducir libros y manuales de informática, desde aquel idioma que poco y nada domino (y poca voluntad tengo para hacerlo) al español, que no solo representa mi "lengua natal" sino que además, me apasiona (pensando en voz alta... ¿y las faltas de ortografía, qué? jo! bueno, se me escapan a veces, che!).

Y cual vendedor ambulante ofreciendo peines en el Ferrocarril Gral. Roca - ramal Bosques -, en esta "oportúnity" les hago llegar una "óferty" ideal para la cartera de la "Lady" y el bolsillo del "Gentelman": la traducción al español del manual de PHPUnit, el framework para realizar Test Unitarios en PHP.

Hago un meritorio agradecimiento (hablando en serio) a la infinidad de profesoras de inglés que en mi infancia se han esforzado por enseñarme, al menos algo, de este idioma. A mis profesoras de la Cultural Inglesa de Buenos Aires (1986-1987); a la profesora Elena (1990), de mi ¿apreciado? barrio Gerli, de quien no recuerdo su apellido; a la profesora de inglés de sexto grado del Colegio Esteban Echeverría de Capital Federal y a mis 5 profesoras de inglés del colegio Joaquín V. González de Barracas. Evidentemente, han hecho todas un excelente trabajo, pues no se como, 20 años después, algo en mi memoria ha quedado. También, debo agradecer a Google Translate por servirme de diccionario electrónico :D

Ahora sí, con ustedes (y de a capítulos porque no lo terminé aún), la traducción al español del manual de PHPUnit (comienza en el capítulo 4).

Manual oficial de PHPUnit (en inglés): http://www.phpunit.de/manual/current/en/

Capítulo 4: Escribiendo Test en PHPUnit

En el siguiente ejemplo, mostramos como escribir tests usando PHPUnit para ejercitar operaciones de arrays en PHP. El ejemplo introduce las convenciones y pasos básicos para escribir tests con PHPUnit:

Nombre de la clase: El test para una clase Class debe ir dentro de una clase ClassTest
Herencia: ClassTest hereda (la mayor parte del tiempo) de PHPUnit_Framework_TestCase
Métodos: Los tests son métodos públicos que son nombrados con el prefijo test. Alternativamente, puede usar la anotación @test en un docblock del método para marcarlo como un método test.
Assertion methods: Dentro de los métodos de tests, los métodos de acierto (assertion methods) como assertEquals() son utilizados para afirmar que un valor real coincide con un valor esperado.

Ejemplo 4.1: Testeando operaciones de arrays con PHPUnit

require_once 'PHPUnit/Framework.php';

class Stack extends PHPUnit_Framework_TestCase
{
    public function testPushAndPop()
    {
        $stack = array();
        $this->assertEquals(0, count($stack));

        array_push($stack, 'foo');
        $this->assertEquals('foo', $stack[count($stack)-1]);
        $this->assertEquals(1, count($stack));

        $this->assertEquals('foo', array_pop($stack));
        $this->assertEquals(0, count($stack));
    }
}

Cada vez que esté tentado de escribir algo dentro de una declaración print o una expresión de debug, en su lugar, escribirlo como un test. (Martin Fowler)

Emprendimientos en la Web 2.0: Dropbox: Almacenamiento en la nube

2011-07-08T03:32:00.002-03:00

Emprendimientos en la Web 2.0: Dropbox: Almacenamiento en la nube: " ¿A quien no le paso tener que imprimir algún archivo y darse cuenta que quedo en la PC del trabajo o viceversa? ¿Quien no perdió horas bus..."

Python: Guía rápida de referencias (métodos del objeto diccionario)

2011-06-13T20:24:00.001-03:00

Métodos del Objeto Diccionario

Sintaxis general

diccionario.metodo()

Métodos más usuales:

-----------------------------------------------------------------------------------------------
keys()         Retorna una lista con todas las claves del diccionario
-----------------------------------------------------------------------------------------------
values()    Retorna una lista con todos los valores del diccionario
-----------------------------------------------------------------------------------------------
items()        Retorna una lista que contiene en cada nodo una tupla con la clave y el valor.

            diccionario = {'madera:':'cedro', 'ancho':175, 'alto':250}
            lista = diccionario.items()
            print lista #Salida: [('madera', 'cedro'), ('ancho', 175), ('alto', 250)]
-----------------------------------------------------------------------------------------------
pop('clave', ['mensaje_de_error_clave_no_encontrada'])
        Borrar el para clave-valor que coincida con el parámetro pasado.
        En caso de no encontrarlo, en vez de un error puede proveernos de un mensaje de
        error personalizado.
-----------------------------------------------------------------------------------------------
has_key(clave)    Retorna true si el diccionario contiene la clave pasada como parámetro.
-----------------------------------------------------------------------------------------------
clear()        Elimina todos los elementos del diccionario.
-----------------------------------------------------------------------------------------------
copy()        Copia el diccionario en memoria.
-----------------------------------------------------------------------------------------------
popitem()    Retorna y borra un elemento del diccionario al azar.
-----------------------------------------------------------------------------------------------
update(otro_diccionario)
        Actualiza el diccionario agregando las claves y valores de otro_diccionario en
        el diccionario actual.
-----------------------------------------------------------------------------------------------

Python: Guía rápida de referencias (métodos del objeto list)

2011-06-13T20:23:00.001-03:00

Métodos del Objeto List

Sintaxis general

lista.metodo()

Métodos más usuales:

-----------------------------------------------------------------------------------------------
append(element) Agrega un elemento a la lista.
-----------------------------------------------------------------------------------------------
extend(elementos)
        Agrega más de un elemento a la lista.
-----------------------------------------------------------------------------------------------
insert(posicion, elemento)
        Agrega un elemento a la lista en la posición indicada.
-----------------------------------------------------------------------------------------------
pop([posicion])    Retorna y borra el elemento correspondiente a la posición indicada.
        Si no se le indica una posición, retorna y borra el último elemento de la lista.
-----------------------------------------------------------------------------------------------
remove(element) Borra el primer elemento de la lista que coincida con el parámetro pasado.
-----------------------------------------------------------------------------------------------
count(elemento)    Cuenta la cantidad de veces que el elemento aparece en la lista.
-----------------------------------------------------------------------------------------------
index(elemento, [inicio], [fin])
        Retorna la primera posición en la que se encuentra el elemento pasado como
        parámetro.
-----------------------------------------------------------------------------------------------
sort()        Ordena la lista de menor a mayor.
-----------------------------------------------------------------------------------------------
reverse()    Invierte el orden de la lista.
-----------------------------------------------------------------------------------------------

Python: Guía rápida de referencias (métodos del objeto string)

2011-06-13T20:21:00.001-03:00

Métodos del Objeto String

Sintaxis general:

string.metodo()

Métodos más comunes:

-----------------------------------------------------------------------------------------------
capitalize()    Retorna otra cadena con el primer caracter en mayúsculas.
-----------------------------------------------------------------------------------------------
upper()        Convierte toda la cadena a mayúsculas.
-----------------------------------------------------------------------------------------------
lower()        Convierte toda la cadena a minúsculas.
-----------------------------------------------------------------------------------------------
isupper()    Retorna true si todos los caracteres están en mayúsculas.
-----------------------------------------------------------------------------------------------
islower()    Retorna true si todos los caracteres están en minúsculas.
-----------------------------------------------------------------------------------------------
isdigit()    Retorna true si todos los caracteres de la cadena son dígitos.
-----------------------------------------------------------------------------------------------
isalpha()    Retorna true si todos los caracteres de la cadena son alfabéticos.
-----------------------------------------------------------------------------------------------
isspace()    Retorna true si todos los caracteres de la cadena son espacios en blanco.
-----------------------------------------------------------------------------------------------
isalnum()    Retorna true si los caracteres de la cadena son alfanuméricos.
-----------------------------------------------------------------------------------------------
find('cadena_buscada', [inicio], [fin])
        Busca cadena_buscada en la cadena y retorna su posición.
        Opcionalmente se puede indicar una posición de inicio y fin para efectuar
        la búsqueda. Si no la encuentra retorna -1.
-----------------------------------------------------------------------------------------------
rfind('cadena_buscada', [inicio], [fin])
        Igual a find() pero comienza la búsqueda de atrás hacia adelante.
-----------------------------------------------------------------------------------------------
count('cadena_buscada', [inicio], [fin])
        Retorna la cantidad de veces que cadena_buscada se repite en la cadena
        desde inicio hasta fin aunque estos dos parámetros son opcionales.
-----------------------------------------------------------------------------------------------
replace('busqueda', 'reemplazo', [maximo_numero_de_reemplazos])
        Retorna una cadena habiendo reemplazado busqueda por reemplazo.
-----------------------------------------------------------------------------------------------
split('caracter_divisor', [maximo])
        Retorna una lista dividiéndola en trozos a partir de cada ocurrencia
        del caracter_divisor.
-----------------------------------------------------------------------------------------------
rsplit('caracter_divisor', [maximo])
        Igual que split() pero comienza de atrás hacia adelante.
-----------------------------------------------------------------------------------------------
splitlines()    Retorna una lista dividiendo la cadena con cada salto de línea.
-----------------------------------------------------------------------------------------------
swapcase()    Convierte las mayúsculas a minúsculas y viceversa.
-----------------------------------------------------------------------------------------------
rjust(longitud, 'caracter_de_relleno')
        Rellena una string hacia la izquierda, con el caracter indicado la cantidad
        de veces que sea necesario hasta completar la longitud indicada.
-----------------------------------------------------------------------------------------------
ljust(longitud, 'caracter_de_relleno')
        Similar a rjust() pero completa hacia la derecha.
-----------------------------------------------------------------------------------------------
center(longitud, 'caracter_de_relleno')
        Similar a rjust() y ljust() pero centrando la cadena.
-----------------------------------------------------------------------------------------------

Python: Guía rápida de referencias (excepciones)

2011-06-13T20:18:00.004-03:00

Captura de Excepciones

try:
    #algoritmo

except [(TipoDeExcepcion_1, TipoDeExcepcion_2)]:
    #respuesta

finally:
    #algoritmo
    #se puede prescindir de finally ya que no es obligatorio

Python: Guía rápida de referencias (clases, métodos y objetos 2)

2011-06-13T20:17:00.002-03:00

El Método __str__

• El método especial __str__, al igual que __init__, se ejecuta de forma automática.
• Facilita a la función print, imprimir una string de forma humanamente legible, cuando se le pasa como parámetro un objeto.

class MiClase:

    # Constructor de la clase
    def __init__(self):
        self.nombre = "Juan"
        self.apellido = "Perez"

    def __str__(self):
        persona = "Apellido y nombre: %s, %s" % (self.apellido, self.nombre)
        return persona

mi_objeto = MiClase()
print mi_objeto

La Clase File()

• Crear un Archivo para escritura

archivo = open('nombre_del_archivo.txt', '[w|a]')

• Abrir un Archivo para solo lectura

archivo = open('nombre_del_archivo.txt', 'r')

• Cerrar un Archivo

archivo.close()

• Escribir en un Archivo

archivo.write('contenido')

• Leer un archivo línea por línea

archivo.readline()

• Leer todo el contenido de un archivo

archivo.readlines()

Python: Guía rápida de referencias (clases, métodos y objetos 1)

2011-06-13T20:15:00.001-03:00

Definición de una Clase

class MiClase:

    atributo = ""

    # Constructor de la clase
    def __init__(self):
        self.otro_atributo = "Atributo de la clase"

    def mi_funcion(self, parametro):
        self.atributo = parametro
        self.imprimir_atributo()

    def imprimir_atributo(self):
        print self.atributo, self.otro_atributo

Instanciar un objeto

mi_objeto = MiClase()

Llamada a métodos de un objeto

mi_objeto.mi_funcion('Dato del parámetro')

Extender una clase: herencia

class MiClase(ClasePadre):
#funciones, atributos...

Python: Guía rápida de referencias (funciones propias de uso frecuente)

2011-06-13T20:11:00.002-03:00

range([inicio,] fin[, paso])
• Devuelve una lista de valores enteros
• Comienza con el valor pasado al parámetro [inicio]
• En caso de omitir este parámetro comienza en cero
• Finaliza con el valor indicado en el parámetro 'fin' sin incluirlo.
• En caso de indicar el parámetro [paso] la lista de valores se incrementa según dicho número, sino se incrementa de uno en uno.

print range(0, 10, 2) #Salida: [0, 2, 4, 6, 8]
print range(1, 11) #Salida: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print range(10) #Salida: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

str(variable)
• Convierte a string cualquier tipo de dato pasado en el parámetro

numero = 15.2
tupla = (1, 2, 'Juan Perez')
print str(numero) #Salida: 15.2
print str(tupla) #(1, 2, 'Juan Perez')

type(variable)
• Devuelve el tipo de una variable

numero = 15.2
tupla = (1, 2, 'Juan Perez')
numero_conv = str(numero)
tupla_conv = str(tupla)

print type(numero_conv) # Salida:

if type(tupla_conv) == str:
print "la variable tupla_conv es una string"
else:
print "algo falló!!!! Qué horror!!!"

#Salida: la variable tupla_conv es una string

dir(variable)
• Devuelve la lista de métodos de un objeto o de funciones de un módulo

print dir(range)
#Salida: ['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__getattribute__', '__hash__', '__init__', '__module__', '__name__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__str__']

help(parametro)
• Devuelve la documentación definida en un módulo, método, función, clase, etc.

print help(range)

La salida de lo anterior será:

Help on built-in function range in module __builtin__:

range(...)
range([start,] stop[, step]) -> list of integers

Return a list containing an arithmetic progression of integers.
range(i, j) returns [i, i+1, i+2, ..., j-1]; start (!) defaults to 0.
When step is given, it specifies the increment (or decrement).
For example, range(4) returns [0, 1, 2, 3]. The end point is omitted!
These are exactly the valid indices for a list of 4 elements.

def mi_funcion():

""" Esta es la documentación de mi función,
la cual coloco a modo de ejemplo """

print help(mi_funcion)

La salida de lo anterior será:

Help on function mi_funcion in module __main__:

mi_funcion()
Esta es la documentación de mi función,
la cual coloco a modo de ejemplo

Python: Guía rápida de referencias (módulos en Python)

2011-06-13T20:07:00.001-03:00

Módulos
• Un módulo es un archivo .py el cual puede ejecutarse desde una consola con el comando:

eugenia@cocochito:~$ python mi_modulo.py

• La forma de insertar un módulo dentro de otro, es mediante la palabra clave reservada import nombre_del_modulo

import mi_modulo

• Para llamar a una función del módulo importado, se utiliza la siguiente sintaxis:

nombre_del_modulo_importado.funcion()

Python: Guía rápida de referencias (asignando variables)

2011-06-13T20:05:00.001-03:00

Asignaciones Múltiples de Variables

    var1, var2, var3 = valor1, valor2, valor3
    var1, var2, var3 = (valor1, valor2, valor3)
    nombre, apellido, edad = ('Juan', 'Pérez', 23)

    var1=var2=var3 = valor
    a=b=c = 10

Casos de Uso
Agrupando asignaciones:

personas = [('Juan',23), ('Emilia', 31), ('Raquel', 72)]
 for nombre, edad in personas:
 print "%s tiene %d años. " % (nombre, edad)

La salida de lo anterior será:

    Juan tiene 23 años.
    Emilia tiene 31 años.
    Raquel tiene 72 años.

Asignaciones múltiples mediante funciones:

def calcular_precio(monto):
 bruto = monto
 iva = (monto*21/100)
 neto = bruto+iva
 return (bruto, iva, neto)

 bruto, iva, neto = calcular_precio(100)
 linea_divisoria = "-"*20
 print "Costo: $%d IVA: $%d %s Total: $%d" % (bruto, iva, linea_divisoria, neto)

La salida de lo anterior será:

    Costo: $100
    IVA: $21
    --------------------
    Total: $121

Python: Guía rápida de referencias (formato de texto de salida)

2011-06-13T20:02:00.002-03:00

Concatenar variables dando formato a una String
Dadas las siguientes variables:

    numero_decimal = 25
    numero_flotante = 12.8
    cadena_de_texto = "¡Hola Mundo!"

Podremos unirlas mediante:

concatenacion = "Esta cadena contiene un decimal %d, un flotante %f y una string %s" % (numero_decimal, numero_flotante, cadena_de_texto)

La salida de lo anterior, al imprimirla será:
Esta cadena contiene un número decimal 25, un número flotante 12.8 y una string ¡Hola Mundo!

Algunos formatos posibles:

----------------------------------------------------------------------------
%d      Decimal (Ejemplos: 10, 15, 174, 1289)
----------------------------------------------------------------------------
%f      Flotante (Ejemplos: 12.8, 93.74)
----------------------------------------------------------------------------
%10.1f Formateo de flotantes, donde el primer número indica el largo total
    de caracteres a reservar y el segundo la cantidad de decimales
    (Ejemplo de salida: 93.7)
----------------------------------------------------------------------------
%s      String (Ejemplo: Hola Mundo)
----------------------------------------------------------------------------
%x      Conversión a hexadecimal
    (Ej.: dada la variable var = 255, la salida sería ff)
----------------------------------------------------------------------------
%o      Conversión a octal
    (Ej.: dada la variable var = 255, la salida sería 377)
----------------------------------------------------------------------------
%10s    Reserva un largo de 10 caracteres de derecha a izquierda
%-10s   Reserva un largo de 10 caracteres de izquierda a derecha
----------------------------------------------------------------------------

Python: Guía rápida de referencias (declaración de funciones)

2011-06-13T20:00:00.002-03:00

Definición de Funciones

    def nombre_funcion(param1, param2):
        suma = param1+param2
        return suma

    print nombre_funcion(10, 10) #Salida: 20

    def nombre_funcion(param1, param2, parametro_por_defecto=15):
        suma = param1+param2+parametro_por_defecto
        return suma

    print nombre_funcion(10, 10) #Salida: 35

    def nombre_funcion(param1, param2, *parametros_variables):
        suma = param1+param2
        for parametro in parametros_variables:
            suma += parametro
        return suma

    print nombre_funcion(10, 10, 1, 1, 1) #Salida: 23

Python: Guía rápida de referencias (condicionales, bucles e iteraciones)

2011-06-13T19:57:00.002-03:00

Condicional if

    if condicion:
        ....
    elif condicion:
        ...
    else:
        ...

Bucle while

while n1<=n2:
...

Bucle for in

    tupla = ('Juan Perez', 25, 1.74)
    for elemento in tupla:
        print elemento

Break y Pass

    tupla = ('Juan Perez', 25, 1.74, 12, 7.8, 'Otro Dato')

    for elemento in tupla:
        if elemento != 'Otro Dato':
            print elemento
        else:
            break #corta el bucle

    for elemento in tupla:
        if elemento == 25:
            pass #continúa sin hacer nada
        else:
            print elemento

Python: Guía rápida de referencias (operadores)

2011-06-13T19:55:00.002-03:00

Operadores Matemáticos

    +   suma
    -   resta
    *   multiplicación
    /   división de flotantes
    // división de enteros
    %   resto de una división
    ** exponenciación

Operadores Relacionales

== Igual que
 != Distinto que
 < Menor que
 <= Menor o igual que
 > Mayor que
 >= Mayor o igual que

Operadores Lógicos

    and   (y)
    or    (o)
    not   (no)

    if a==b and (b==c or c==a):
        ...

    if not a==b:
        ...

Python: Guía rápida de referencias (tuplas, listas y diccionarios)

2011-06-13T19:52:00.001-03:00

Tuplas
• Una tupla es una variable que permite almacenar varios datos inmutables (no pueden ser modificados una vez creados) de tipos diferentes:

mi_tupla = ('cadena de texto', 15, 2.8, 'otro dato', 25)

• Se puede acceder a cada uno de los datos mediante su índice correspondiente:

print mi_tupla[1] # Salida: 15

• También se puede acceder a una porción de la tupla, indicando (opcionalmente) desde el índice de inicio hasta el índice de fin:

    print mi_tupla[1:4] # Devuelve: (15, 2.8, 'otro dato')
    print mi_tupla[3:] # Devuelve: ('otro dato', 25)
    print mi_tupla[:2] # Devuelve: ('cadena de texto', 15)

• Otra forma de acceder a la tupla de forma inversa (de atrás hacia adelante), es colocando un índice negativo:

print mi_tupla[-1] # Salida: 25
print mi_tupla[-2] # Salida: otro dato

• Las tuplas son inmutables: no permiten modificar los datos una vez creados ni agregar datos nuevos:

mi_tupla[2] = 3.8 # da un error

• Con la función len(mi_tupla) podremos conocer la cantidad de datos almacenados en la tupla:

print len(mi_tupla) # Salida: 5

Listas
• Una lista es similar a una tupla con la diferencia fundamental de que permite modificar los datos una vez creados

mi_lista = ['cadena de texto', 15, 2.8, 'otro dato', 25]

• Las lista NO son inmutables: permiten modificar los datos una vez creados:

mi_lista[2] = 3.8 # permite modificar el dato

• A las listas se accede igual que a las tuplas:

    print mi_lista[1] # Salida: 15
    print mi_lista[1:4] # Devuelve: [15, 2.8, 'otro dato']
    print mi_lista[-2] # Salida: otro dato

• Con la función len(mi_lista) podremos conocer la cantidad de datos almacenados en la lista:

print len(mi_lista) # Salida: 5

• Las listas, a diferencia de las tuplas, permiten agregar nuevos valores:

mi_lista.append('Nuevo Dato')

Diccionarios
• Mientras que a las listas y tuplas se accede solo y únicamente por un número de índice, los diccionarios permiten utilizar una clave para declarar y acceder a un valor:

mi_diccionario = {'clave_1':valor_1, 'clave_2':valor_2, 'clave_7':valor_7}
print mi_diccionario['clave_2'] # Salida: valor_2

• Un diccionario permite eliminar cualquier entrada:

del(mi_diccionario['clave_2'])
# elimina clave_2 del diccionario produciendo como resultado: mi_diccionario = {'clave_1':valor_1, 'clave_7':valor_7}

• Al igual que las listas, el diccionario permite modificar los valores

mi_diccionario['clave_1'] = 'Nuevo Valor'

• Con la función len(mi_diccionario) podremos conocer la cantidad de pares (clave:valor) almacenados en el diccionario:

print len(mi_diccionario) # Salida: 2

Python: Guía rápida de referencias (lo básico)

2011-06-13T19:46:00.002-03:00

Imprimir en Pantalla

print "¡Hola Mundo!"

Comentarios

# Esto es un comentario de una línea

""" Esto es un comentario
    de varias líneas """

Definición de Variables

# Enteros: 
edad = 32

# Flotantes: 
precio = 144.75

# Booleano: 
habilitado = false

# Strings: 
    pais1 = "Reino Unido"
    pais2 = 'República Argentina'
    strings_concatenadas = pais1+pais2
    string_repetida = "Esto se imprime 3 veces. "*3

Aviso Legal - Contenido Libre

2011-06-01T06:00:00.001-03:00

Sobre el material bibliográfico, literario, artículos y notas publicadas

El contenido es LIBRE. Todo el material literario (excluyendo libros y artículos escritos por terceras personas) es de libre copia, publicación y distribución y se encuentra publicado bajo licencia Creative Commons BY-NC-ND. Más acerca de sus derechos >>

Sobre las librerías, software y otros códigos fuente

Todo el código fuente publicado en este blog, así como librerías, scripts, snippets, software, aplicaciones, etc. es Software Libre. Usted es libre de utilizar dichos códigos fuente para sus aplicaciones, copiarlo, publicarlo, distribuirlo, mejorarlo, etc. ya que se encuentra publicado bajo licencia pública GNU LGPL v3. Queda exento el código fuente publicado por terceras personas o aquel que simplemente no es de mi autoría, excepto que el autor, especifique lo contrario. Más acerca de sus derechos >>

Sobre la garantía de sus derechos

Sus derechos de libre copia, publicación y distribución, así como el de acceder GRATUITAMENTE al material publicado, se encuentran amparados por el registro del material bajo las licencias mencionadas en safeCreative. Más acerca de estas garantías >>.

Discurso de Steve Jobs en la Universidad de Stanford (2005)

2011-01-31T16:05:00.000-03:00

[...]Today I want to tell you three stories from my life. That's it. No big deal. Just three stories[...]

Texto completo [+]

Programación LAMP con Scrum y XP

El síndrome de lo malo conocido

Test-First Programming en Bash y Shell Scripting

Software Libre - No te quedes con la duda

Entendiendo de qué hablamos cuando hablamos de Software Libre

Aprende a prescindir del entorno gráfico en Linux

Database Integration Testing With Enhance PHP

Curso gratis de Python

8. Write controllers for your models

How event handler works?

What do you need in order to write controllers?

Step #1: write the general controller

Step #2: write your own controllers

Complete example

[off-topic] Phixr - Editor online de fotos

7. Test-first your model methods with Enhance PHP

Write TDD with Enhance PHP on Europio

6. Making a standard model (Europio User Guide)

Model structure

Europio Data Types

Data type sintax

The $null parameter

A Model example

The model file names

5. Making the first module (Europio User Guide)

The module folder

The module sub-folders

File initialize module

2. Install Europio + Enhance PHP on Linux (Europio User Guide)

First step

Second step

Third step

Final step

4. Configure the settings.php file (Europio User Guide)

Configure the database constants

Set the app folder

Installed modules

Set the app resources

1. About Europio (Europio User Guide)

What is Europio?

Features summary

About Europio and Enhance PHP Projects

3. Folders Structure (Europio User Guide)

One folder for your app

One folder for each app module into the app folder

Inside each of the modules must be the following four folders: models, views, controllers and test

The Europio core folder must be into the app folder

Files inside the app folder

One __init__.php module file inside each module

Europio + Enhance PHP

Se suma EnhancePHP, Framework para Unit Testing a la versión 2.0.18 de Europio

Download the latest stable version, now!

Documentación (inglés / español)

Enhance PHP: Acerca de los Test Unitarios (traducción al español)

Enhance PHP: Guía de Inicio Rápido

Instalación

Tu primer test

Presentación de Enhance PHP - Framework para test unitarios en PHP

Europio v1.0 Final - Núcleo para Arquitecturas MVC Modulares en PHP 5 Orientado a Objetos

Presentación de Europio

MissArchitect: Manejador de eventos para arquitecturas MVC y Despachador de URLs Amigables

MissArchitect ORM: Herramienta de mapeo relacional de datos

DBAbstractModel: Manejador de conexiones y consultas a MySQL

PHPAggregate: Funciones agregadas para la validación de datos

PHPValidator: Ayudante para PHPAggregate

PHPTemplate: Métodos de renderización de diccionarios dinámicos

EnhancePHP: Framework para Unit Testing

MissArchitect - core para arquitecturas MVC en PHP

Artículos escritos para otros sitios

Debian Hackers

Programación en Python

Manual de Metodologías Ágiles para el Desarrollo de Software

Artículos sobre programación en PHP

Opinión

Diseño Ágil con TDD (por Carlos Blé Jurado)

PHPFormValidator: Clase para validación automática de cualquier tipo de formulario

PHPTemplate - Clase PHP para manejar la lógica de las vistas en MVC

DBAbstractModel - Clase PHP 5 para insertar, eliminar, actualizar y seleccionar datos de una DB MySQL

PHPAggregate - Librería GPL de funciones agregadas de validación de datos para PHP

Scrum: Cartas para Planning Pocker

One init.php module file inside each module