Source: http://www.carlosrobles.com/blog/page/2/
Timestamp: 2019-03-27 03:26:55+00:00

Document:
Carlos Robles frikiblog | Eso tampoco me preocupa demasiado… | Page 2
Más o menos podemos decir que doctrine esta pensado para no pensar en el servidor de bases de datos, en tablas, ni en nada que no sea puramente las estructuras que vamos a utilizar en la programacion.
Por tanto se suele empezar creando entidades, que después doctrine transforma en lo que corresponda en el servidor de base de datos. Estamos totalmente abstraidos de la persistencia de datos.
Para mi, que siento una especie de amor por el diseño de modelos de base de datos, esto es un poco lo contrario a lo que me gustaria.
Mi forma de empezar un proyecto suele ser primero pensar a fondo un modelo, crear un diagrama con MySql WorkBench, desde ahi obtener el script sql y ejecutarlo directamente el servidor (Database > Forward engineering) y despues sincronizar cualquier cambio entre el modelo y el servidor. Despues, obtengo las entidades y el mapeo a partir del servidor de base de datos.
Esto es algo que se hace una vez al inicio del proyecto, pero es muy probable que haya que repetirlo si hay cambios importantes en el modelo. Hay que tener en cuenta que si la base de datos es compleja (muchas relaciones entre tablas, etc) puede que el resultado no sea el esperado, y tengas que retocar el mapeo a mano. Según la documentación de doctrine, automaticamente solo encotraremos el 70-80% de la informacion necesaria. Además, y copio directamente de la documentación “the detection from an existing database cannot detect inverse associations, inheritance types, entities with foreign keys as primary keys and many of the semantical operations on associations such as cascade”
En cualquier caso, me sigue pareciendo la mejor forma de empezar para los que nos gusta tener control total sobre como se modela la base de datos.
Este manual está pensado para integrar con Zend Framework 2. Por tanto, tendriamos que tener instalado:
Los modulos doctrine-module y doctrine-orm-module
Además algunos módulos de Symfony: console y yaml
Cómo instalar doctrine y sus modulos, lo veremos facilmente en la documentación de doctrine. Los de symfony es facil que ya nos los haya instalado el composer como dependencia de algun otro, si no es asi, tendremos que investigar un poco (no quiero salirme demasiado del tema).
Este mismo tutorial serviría para hacer la ingeniería inversa a un sistema que no fuese zend. En ese caso solo necesitariamos doctrine, y tener symfony instalado.
Hay distintas formas de hacerlo. Una es desde consola, y otra es desde código fuente. A mi me gusta desde consola, porque es la que nunca me ha fallado, por tanto explicaré esta.
Lo primero, creamos una carpeta y dentro creamos un archivo llamado cli-config.php, con este contenido:
//1.Configuración
setMetadataCacheImpl($cache);
// 2.Caché
// 3. Driver
$driverImpl = new Doctrine\ORM\Mapping\Driver\AnnotationDriver(array(__DIR__.'/Entities'));
// $driverImpl = new Doctrine\ORM\Mapping\Driver\YamlDriver('./config/yml/');
//$driverImpl = new Doctrine\ORM\Mapping\Driver\XmlDriver("./config/xml/");
//4. Proxies
$config->setProxyDir(__DIR__ . './Proxies');
//5. Conexión
'host'     => 'TU_HOST',
'user'     => 'TU_USUARIO',
'password' => 'TU_BASE_DE_DATPS',
'dbname'   => 'TU_CONTRASEÑA',
'mapping_types'   => array ( 'enum'   => 'string')  //ojo aqui
//6. EntityManager
$platform->registerDoctrineTypeMapping('enum', 'string');//ojo aqui
//7.HelperSet
Ahora tenemos que buscar los binarios de doctrine. En ZF los podremos encontrar en distintos sitios, segun com hayamos instalado doctrine. El sitio habitual sería aquí:
\vendor\doctrine\orm\bin
Lo que yo recomiendo es copiar directamente el archivo cli-config.php. Ademas, creamos una carpeta Entities.
Doctrine puede utilizar distintos drivers para crear las Classes, Classes con anotaciones o los archivos de configuración (xml, yml), en el punto 3 puedes elegir el driver. A mi me gusta hacer clases con anotaciones
Ahora abres un terminal (Inicio > ejecutar > cmd) y vas a la carpeta donde estan los binarios de doctrine y el cli-config.php, y ejecutas el comando que corresponda:
Nota:Para generar las clases es necesario que hayas generado primero los archivos de mapeo ya sea xml o yml.
Nota:Doctrine no trabaja con los tipos ENUM. Para ello lo que hacemos es un mapeo de tipos, para decirle que los tipos enum los trate como un string. hemos visto estas lineas:
'mapping_types' => array ( 'enum' => 'string')
Las dos hacen exactamente lo mismo, pero he tenido casos en distintos sistemas donde uno funciona y el otro no. Como poner los dos no supone ningun problema, suelo usar los dos aunque sea redundante.
Al terminar la ejecución, dentro de la carpeta Entities, tendras una clase para cada una de las tablas de la base de datos, y estarán preparadas para trabajar con doctrine.
Una vez tenemos las clases, donde colocarlas en nuestro proyecto depende de cada uno. Hay gente que tiene pocas entidades, y las coloca directamente dentro del modulo que las utiliza. Esto no es una buena práctica.
A mi personalmente, me gusta agrupar la capa de acceso a datos en su propia carpeta ajena a todo lo demás. En ZF, para no complicarme demasiado, creo un módulo con todas las clases referentes al acceso a datos, como Entidades, repositorios, etc.
Para eso, creo una estructura como la que se ve:
Es decir, dentro de module, creo un modulo de la forma habitual, le llamo DBAL (data base access layer) y dentro de src creo la carpeta DBAL, que contendra las que necesitemos, como por ejemplo Entity, Model, Repository, etc. Dentro de Entity colocaremos las clases que acabamos de crear.
Además, deberemos cambiar el namespace de cada una, para que podamos trabajar con ellos. Siempre utilizo DBAL\Entity, para todas las entidades, para ello la primera linea de los archivos de todas las entidades debe ser:
Ahora, le decimos ZendFramework como puede cargar todas. Primero en
config/aplication.config.php, dentro del array ‘modules’ añadimos “DBAL”
'DBAL',
y en la configuracion del modulo
/module/DBAL/config/module.config.php
le decimos a doctrine como cargar las clases del namespace DBAL\Entity, asi:
'mi_annotation_driver' => array(
'paths' => array(__DIR__ . '/../src/DBAL/Entity'),
'DBAL\Entity' => 'mi_annotation_driver',
http://jaehoo.wordpress.com/2011/11/17/ingenieria-en-inversa-en-php-con-doctrine-reverse-engineering-db/
Buscando un proyector, me he dado cuenta de que hay un montón de caractéristicas, y puede que no todo el mundo tenga muy claro cuales son las importantes, que signigica cada cosa, o que es lo que tiene que buscar cuando busca un proyector
He recopilado y digerido info de distintas webs para asegurarme de que tiene coherencia y no son opiniones mias sin mas. Entre otras cosas hay información obtenida de taringa, xakata, y ebay.
No os llevará al proyector ideal, pero s servirá como guía para saber qué es cada cosa y saber que es lo que teneis que buscar para no perderos entre mil datos.
Es la cantidad de detalle que puede mostrar un proyector y está definida por cuantos píxeles se proyectan. La resolución se expresa en pares de números, pixeles horizontales x pixeles verticales. Mientras más píxeles, mayor la resolución y mayor el nivel de detalle que podrá apreciarse en la imagen proyectada. Hasta aqui es igual que un monitor, con la diferencia de que con un proyector siempre se puede ampliar la imagen proyectada. Por tanto lo que nos interesa principalmente es lo que llaman “resolución verdadera” o “nativa”.
SVGA, o “800 x 600” – barato, pero mas limitado, más de uso domestico.
XGA, o “1.024 x 768” – Generalmente más caros, son un formato tan popular como la resolución a SVGA. Es el tamaño minimo a considerar para proyectar desde ipad sin limitarnos.
SXGA, o “1.280 x 1.024” – De alta resolución, y notablemente más costosos que XGA. Recomendados para usuarios que necesiten un proyector principalmente para conectar un ordenador, debido a qué éste requiere mayor resolución para mostrar mejor las letras y pequeños detalles.
UXGA, o “1.600 x 1.200” – Exclusivo para los usos a muy alta resolución que requieran detalle al máximo (generalmente PC destinados al trabajo y análisis de imágen). Relativamente pocos productos en el mercado tienen esta resolución nativa. Es más de lo que necesitariais para hacer presentaciones normales
La salida de luz del proyector se mide en unidades de ANSI lúmenes.
Más lúmenes significan más brillo de la imagen proyectada, lo que a su vez se traduce en poder ver imágenes de calidad aún cuando exista mucha luz en el lugar en que se esté proyectando. Tenemos que pensar si nos interesa poer hacer presentaciones en lugares con luz, o si podemos y nos interesa bajar las persianas. Evientemente el criterio es el que más luminosidad tenga, dentro de lo que te puedas permitir. Tambien hay que tener en cuenta si tienes una buena pantalla de proyecccion, que permiten ganar nitided y brillo
Menos de 1000 lúmenes – Se tendrán que hacer las proyecciones en la máxima oscuridad posible.
1000 a 2000 lúmenes – Ésta gama de lumenes conlleva una intensificación en el funcionamiento y el precio. Hay muchos productos de SVGA y de XGA en esta clase. Las proyecciones pueden hacerse con la iluminación del lugar, si bien al reducirla se mejora la visión de la pantalla. Generalmente la total oscuridad no es necesaria.
2000 a 3000 lúmenes – Ésta es la gama de alto rendimiento en proyectores portátiles y semi-portátiles. Los productos en esta clase son convenientes para grandes salas de conferencias y clases. Ofrecen más flexibilidad en términos iluminación del lugar, puesto que la imagen es bastante brillante (una sala con luz moderada puede ser válida). También ofrecen más flexibilidad en términos de tamaño puesto que pueden iluminar una pantalla más grande sin mucha pérdida de calidad en la imagen.
3000 lúmenes y más – Normalmente mas de lo necesario, considerar solo si el precio no sube mucho. Los hay hasta 12.000 lumenes, y los précios cubren una amplia gama dependiendo de otras características de funcionamiento. Se utilizan en variedad de lugares que requieren enormes pantallas, incluyendo salas de conferencias, auditorios, iglesias, conciertos, etc…
La cantidad de luz que impacta en la pantalla produce que el color negro pierda intensidad. Para compensar esto, debe considerarse adquirir un proyector con el mejor contraste posible.
Ccuantas más lleve mucho mejor, pues nos abre el abanico de cara a conectar fuentes de vídeo o información. Indispensables la conexión para el ordenador, VGA y la de S-video. Mucho mejor si añadimos la DVI y si queremos alta definición, o conectar tablets o moviles, la HDMI es una necesidad. Tambien los hay con wifi, que nos puede resultar util si nos desplazamos y tenemos que instalarlo en distintos sitios, o si queremos hacer presentaciones desde tablet, movil, o portatil, con una comodidad mayor.
Es importante considerar si mayormente va a estar en un lugar fijo o si va a tener que transportar. De cara a comparar, es importante ver si las fichas indican “peso neto” o “peso bruto”
Entre los más normales están entre los 2 kg los mas ligeros, y los 4 los mas pesados
Los hay ultraligeros, o portatiles, de menos de un kilo. Suele ser a costa de perder otras caracteristicas, por tanto es importante saber las preferencias.
Los más profesionales, de alto desempeño y requisitos muy exigentes, pueden pesar mas de 10 kg. Suelen instalarse en el techo con idea de no moverse.
Son menos importantes pero nos pueden hacer decidirnos por un producto muy similar a otro. Por ejemplo:
que lleve un buen sonido integrado (altavoces)
mejoras digitales para la imagen
Distancia necesaria a la pared
Hay distintas tecnologías que se usan en la actualidad para generar las imágenes en los proyectores. Son tres, LCD, DLP y LED.Normalmente, escogeremos proyector por el conjunto de características, no por la tecnología usada.
LCD: es la tecnología más antigua, y se basa en la misma filosofía que las pantallas, solo que aquí la imagen es proyectada luego.
DLP: son más actuales que los LCD, usan tecnologías distintas por lo que cada uno tiene sus ventajas e inconvenientes, pero en rendimiento se están acercando mucho últimamente. En este caso la imagen es creada por espejos microscópicos dispuestos en una matriz sobre un chip semiconductor, en el que cada espejo representa un píxel en la imagen proyectada.
Por tanto es importante comprobar el tiempo de vida util indicado por el fabricante, que puede ir entre las 2.000 y las 6.000 horas mas o menos, sabiendo cuanto lo usamos podemos hacer el ejercicio de calcular cuantos años nos va a durar. Si no lo usamos mucho cada dia, no es muy preocupante porque cualquiera nos puede durar cinco o 10 años.
Lo que si que es importante, es tratar bien el proyector para no acortar su vida:
Abreis visto el modificador synchronized en distintos métodos java, voy a explicar brevemente para qué sirve.
Vemos esta clase de la documentación de oracle:
public synchronized void increment() {c++;}
public synchronized void decrement() {c--;}
public synchronized int value() {return c;}
Esto es una buena base, aunque hay muchas cosas a tener en cuenta cuando hablamos de hilos y concurrencia, especialmente Deadlocks, bloqueos mutuos y ese tipo de complicaciones. Un buen punto de partida para entender conceptos es la documentacion de oracle:
Veo que hay alguna gente que no termina de tener claro los tipos de visibilidad en Android, en lo que respecta a View.INVISIBLE y View.GONE. Voy a explicarlo, y de paso pongo el equivalente CSS que para muchos será la mejor explicación.
1. View.VISIBLE: Normal, visible.
/*equivalente CSS*/
/*display: block; o cualquiera excepto none*/
2. View.INVISIBLE: No se ve nada, pero el componente ocupa el espacio. Es decir, se reserva un espacio vacio del tamaño del componente
3. View.GONE: No se muestra ni reserva el espacio, es como si no existiese.
Estoy haciendo pruebas con Libra CMS (un CMF opensource basado en ZF2) y me encuentro este problema. Es bastante normal en Zend, y en otros sistemas, y si es un sistema que acabas de instalar, posiblemente empieces a buscar dependencias por el sitio equivocado. La clase Locale es de PHP 5, por tanto si no te la encuentra, debes empezar comprobando que tienes php 5, que tienes la extensión correspondiente instalada, o si la tienes activada.
La extension es php-intl.
Si estas en wamp, la puedes activar desde el icono de wamp en la bandeja del sistema, en PHP > PHP extensions > php-intl
Si no, puedes hacerlo directamente en tu php.ini, descomentando la linea correspondiente, (recuerda que en php.ini el punto y coma es un comentario) busca
;extension=php-intl.dll
;extension=php-intl.so
quita el ; y reinicia apache.
Si no funciona, o no encuentras esa linea, es probable que no tengas la extensión. Échale un ojo a :
http://php.net/manual/es/intl.setup.php
UPDATE: puede que en tu servidor la extension se llame simplemente intl.so
UPDATE: si no puedes editar tu php.ini, a partir de 5.3 puedes considerar un phprc. diré más sobre esto en breve.
Categories: PHP, Zend | Permalink
En el post sobre TDD mencioné los Baby Steps, por si alguien no sabe a que me refiero con esto, lo voy a comentar, que son dos lineas:
Básicamente significa que el siguiente paso en un desarrollo debe ser lo más pequeño posible. No debemos pensar en nuevas fases muy grandes, que son dificiles de diseñar, de estimar, y de probar de forma unitaria, si no en pasos muy pequeños que sean absolutamente triviales, y que a su vez hacen el siguiente paso tambien trivial.
Combinado con TDD, no solo nos facilita mucho la estabilidad, sino que además dispara la productividad.
En una aplicación Android, cuando estamos en una actividad, y queremos volver a la actividad que llamó a la actual, como sabemos, simplemente llamando a
termina nuestra actividad actual, y volvemos a la anterior en la pila.
Se complica más cuando queremos volver a una que no está inmediatamente atrás, por ejemplo si queremos volver a la home. Pues en realidad es igual de fácil. PAra ello creamos un intent para esa actividad, pero le añadimos el flag
Que le indica al sistema que la actividad que estamos lanzando ya está en ealidad corriendo, y en lugar de lanzar una nueva, lo que queremos es que se cierren todas las actividades que nos separen de ella, y hacerla la actual. Eso si, el intent se le entregará a la actividad vieja, como un intent nuevo, por tanto podemos usarlo de la forma habitual para pasar datos entre actividades, o cualquiera de las posibilidades normales.
Para añadir el flag, hacemos esto:
Intent intent = new Intent(this, ActivitySuperior.class);

References: resolución 
 resolución 
 resolución 
 resolución 
 resolución 
 resolución