domingo, abril 29, 2007

Caótico: Dícese [...]

Ultimamente mi vida es bastante caótica primero porque hay muchas cosas que hacer (los clientes siempre piden las cosas para ayer). También tengo vida personal que trato de no contaminar con mí profesión pero no es tan fácil cuando la linea es muy delgada. En la lista "Para hacer" hay varias cosas, tanto personales como profesionales. Pero hace no más de 15 días sufrí un accidente con mi padre en la calle... un inconsciente arriba de una moto nos choco, por suerte (no me gusta decir eso) no fue muy grave pero mi padre termino con un pie quebrado. Esta experiencia no muy grata me hizo re-plantearme muchas cosas, entre otras, la laboral o mi "estilo de trabajo".
Si bien este blog no es para hablar sobre mi vida personal (mas bien mi contacto con la programación y la informática en general) el incidente llego a desbaratar toda mi vida o una gran parte de esta.

Cambiando un poco de tema, algunas cosas que tengo planeadas realizar que le puede ser de interés a los queridos lectores podrían ser:

  • Screencast sobre SQL.
  • Iniciación de un "proyecto libre" propio.
  • Terminar de extender los artículos sobre UML.
  • Mi propio reality.
  • Una idea "Loca".
  • Lectura de dos libro y comentarlos en el blog.
Explicación de cada punto:

Screencast: Hace tiempo tenía ganas de hacer uno pero realizar algo que me hubiera gustado encontrar cuando yo empecé. Soy de las personas que le gustan ver ejemplos y sus resultados y sacar propias conclusiones con poca teoría.
Proyecto Libre: Algún proyecto chiquito y que de la posibilidad a los que saben insultarme xD
UML: Idea a largo plazo, quiero leer y aprender más sobre el tema.
Reality: Blog personal contando vivencias y cosas personales.
Idea "Loca": Es clon de otra idea pero mas innovadora y con un enfoque diferente... si funciona en otros lugares me debería de funcionar a mí.
Libros: El libro de la certificación de PHP y "UML Gota a Gota". Ambos me dejarán alguna enseñanza y se comentara aquí seguramente.

sábado, abril 14, 2007

UML - Relación de Uso (Dependencia o Instanciación)

La relación de uso es la más facíl de todas, se podría definir de ésta manera:

La instanciación de un objeto depende de otro objeto/clase.

Traducido (o en "criollo") un objeto "usa" a otro cuando el primero crea una instancia del segundo y lo devuelve. Ojo, no guarda la instancia creada porque sino sería Composición.


Diagrama de Clase

En código sería algo así:

class Usuario{
private $nombre = '';
private $edad = 0;

public function __construct($nombre, $edad){
$this->nombre = $nombre;
$this->edad = $edad
}
}

abstract class Fabrica{

public function crearUsuario($nombre, $edad){
return new
Usuario($nombre, $edad);
}
}

$usuario = Fabrica::crearUsuario("Dario", 20);

Espero que se entienda, la verdad es bastante simple.

DarioDario.

lunes, abril 09, 2007

He perdido ante J2ME

Si, he perdido. No entiendo (entre otras cosas) el tema de versiones, que editores (IDE's) usar, etc. Les comento toda mi frustración.

Desde el principio empecé mal, no entendía las distintas nomenclaturas (ME = Micro Edition, SE = Standart Edition, EE = Enterprice Edition), obvio que la responsabilidad es mía. Ya aprendí varias cosas pero me faltan muchas otras por ejemplo un tutorial de Carbide, los que baje de la web de Nokia (vídeos tutoriales por cierto) están muy des-actualizados. El producto que instale en mi PC difiere totalmente de lo que se muestra en el vídeo tutorial, ni siquiera tiene pequeñas diferencias, directamente parecen 2 productos totalmente distintos.

Había logrado instalar J2ME en mi PC y logre hacer mi primer MIDlet pero ni de casualidad lo pude hacer andar un mi Nokia, en el emulador si pero para que me sirve si solo anda en el emulador. Más allá de esto tuve las 1001 advertencias porque la versión de la maquina virtual de Java de mi PC es "vieja" o muy actual (si si, cada aplicación va con una versión especifica de otra cosa). Muchas cosas correlativas.

Está bien, mi frustración no es más que por desconocimiento, pero no podrían ser un poco más colaborativos y poner en su web las versiones de las cosas que van? Me proporcionan todo pero también cuando intento descargar algo me encuentro con 4 versiones distintas de lo mismo.

En fin, "baje los brazos" (sigo leyendo y demás) pero estoy decidido a comprar ese libro que desde hace tiempo quiero comprar... supongo que en esta semana si tengo tiempo voy a la primera librería que encuentre y busco alguno y comento (para el que quiera saber).

DarioDario

sábado, abril 07, 2007

Programando para el Nokia 6131


Soy un feliz poseedor de un Nokia 6131 (algún día hablaré de el). Hace tiempo que me interesa el desarrollo para móviles por diversión, pero siempre lo pospuse por una u otro razón. También hace bastante vengo posponiendo la compra de un libro sobre esto, pero ayer caí de casualidad en una web donde había un tutorial sobre J2ME (Java 2 Micro Edition) y me puse a leer. Después de leer un poco me dispuse a instalar todo lo necesario y costo bastante.

Instalación

Fue bastante difícil para mí pero pude lograrlo. Una cosa que me confundió bastante y me dificulto las tareas es la gran cantidad de nomenclaturas que no conozco y tienen las distintas cosas. También tuve problemas por la versión y tipo del paquete instalado y demás, lo siguiente fue lo que me funciono.

1) Primero hay que instalar J2SE (Java 2 Standar Edition). Tuve bastantes problemas y este es el que me anduvo (bajar).
2) Instalar J2ME (Java 2 Micro Edition) de aquí se puede bajar.

En este punto ya podemos trabajar, pero puede ser que les interese este paso extra:

3) Instalar plug-in de J2ME en Eclipse.

Documentación útil

El tutorial de Programación de juegos para móviles con J2ME fue lo que leí y que al ver lo fácil que era todo (por mis conocimientos previos) me dispuse a aprender. La verdad es que no es nada difícil el lenguaje (encontrar documentación tampoco lo es). Por ahora solo estoy aprendiendo las cosas básicas como puede ser la sintaxis (que me es fácil porque ya la conozco) y como trabajan los objetos (bastante simple porque no cambia mucho a lo que yo ya sé). Si quieren también tienen varios manuales de J2ME. La verdad no es difícil encontrar documentación basta con poner j2me en google y encontramos de todo. No leí mucho así que no pongo referencia a ninguno porque no sé que calidad tendrá dicho tutorial.

Datos específicos del Nokia 6131

Resulta que al seguir investigando me encuentro con que Nokia te da todo lo necesario para que desarrolles. Aquí tenemos los detalles técnicos del Nokia 6131 y aquí distintas herramientas y kit de desarrollos para el Nokia 6131 (presten atención, este es de los serie 40... no bajen cualquier cosa).
El próximo paso que haré es la instalación de las herramientas que da Nokia que suponen que andarán sin problemas cosa que es seguro que tenga con la instalación aparte de las cosas.

Mañana comentaré la instalación y nuevos descubrimientos sobre las herramientas que Nokia facilita.

Por si a alguien le interesa este es un foro sobre el Nokia 6131 que encontré dando vueltas por ahí; tiene una sección de programación, tal vez ahí puedan sacarse algunas dudas.

DarioDario.

jueves, abril 05, 2007

La Agregación en UML según yo


Bueno, en el post anterior vimos como se conforma una relación de Composición entre dos objetos; ahora veremos como se conforma una relación de Agregación.

La Agregación es un tipo de relación dinamica, donde el tiempo de vida del objeto incluido es independiente del que lo incluye.

Con la relación de Composición se dice: "Un banco tiene cuentas bancarias, pero si no existe el banco tampoco las cuentas." pero con la Agregación es: "El banco tiene clientes, pero si no existe el banco los clientes siguen estando." osea los clientes (las personas) no mueren con el banco, las cuentas bancarias si.

Veamos algo de código:

class Cliente{
private $nombre = '';
private $dni = 0;
private $fechaNacimiento;

public function __construct($nombre, $dni, $fechaNacimiento){
$this->nombre = $nombre;
$this->dni = $dni;
$this->fechaNacimiento = $fechaNacimiento;
}

public function setNombre($nombre){ $this->nombre = $nombre; }
public function setDni($dni){ $this->dni = $dni; }
public function setFechaNacimiento($fechaNacimiento){ $this->fechaNacimiento = $fechaNacimiento; }
}

class
Banco{
private $nombre = '';
private $direccion = '';
private $clientes = array();

public function __construct($nombre,$direccion){
$this->nombre = $nombre;
$this->direccion = $direccion;
}

public function agregarCliente(Cliente $cliente){
$this->clientes[] = $cliente;
}
}

$banco = new Banco('Nacion', 'Lejos de aca');

$dario = new Cliente("Dario", 3000000000, "10-10-2010");
$claudio = new Cliente("Claudio", 3000000001, "10-10-2010");

$banco->agregarCliente($dario);
$banco->agregarCliente($claudio);

unset(
$banco);

echo
'<pre>';
var_dump($dario, $claudio);
echo
'</pre>';

Como se puede ver, banco muere, pero los clientes siguen "vivos".

Cualquier duda en los comentarios.

DarioDario

lunes, abril 02, 2007

Composición y un articulo "malo"

Realmente no soy el indicado como para decir que algo esta mal o esta bien, pero me encontré con algo (un articulo específicamente xD ) que realmente se contradice en algunas cosas y no realiza un buen ejemplo.

Primero voy a explicar que entiendo yo por Composición y luego entro a analizar el artículo.

Relación entre distintas capas.

Composición según Dario Ocles XD

Si me baso en una definición ya hecha sería la siguiente:
El tiempo de vida del objeto incluido esta condicionado por el tiempo de vida del que lo incluye.
Entonces entendemos que un objeto incluye a otro, pero la vida del incluido es condicionada por la vida del objeto que lo incluye (es obvio esto, pero debía decirlo).

Este sería un ejemplo de dicha relación:
class Cuenta{
private $numero = '';

public function __construct($numero){
$this->numero = $numero;
}
public function getNumero(){ return $this->numero;}
}


class
Banco{
private $nombre = '';
private $direccion = '';
private $cuentas = array();

public function __construct($nombre,$direccion){
$this->nombre = $nombre;
$this->direccion = $direccion;
}

public function agregarCuenta($numeroDeCuenta){
$this->cuentas[] = new Cuenta($numeroDeCuenta);
}
}


$banco = new Banco('Nacion', 'Lejos de aca');
$banco->agregarCuenta(123);
$banco->agregarCuenta(1234);
$banco->agregarCuenta(12345);
Perdonen la falta de indentación, pero éste bendito WYSIWYG me gano.

La relación se puede verificar por el simple hecho que si muere la instancia de la clase Banco, en este caso la variable $banco, todas las instancias de Cuenta relacionadas con la instancia anterior muren también.

Composición según el articulo

El articulo en concreto es éste y lo descubrí gracias a éste thread dentro de ForosDelWeb (Allí también se discute sobre esto).

Lo primero que debo decir es que ya lleva algún tiempo largo colgado en la red (tiene fecha de 11-07-2005). Lo segundo que puedo decir... en realidad no voy a decir voy a citar una frase de allí:
It occurs when an object creates another object; that is, the first object completely possesses the second object.
Traducido sería algo así (no doy fe sobre la traducción ya que no soy muy bueno en esto):
Esto ocurre (N.T: la Composición) cuando un objeto crea otro; es decir, el primer objeto posee completamente al segundo objeto.

En la segunda página sobre éste tema también dice algo así:
Composition happens when one object directly creates a second object. This means that the original object is responsible for the “birth” of the second.
Traducido sería algo así:
La Composición ocurre cuando un objeto de forma directa crea a un segundo objeto. De esta manera el objeto original es responsable del "nacimiento" del segundo.
Ahora si analizamos el código del ejemplo (esta aquí) podemos asegurar lo siguiente (obviamente también tenemos que leer el articulo completo):
  • La clase Page es la que incluye a la clase Table.
  • En teoría si muere Page muere Table.
Ahora yo hice la siguiente prueba: Si ejecuto lo siguiente demuestro que la Composición no está bien aplicada... o por lo menos lo que yo entiendo por Composición.
$page=&new Page();
$page->makeHeader('
Header
'
);
$table=$page->makeBody(range(0,20));
$table->setId('maincontent');
$table->build('#ffcc00','#eeeeee');
$page->makeFooter('
Footer
'
);

unset(
$page);

echo
'
';
var_dump($table);
echo
'
';
En éste caso muere Page pero Table ni siquiera se "entera" esto va en contra totalmente sobre lo que hablamos de Composición o por lo menos va en contra de la teoría que aquí se expuso.

Lo que no termino de entender es el porque de este ejemplo mal hecho pero sospecho que se debe a lo siguiente.
En la clase Page se declara un metodo makeBody() de la siguiente manera:
function makeBody($content=array()){
return new
Table($this,$content);
}
Y en todo caso sí se hace eso hay una relación de uso (línea punteada)... pero hay otra cosa "rara" y es que en la clase Table el constructor es definido de la siguiente manera:
function Table(&$page,$content){
$this->page=&$page;
$this->content=$content;
$this->id='defaultID';
}
La propiedad page de la clase Table termina siendo un tipo de "puntero" de C... si el objeto cambia fuera del objeto Table también lo hace la propiedad dentro de Table (actuando así como un puntero) pero aún así si muere Page de ninguna manera muere Table (cosa necesaria para considerarse una relación de Composición).

Espero que esto sirva de algo a alguién y cualquier duda, consulta, queja o corrección son bienvenidas.

DarioDario.