TestDisk - Herramienta de recuperación de datos

TestDisk es una herramienta de recuperación de datos Open Source bajo licencia GPL. Con esta herramienta podemos arreglar nuestro disco duro y volver a recuperar la información con facilidad. Con éste software podemos:

• Arreglar la Tabla de Particiones, recuperar particiones eliminadas
• Recuperar sectores de booteo FAT32 de su copia de respaldo
• Reconstruir sectores de booteo FAT12/FAT16/FAT32
• Arreglar tablas de booteo de tipo FAT
• Reconstruir sectores de booteo NTFS
• Recuperar sectores de booteo NTFS de su copia de respaldo
• Arreglas la MFT usando la MFT mirror
• Localizar el Superblock de copia de respaldo de ext2/ext3

Desde la página de descargas podemos obtener la última versión y para el SO que queramos.

Si queremos recuperar información de vídeo, imágenes o ficheros de nuestros discos duros o CD's, podemos utilizar la herramienta PhotoRec. Ésta la podemos descargar del mismo enlace que la aplicación TestDisk que además és Open Source bajo licencia GPL.

Otra de las aplicaciones interesantes que podemos encontrar de la casa de CGSecurity es CmosPwd, una pequeña utilidad que desencripta password almacenados en la cmos utilizada para el acceso al SETUP de la BIOS, interesante, no?. Podemos descargar la última versión de la aplicación directamente en este link -> CmosPwd.

Herramientas de Geo Localización

En esta nueva entrada, os muestro un par de webs interesantes desde dónde podremos localizar diferentes puntos en el mundo a través de su Geo localización (Latitud, Longitud) (40°41′21″N 74°2′40″O). En este caso por ejemplo vamos a intentar descubrir que hay en la posición que he indicado anteriormente. Podemos utilizar un Atlas y buscarlo a mano, o podemos utilizar las diferentes herramientas que nos ofrece la red para poder obtener nuestra posición. Simplemente hay que tener en cuenta las diferentes expresiones regulares que componen una localización, y utilizarlas correctamente en las diferentes herramientas.

• GeoLocator:

Con esta aplicación web, podemos encontrar con unos breves pasos nuestra geo localización:

Como podemos ver, ya aparece lo que estamos buscando. En realidad es la Estatua de la libertad. Incluso aparece dibujado en el mapa, una gozada verdad?. hay que tener en cuenta que hay que formatear la posición en su formato, en este caso el siguiente: 40 41 21 N, 74 2 40 W.
Si nos fijamos en la imagen, en la posición derecha, podemos ver que nos entrega la latitud y longitud en grados decimales : 40.689167°, -74.044444°, esto nos servirá para otras páginas como MundiVideo.

• MundiVideo - GeoLocalizador:

Desde esta página, entrando las coordenadas también nos entrega su posición en el mapa.

• GeoHack:

Esta web también te permite ver la ubicación en función de las coordenadas.

Hay muchas más web's por la red. Si alguien sabe alguna más que me deje un comentario. Espero que os sirva de ayuda. Otro día publicaré las diferentes API's que hay para nuestras aplicaciones y poder disfrutar de la GeoLocalización desde éstas.

Penjili Project

Penjili es un proyecto desarrollado por la EADS (European Aeronautic Defence and Space Company) y es una herramienta de análisis de software embebido. Ésta prueba la ausencia de vulnerabilidades de seguridad, por ejemplo los límites de una matriz, punteros con referencia null, desbordamientos, etc. Penjili con Newspeak (es un lenguaje de programación simplificado, bien adaptado a los fines de análisis) permite la entrada de ficheros C o ADA y genera una lista de warnings, indicando el origen del problema y el tipo de error. Si no hay ninguna advertencia, el código está libre de vulnerabilidades. Hay varios estudios que identifican este problema, como este por Xavier Allamigeon, Wenceslas Godad y Charles Hymans, donde hacen un análisis de la manipulación de Strings en Programas críticos embebidos escritos en C. En éste artículo se hace referencia al problema del uso de cadenas, ya que siempre tenemos que comprobar que la cadena de destino sea lo suficientemente larga como para poder albergar nuestra cadena original. Cuando no es el caso, y la cadena de destino es más larga, esta se llena con bytes aleatorios que pueden llegar a crear inesperadas posiciones de memoria.
En la página oficial del Proyecto Penjili, podemos encontrar una buena presentación explicando los contenidos más importantes de ésta, explicando las mejoras que conseguiremos en nuestra aplicación aplicando los parámetros de Penjili. Las características más importantes del proyecto son las siguientes:

Lograr una gran escalabilidad:
- más de 1 millón de líneas de código

Mantiene una gran precisión:
- más de 99% para las matrices y más del 95% para los punteros

Ha sido capaz de encontrar anomalías en Software verdadero y maduro.

Un ejemplo de conversión, utilizando el NewSpeak, es el siguiente:

Podemos encontrar toda la tabla de referencia en la misma web, y además podemos descargar todo el proyecto entero ya que está bajo una licencia LGPL. Desde este mismo enlace, podemos descargar la última versión de la aplicación NewSpeak 1.6, para que la podáis disfrutar y probar con vuestros proyectos generados en C o ADA. El proyecto llamado CtoNewSpeak, también lo podemos encontrar en SourceForge.

Aquí os dejo una imagen, que también la encontrareis en la web y que explica un poco la jerarquía del proyecto.

Gracias a JM_@Inject por hablarme de esta tecnología:

Penjili(뺀질이): in Korean, said of a person who is cunning at avoiding unnecessary work.

Syntax Highlighter para Delphi

Con la aportación de ayer sobre mi primera aplicación con Lazarus, descubrí los SynEdit, que son Syntax Highlighter para Delphi. Pues bien, mi misión ha sido probarlos en Delphi, y funcionan perfectamente. Dispone de más de 30 controles para colorear (desde Java, PHP, SQL hasta Haskell, ASM, etc), y dispone de muchas utilizades muy interesantes como grabador de macros, autocompletadores, etc. Primero tenemos de descargar el último Package. Podemos descargalo desde aquí: SynEdit-2.0.6. Una vez descargado, lo ponemos en una ruta útil, por ejemplo en:
C:\Archivos de programa\SynEdit-2_0_6\SynEdit

Una vez allí, abrimos el delphi, y abrimos los proyectos:


Compilamos y buildeamos todo e instalamos el package SynEdit_D2006.bpl. Una vez instalado nos aparecerá un mensaje con los siguientes componentes:

Una vez instalados, hay que configurar el acceso a las fuentes desde Delphi. Nos dirigimos a Tools -> Options, y desde Environment Options -> Delphi Options -> Library - Win32, ponemos la ruta siguiente dentro de Library Path y Browsing Path:
C:\Archivos de programa\SynEdit-2_0_6\SynEdit\Source

De esta manera las fuentes seran visibles desde nuestra aplicación, sino cuando insertéis uno de los componentes dará un error de que no encuentra los ficheros .pas. (Esto lo he explicado siempre que instalo un paquete en Delphi).

Una vez hecho todo esto, voilà, ya tenemos todos los componentes en nuestra paleta y podemos crear bonitas aplicaciones utilizando estos editores. Aquí os dejo una muestra de casi todos los componentes:

Aquí os dejo una muestra, creando un formulario para mostrar código SQL, utilizando las opciones de selección de línea y mostrando el número de líneas:

Capturar la salida de una aplicación DOS con Delphi

No os ha interesado alguna vez leer la salida estándar de una aplicación (stdout) para poder visualizar su contenido en nuestra aplicación, o simplemente para tratar el texto que devuelve? Pues bien, con Delphi lo podemos hacer. No es sencillo, pero con las herramientas necesarias si. Por ejemplo, imaginad que queremos ver el valor que devuelve ejecutar la sentencia java -version en nuestra máquina. El resultado es el siguiente:

Pues, como podemos capturar esa salida en nuestra aplicación?.

Utilizando TDosCommand. Dos Command 2.0 es un componente gratuito de Delphi. Lo podemos encontrar en Maxx's Delphi Site, y es libre de descarga. El componente es bastante fácil de instalar y de ejecutar, y mediante 3 líneas de código podemos capturar el stdout en un TMemo. El ejemplo que propongo es el siguiente:

Primero, podemos crear un bpl e instalar el fichero DosCommand.pas como un package. Pero también podemos crear un proyecto nuevo y agregarlo como fuente externa. Funciona de las 2 maneras. En ese caso, creo un nuevo proyecto, con un botón y un TMemo, y luego con el DosCommand agregado en mi proyecto escribo:

unit Unit3;

interface

uses
    Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
    Dialogs, StdCtrls, ShellAPi, DOsCommand, ExtCtrls;

type
    TFTest = class(TForm)
        Memo1: TMemo;
        Button1: TButton;
        procedure Button1Click(Sender: TObject);
        procedure FormCreate(Sender: TObject);
        procedure FormDestroy(Sender: TObject);
    private
        { Private declarations }
    public
        { Public declarations }
    end;

var
    FTest: TFTest;
    dos: TDosCommand;

implementation

{$R *.dfm}

procedure TFTest.Button1Click(Sender: TObject);
begin
    dos.CommandLine := 'java -version';
    dos.Execute;
end;

procedure TFTest.FormCreate(Sender: TObject);
begin
    memo1.Clear;
    dos := TDosCommand.create(self);
    dos.OutputLines := memo1.lines;
end;

procedure TFTest.FormDestroy(Sender: TObject);
begin
    FreeAndNil(dos);
end;

end.

una vez escribo el comando del cual quiero capturar su salida, le doy al botón get et voilà:

Ahora ya tenemos la salida de la aplicación, pero no abusar mucho del componente, ya que utiliza hilos para poder capturar la salida de la aplicación. Si hacemos demasiadas peticiones puede ser que saturemos la pila del sistema (ya lo he intentado, y si!).

Aquí os dejo la aplicación de muestra ThundaxSTDOUT.exe, donde he puesto una textbox para entrar el comando que queráis. Aquí os dejo una muestra de la ejecución de un comando:


En la web de Lazarus, también he encontrado un componente llamado TProcess, que permite capturar la salida de un programa casi de la misma manera, utilizando un TStringList. Pero no acaba de funcionar. Os dejo los enlaces por si queréis indagar en el tema.

JSON (JavaScript Object Notation) en Delphi

JSON (JavaScript Object Notation - Notación de Objetos de JavaScript) es un formato ligero de intercambio de datos. Se basa en un subconjunto del lenguaje de Programación JavaScript. Es un formato de texto que es completamente independiente del lenguaje pero utiliza convenciones que son ampliamente conocidas por los programadores de la familia de lenguajes de C/C++, Java, JavaScript, Perl, Python, etc. De esta manera JSON se convierte en un lenguaje ideal para el intercambio de datos.

JSON está constituido por dos estructuras:

• Una colección de pares de nombre/valor. En varios lenguajes esto es conocido como un objeto, registro, estructura, diccionario, tabla hash, lista de claves o un array asociativo.
• Una lista ordenada de valores. En la mayoría de los lenguajes, esto se implementa como arreglos, vectores, listas o secuencia.

Estas son estructuras universales; virtualmente todos los lenguajes de programación las soportan de una forma u otra. Cada vez hay más soporte de JSON mediante el uso de paquetes escritos por terceras partes. La lista de lenguajes soportados incluye ActionScript, C, C#, ColdFusion, Common Lisp, Delphi, E, Eiffel, Java, JavaScript, ML, Objective CAML, Perl, PHP, Python, Rebol, Ruby, y Lua.

En la web oficial de JSON, json.org, podemos encontrar toda la lista de lenguajes que incorporan JSON. En este caso, yo voy a mostrar un ejemplo de la JSON Delphi Library. En esta librería Open Source, podemos encontrar el desarrollo de JSON y varios proyectos de ejemplo para que podamos ver su configuración y utilización. Además, en la web de json.org, también nos hablan de 2 proyectos más para delphi, JSON Super Objects, y uJson.

Si analizamos el ejemplo, lo veremos un poco más claro:

program sample3;

{$APPTYPE CONSOLE}

uses
  variants,
  SysUtils,
  uLkJSON in 'uLkJSON.pas';

var
  js,xs:TlkJSONobject;
  ws: TlkJSONstring;
  s,s2, s1, s3: String;
begin
  s := '{"\"string1\"":"123","\"string2\"":"5676","\"string3\"":"test",'+
    '"childobject":{"objstr1":"Oone","objstr2":"Otwo","objstr3":"Othree"}}';
  js := TlkJSON.ParseText(s) as TlkJSONobject;

  s1 := vartostr(js.Field['"string1"'].Value);
  writeln(s1);
  s2 := vartostr(js.Field['"string2"'].Value);
  writeln(s2);
  s3 := vartostr(js.Field['"string3"'].Value);
  writeln(s3);

  readln;
  js.Free;
end.

Como podemos ver, la cadena de texto formada por :

s := '{"\"string1\"":"123","\"string2\"":"5676","\"string3"":"test",'+"childobject":"objstr1":"Oone",
"objstr2":"Otwo","objstr3":"Othree"}}';

hace algo parecido a las regular expresions de mi anterior post. Luego el protocolo JSON, parsea el texto en busca de las keywords que tiene definidas, y de esta manera obtiene los registros string1, 2 y 3. La salida por pantalla de programa:

Además, como he indicado antes, al ser ideal para el intercambio de datos, tenemos el protocolo JSON RPC (Llamada de procedimiento remoto con JSON). Hace varios meses, colgué un post sobre XML-RPC que utiliza XML para realizar la llamada de procedimiento remoto. Ahora con json, tendríamos que mirar si el funcionamiento puede mejorar en vez de utilizar el XML.

• Enlaces de interés:

JSON in J2ME.

JSON con PHP.

Expresiones regulares en Delphi

Las expresiones regulares son cadenas de texto que describen un patrón de búsqueda. Podemos pensar en éstas expresiones como una especie de comodines, como los que utilizamos para listar una serie de ficheros en un directorio desde el intérprete de comandos -> dir *.doc (devolverá la lista de todos los ficheros con la extensión .doc). Pues bien, la expresión regular equivalente para *.doc seria .*\.doc$. Pero podemos llegar a hacer muchas más cosas con las expresiones regulares. Ya hay varios editores de texto como EditPad Pro o PowerGrep que llevan integradas las Regular Expression, aunque son de pago :( . En PowerGrep, podemos ver una expresión regular típica para la búsqueda de una dirección de correo electrónico:

Como podemos ver, la expresión regular \ b [A-Z0-9._ %+-]+@[ A-Z0-9 .-] + \. [AZ] {2,4} \ b buscar direcciones de correo electrónico dentro del texto. Luego con un pequeño cambio com éste: \ ^ [A-Z0-9._ %+-]+@[ A-Z0-9 .-] + \. [AZ] {2,4} \ $ nos puede servir para comprobar si la dirección de correo electrónico se ha entrado correctamente en un campo. Mediante esta expresión regular, podemos comprobar si hemos entrado los datos correctamente, y nos sirve para una multitud de lenguajes como java, perl, PHP, .net, etc.

Con Microsoft Excel, también las podemos utilizar, con la Microsoft VBScript Regular Expressions 5.5. Aquí os pongo un pequeño ejemplo de como utilizarlo, aunque hay muchos ejemplos por la red:

Luego, por ejemplo si tenemos un texto en una de las celdas y queremos extraer las direcciones electrónicas, solo tenemos que hacer:


Ahora, creamos la función que irá dentro de uno de los módulos del Excel (Acordaros de activar las macros):

Public Function extraerreg(s As String) As String
     Dim o_RegExp As RegExp
     Dim o_Match As Match
     Dim o_Matches As MatchCollection
     Set o_RegExp = New RegExp
     o_RegExp.IgnoreCase = True
     o_RegExp.Global = True
     o_RegExp.Pattern = "[^,;\s]+@[^,;\s]+"
     Set o_Matches = o_RegExp.Execute(s)
     ' Recorre en la colección
     For Each o_Match In o_Matches
        extraerreg = extraerreg + o_Match.Value + " "
     Next
End Function

Como podemos ver en el ejemplo, se utiliza la expresión regular "[^,;\s]+@[^,;\s]+" para encontrar una cadena de texto que siga este patrón. Aquí os dejo el ejemplo : libro1.xlsm

En este caso Delphi aún no lo tiene integrado en su core (esperemos que algún día lo hagan). Pero si que lo he visto en muchos de los componentes de terceros como DevExpress. Por ejemplo el componente TcxMaskEdit, permite realizar la entrada de valores mediante Regular Expressions:


En delphi, hay una librería llamada TRegExpr, de la mano de Andrey V. Sorokin. Podemos descargarla y probarla desde el siguiente enlace: RegExp Studio. Una vez descargada la librería, podemos ver varias demos de la utilización sobre las regular expressions:

En este caso, si analizamos el código fuente:

procedure TfmTRegExprClassMain.btnExtractEmailsClick(Sender: TObject);
 begin
  lbxEMailesExtracted.Items.CommaText := ExtractEmails (memExtractEmails.Text);
 end;

// This simple function extracts all emails from input string
// and places list of this emails into result string as CSV (comma separated values)
function ExtractEmails (const AInputString : string) : string;
 const
  EmailRE = '[_a-zA-Z\d\-\.]+@[_a-zA-Z\d\-]+(\.[_a-zA-Z\d\-]+)+';
 var
  r : TRegExpr;
 begin
  Result := '';
  r := TRegExpr.Create;
  try // ensure memory clean-up
     r.Expression := EmailRE;
     if r.Exec (AInputString) then
      REPEAT
       Result := Result + r.Match [0] + ',';
      UNTIL not r.ExecNext;
    finally r.Free;
   end;
 end;

Podemos ver como utiliza expresiones regulares para capturar la dirección de correo electrónica. Pues bien, ahora ya podemos extender la librería y empezar a utilizarlas ya que nos ayudan mucho con los patrones de texto.

• Enlaces de interés:

Expresiones regulares con visual basic.
Comprobador de expresiones regulares en javascript. (Ejemplo).
Introducción expresiones regulares.
Expresiones regulares XHTML.
Evaluar expresiones regulares.

Canvas para dibujar graficos en Delphi

Después de varios meses vuelvo a abrir el post de jugando con Tcanvas, donde mostraba como configurar y programar el Tcanvas para crear las aplicaciones gráficas que queramos. Pues bien, he encontrado una aplicación "Simple Graph Demo", desarrollada por Kambiz R. Khojasteh, que permite hacer la parte que yo queria sobre la manipulación de objetos a través del canvas. Podemos encontrar todo el proyecto en SourceForge ya que es Open Source. Una vez descargada la última versión estable (v1.542) -> simplegraph.zip, solo tenemos que descomprimirla y crear un package donde importaremos el código fuente SimpleGraph.pas. Debemos hacer algo parecido a lo que hay en la siguiente imagen:

Creamos un package llamado graph.bpl y luego importamos la fuente SimpleGraph.pas, una vez hecho, hacemos un build y un install para instalar el componente en nuestra paleta. Una vez acabado, abrimos el proyecto demo, lo compilamos y lo iniciamos, y podremos jugar con el componente, utilizando diversos objetos, conectándolos, asignándoles propiedades, aplicando zoom, etc. Osea que hay para ir practicando y mejorar la aplicación.

Herramientas para mostrar el password oculto en una textbox

Muchas veces nos encontramos con campos de texto con los típicos asteriscos y no hay manera de acordarse del password que pusimos en su día. Pues bien, hay muchas herramientas on-line que permiten revelar el password, y que nos pueden salvar en caso de algún apuro. Recordad que el robo de passwords es un crimen, y este post solo pretende dar información sobre varias herramientas que podemos utilizar en el caso de que hayamos rellanado un campo en alguna aplicación o web y que no nos acordemos de éste.

• Asterisk Key

Esta aplicación, para mi una de las mejores (que yo conozca), permite obtener los passwords de aquellas textbox que queramos. La aplicación una vez arrancada escanea el formulario en busca de textbox con los típicos "*******" y te entrega el contenido del password. Asterisk Key es de libre descarga, y podemos encontrar el programa en descarga directa desde el siguiente enlace: Ariskkey.exe.
Aquí os dejo un ejemplo de su utilización. He creado una pequeña aplicación con un TextBox y un password, y luego podemos ver como Asterisk Key te devuelve el texto interno de la TextBox:

• Show PW

Esta aplicación no tan potente como la anterior pero también nos puede servir en determinados momentos y además es muy portable ya que solo necesitamos su ejecutable. Este funciona de otra manera, simplemente tenemos que pasar el puntero del mouse por la celda con los asteriscos y automáticamente si la aplicación puede (debido a la seguridad de la aplicación) te devolverá el texto debajo de los asteriscos. Desde la web de ShowPassword, podemos decargarnos la aplicación showpw.exe. En la web también encontraremos otra aplicación Protected Storage Viewer, es muy interesante, pero es de pago.

• Password Reveal Pro
  

Es utilidad es muy parecido a ShowPassword pero con el inconveniente que es de pago. Puedes descargar una versión Trial, que sirve de igual manera para nuestro cometido. Nos aparece un candado en la parte derecha de la aplicación. Lo seleccionamos y lo arrastramos hasta la textbox, luego nos aparecerá el texto en la aplicación. En la web de Password Reveal, podemos descargar la aplicación. Aquí os dejo un enlace directo para la descarga: psrvls10.zip

QR Code

QR Code (Quick Response) son un nuevo tipo de código de barras que puede contener mucha más información que un simple código de barras, incluyendo caracteres alfanuméricos e incluso otros alfabetos (japonés, cirílico, etc). Estos códigos son facilmente legibles mediante el teléfono móvil, se descarga un software especial de escaneo, y mediante la cámara de fotos del móvil, se marca la imagen, y luego podemos leer el contenido. La imagen que podéis ver en esta página y en la web es un código QR y hay en el la dirección de mi web (ThundaxSoftware). En el siguiente vídeo, podéis ver un anuncio de japón mostrando el funcionamiento del QR Code. Ahora se está explotando mucho, sobretodo en temas comerciales (vallas publicitarias), información de productos, comida, etc. Mediante este código por ejemplo podemos la lista entera de la composición de un producto con sus características. La verdad es que da mucho juego, y como que es un código de formato libre, podemos implementar los programas para que lean este tipo de código.

Podemos descargar la aplicación para nuestro móvil, en el siguiente enlace:

• beetagg.com

Nos tenemos que conectar al enlace desde nuestro teléfono, y luego descargar la aplicación para nuestro modelo en concreto.

Podemos encontrar generadores QR Online, donde podemos escribir lo que queramos automáticamente nos genera el código QR, aquí os dejo un par de enlaces:

• qrcode.kaywa.com
• winksite.com/site
• openqrcode.com
  

Podemos encontrar toda la información referente a la codificación en la página oficial de qrcode y nos podemos descargar el proyecto que tienen hecho para la decodificación en java:

• http://sourceforge.jp/projects/qrcode/downloads/28391/qrcode.zip

La web de la librería:

• http://qrcode.sourceforge.jp/

Aquí tengo el programa iniciado, cargando la imagen de mi web:


El log resultado de la captación de la imagen:

Starting QRCode Decoder GUI Example ...
Decoding started
Drawing matrix.
Scanning Finder Pattern.
originPoint is: (37,37)
FinderPattern at
(37,37)(147,37)(37,147)
Angle*4098: Sin 0 Cos 8388608
Version: 3
Adjust AP(1,1) to d(0,-1)
AlignmentPatterns at
(52,52)(132,52)
(52,132)(132,132)
Creating sampling grid.
Reading grid.
gridSize=29
Created QRCode symbol.
Reading symbol.
Version: 3-M
Mask pattern: 011
Correcting data errors.
Reading data blocks.

Decode result:
http://www.thundaxsoftware.org

Por lo tanto, crear aplicaciones donde podamos utilizar esta codificación es relativamente sencillo, y podemos encontrar la implementación hecha en varios lenguajes de programación.

Aquí os dejo también un par de vídeos mostrando la utilidad del QR Code:

La importancia sobre las Pruebas Unitarias

Cada vez desarrollamos Software más y más complejo, y esto produce que los plazos de entrega de nuestro producto a veces se eternicen o que nunca se cumplan. Por eso es muy importante que tengamos un buen proceso para depurar nuestras aplicaciones sin causar un gran trauma ni un gran coste al equipo de desarrollo. Mediante pruebas unitarias, verificamos que cada módulo funcione correctamente por separado, luego con las pruebas de integración probamos que la integración de los módulos sea correcta. La idea es escribir casos de prueba para cada función no trivial o método en el módulo de forma que cada caso sea independiente del resto. Muchos de los lenguajes de programación, proveen Unit testing como Dunit (para delphi) Junit (para Java) Nunit (para .Net), etc. Una de la técnicas más importantes para conseguir beneficios en nuestras pruebas y mejorar la calidad de nuestro Software, es aplicando (TDD) Test-Driven Development (Desarrollo guiado por pruebas).

Aplicar el TDD no es fácil, ya que requiere un cambio de mentalidad y profundizar bastante en las metodologías ágiles de programación. Este concepto pretende que primero se diseñen los test para nuestro módulo y luego se escriba el módulo. De esta manera el Software tiente a estar mejor diseñado, menos acoplado y más fácilmente mantenible, porque el programador es libre de hacer decisiones de diseño y hacer refactoring en cualquier momento con la seguridad de que el software todavía funciona. El test actúa evitando los bugs, si el desarrollador encuentra un bug, se crear un test que verifique que existe y luego se cambia en el módulo y se vuelve a pasar el test. Con todos estos test, el tiempo de depuración se reduce.

En la siguiente figura podemos ver que cuanto más complejo se vuelve el software y más grande, menos productivo es. Con el crecimiento del tamaño de los proyectos de software, y la complejidad del testeo del código Orientado a Objetos, las aplicaciones tienen millones de combinaciones, estados y caminos. Es imposible para alguien imaginar cada posible estado, incluso cada posible solución.

Numerosos estudios nos muestran que el coste de arreglar un defecto o error en nuestro programa se ve magnificado en función de la fase en que se encuentre. Esto significa que reparar un bug en la fase release puede costar 100 veces más que en la fase de codificación.

Las pruebas unitarias son necesarias (y obligatorias). Idealmente cada desarrollador debería producir un juego de test para validad cada método individual y clase que hayan escrito. Toma bastante tiempo identificar las áreas más problemáticas, escribir los tests, ejecutarlos, monitorizar los resultados, ficheros de seguimiento, etc. Y además, es bastante complicado para nosotros como seres humanos esperar lo "inesperado" (cosas que nunca habíamos imaginado que pasarían). La automatización de las pruebas ayuda mucho y es esencial. Hay que habituarse a utilizarlos ya sea mediante los xUnit o con Mock Objects o Stubs.

• Que nos aporta Agile Development?

En un post anterior sobre las nueve reglas de oro hice una pequeña introducción al desarrollo ágil y la programación extrema. Agile nos entrega una serie de herramientas que permiten mejorar la calidad de nuestro software haciendo que todo el equipo de desarrollo se involucre en esta metodología de trabajo.

El desarrollo Agile, nos introduce muchas herramientas muy interesantes para mejorar nuestra productividad y hacer que nuestro producto salga con una gran calidad y con muy pocos errores. Aquí os dejo un enlace con los axiomas del movimiento ágil: http://www.agileaxioms.com/

1. Scrum
2. Unit testing
3. Test Driven Development
4. Pair programming
5. Sprints/Iterations
6. Writing user stories
7. Continuous integration
8. Bug Tracking

PD: En los enlaces de interés hay una historia muy interesante sobre la complejidad del software de las naves espaciales, y como resuelven todo este tema.

• Enlaces de interés:

http://www.agileadvice.com/
http://haacked.com/archive/2006/10/20/The_Misuse_of_the_Space_Shuttle_Analogy.aspx
http://www.codinghorror.com/blog/archives/000113.html

Que es Peaberry?

Peaberry, es una extensión de la librería para Google Guice que soporta inyección de dependencia para servicios dinámicos. Provee integración OSGi, y para otros plug-ins basados en servicios de registro. Mediante esta extensión, podemos recoger los Bundles del OSGi, i transformarlos a módulos OSGi que entiende la plataforma del Dependency Injection (Google Guice). Si analizamos el ejemplo disponible desde la misma web del proyecto Peaberry en Google Code, ScramblerTest, podemos probarlo para ver como funciona, y en el apartado de documentación podemos encontrar un poco de información de las librerías y de su implementación:

"org.ops4j.peaberry.Peaberry" construye el proveedor de servicios.

"org.ops4j.peaberry.util" contiene ayudas opcionales para las clases.

Inyectando a un Servicio Dinámico desde OSGi:

    @Inject
    LogService logService;
    ...
    bind(LogService.class).to(service(LogService.class).single());

Exportando una implementación como un servicio OSGi:

    @Inject
    Export exportedLogService;
    ...
    bind(export(LogService.class)).to(registration(logImplKey).export());

Podemos encontrar más ejemplos en el javadoc del Peaberry.

Dependency Injection - da bomb!

Inyección de Dependencias (DI) es un patrón de arquitectura orientado a objetos, en el que se inyectan objetos a una clase en lugar de ser la propia clase quien cree el objeto. Todo este concepto está muy bien explicado en el libro del Google Guice: Agile Lightweight Dependency Injection Framework, donde aparecen varios ejemplos de inyección y las descripciones de todo este palabreo friki como "framework" o "Inversion of Control IoC". Es este post encontrareis un buen ejemplo y simple sobre el uso de la inyección de dependencias, que además he combinado con el Chaining Method para darle más "jugo". Este ejemplo, se basa en un constructor de edificios (BuilderConstructor), que tiene que construir una casa, con un par de ventanas y una puerta. El ejemplo es básico, y mediante proveedores de casas, puertas y ventanas, le daremos las herramientas necesarias para que el constructor de edificios pueda crear la casa sin problemas.

El ejemplo en UML es el siguiente:

Disponemos de la clase House, Window i Door. La casa puede contener Windows y Doors, y estas pueden tener el tamaño que queramos.

En el BuilderConstructor, se inyectan los proveedores de House, Door y Window. El BuilderModule, es el que hace referencia y enlaza los proveedores con las diferentes clases, por lo tanto el Proveedor de puertas está enlazado con la clase Door y así con las demás clases.

Con el BuilderTest, crearemos la aplicación y las dependencias (Inyectores) con guice para que nuestro constructor pueda construir la casa.

La implementación del Provider, simplemente es una pequeña factoría de clase que Guice invocará cuando necesite una instancia de ese tipo.

• Ejemplo de inyección @Inject:

House.java

import java.util.*;

public class House {
    private ArrayList<Window> windows = new ArrayList<Window>();
    private ArrayList<Door> doors = new ArrayList<Door>();

    public House addWindow(Window window) {
        this.windows.add(window);
        return this;
    }

    public House addDoor(Door door) {
        this.doors.add(door);
        return this;
    }

    public String Description() {
        String text;
        text = "This is a house with " + windows.size() + " Windows and \n";
        text = text + doors.size() + " Doors, the Windows are: \n";
        Iterator<Window> winIterator = windows.iterator();
        while (winIterator.hasNext()) {
            text = text + ("  " + winIterator.next().size() + " \n");
        }
        text = text + "and the Doors are \n";
        Iterator<Door> doorIterator = doors.iterator();
        while (doorIterator.hasNext()) {
            text = text + ("  " + doorIterator.next().size() + " \n");
        }
        return text;
    }
}

Window.java

public class Window {
    private int width;
    private int height;

    public Window(int width, int height) {
        setWidth(width);
        setHeigth(height);
    }

    public String size() {
        return "Size " + height + "x" + width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getWidth() {
        return width;
    }

    public void setHeigth(int height) {
        this.height = height;
    }

    public int getHeigth() {
        return height;
    }
}

Door.java

public class Door {
    private int width;
    private int height;

    public Door(int width, int height) {
        setWidth(width);
        setHeigth(height);
    }

    public String size() {
        return "Size " + height + "x" + width;
    }

    public void setWidth(int width) {
        this.width = width;
    }

    public int getWidth() {
        return width;
    }

    public void setHeigth(int height) {
        this.height = height;
    }

    public int getHeigth() {
        return height;
    }
}

HouseProvider.java, WindowProvider.java and DoorProvider.java

import com.google.inject.Provider;

public class HouseProvider implements Provider<House> {
    public House get() {
        return new House();
    }
}

import com.google.inject.Provider;

public class WindowProvider implements Provider<Window> {
    public Window get() {
        return new Window(10, 10);
    }
}


import com.google.inject.Provider;

public class DoorProvider implements Provider<Door> {
    public Door get() {
        return new Door(30, 10);
    }
}

BuilderModule.java

import com.google.inject.AbstractModule;

public class BuilderModule extends AbstractModule {
    protected void configure() {
        bind(Window.class).toProvider(WindowProvider.class);
        bind(Door.class).toProvider(DoorProvider.class);
        bind(House.class).toProvider(HouseProvider.class);
    }
}

BuilderConstructor.java

import com.google.inject.Inject;
import com.google.inject.Provider;

public class BuilderConstructor {
    @Inject
    private Provider<House> houseProvider;
    @Inject
    private Provider<Door> doorProvider;
    @Inject
    private Provider<Window> windowProvider;

    public House getHouse() {
        return houseProvider.get();
    }

    public Door getDoor() {
        return doorProvider.get();
    }

    public Window getWindow() {
        return windowProvider.get();
    }
}

BuilderTest.java

import com.google.inject.Guice;
import com.google.inject.Injector;

public class BuilderTest {
    public static void main(String[] args) {
        Injector injector = Guice.createInjector(new BuilderModule());
        BuilderConstructor m = injector.getInstance(BuilderConstructor.class);
        House house = m.getHouse();
        house.addDoor(m.getDoor()).addWindow(m.getWindow())
             .addWindow(m.getWindow());
        System.out.println(house.Description());
    }
}

El resultado de ejecutar esta aplicación es el siguiente:

This is a house with 2 Windows and 
1 Doors, the Windows are: 
  Size 10x10 
  Size 10x10 
and the Doors are 
  Size 10x30 

Por lo tanto, aquí tenemos nuestra aplicación con inyección. En el BuilderConstructor, se añaden los @Inject en las variables de tipo Provider, y estas se crear automáticamente cuando se hace la inyección.

De todas maneras, esto es solo la punta del iceberg, hay muchas más opciones para aprender dentro del tema del DI. Dependency Injection minimiza la complejidad a través de la abstracción, y permite que tengamos una aplicación más modular y nos permite hacer el testing de una manera más fácil.

• Enlaces de interés:

http://lebensold.net/category/php
http://misko.hevery.com/2008/07/08/how-to-think-about-the-new-operator/
http://martinfowler.com/articles/injection.html