viernes, 30 de julio de 2010

rehacer una aplicación desde 0

un interesante  articulo  encontrado  aqui: http://www.joelonsoftware.com/articles/fog0000000069.html 

pero en ingles, disculpen la traducion pero es lo mejor  que  hace el google.



Las cosas que nunca debes hacer, parte I

Joel Spolsky por
Jueves, 06 de abril 2000
Netscape 6.0 está finalmente entrando en su primera beta pública.Nunca hubo una versión 5.0. El último lanzamiento importante, la versión 4.0, fue lanzado hace casi tres años. Tres años es un muy largo tiempo en el mundo de Internet. Durante este tiempo, se sentó junto a Netscape, con impotencia, como su cuota de mercado cayó en picado.
Es un poco zalamero de mí que les critican por haber esperado tanto tiempo entre versiones. No lo hice a propósito, ahora, ¿verdad?
Bueno, sí. Ellos lo hicieron. Lo hicieron, haciendo que el único peor error estratégico que cualquier compañía de software puede hacer:
Decidieron volver a escribir el código desde cero.
Netscape no fue la primera compañía para hacer de este error. Borland cometió el mismo error cuando compraron Arago y trató de convertirlo en dBase para Windows, un proyecto condenado al fracaso que llevó tanto tiempo que Microsoft Access se comió su almuerzo, y luego lo hicieron de nuevo en la reescritura de Quattro Pro desde cero y la gente increíble con qué pocos características que tenía. Microsoft casi cometió el mismo error, tratando de reescribir Word para Windows desde cero en un proyecto condenado al fracaso llamada pirámide que fue cerrado, tirado, y barrido bajo la alfombra. Por suerte para Microsoft, que nunca habían dejado de funcionar en el antiguo código base, así que tenía algo para enviar, por lo que es simplemente un desastre financiero, no de carácter estratégico.
Estamos programadores. Los programadores son, en sus corazones, arquitectos, y lo primero que quieren hacer cuando llegan a un sitio es arrasar el lugar plano y construir algo grande. No estamos contentos por la renovación elementales: el bricolaje, la mejora, la plantación de macizos de flores.
Hay una razón sutil que los programadores siempre quieren tirar el código y empezar de nuevo. La razón es que piensan que el viejo código es un desastre. Y aquí está la observación interesante: probablemente están equivocados. La razón de que ellos piensan que el antiguo código es un desastre se debe a una, fundamental ley fundamental de la programación:
Es más difícil leer el código que escribirlo.
Esta es la razón por la reutilización de código es tan difícil. Por eso todo el mundo en tu equipo tiene una función diferente que desea usar para dividir cadenas en los arrays de cadenas. Ellos escriben su propia función porque es más fácil y más divertido que descubrir cómo funciona la función de edad.
Como corolario de este axioma, puede pedir casi cualquier programador de hoy sobre el código que está trabajando. "Es un lío peluda", le dirán. "Me gustaría nada mejor que tirarlo y empezar de nuevo."
¿Por qué es un desastre?
"Bueno", dicen, "mira esta función. Se trata de dos páginas! Ninguna de estas cosas pertenecen ahí! No sé lo que la mitad de estas llamadas a la API son para".
Antes nueva hoja de cálculo de Borland para Windows enviadas, Philippe Kahn, el fundador de colores de Borland, fue citado mucho en la jactancia de prensa acerca de cómo Quattro Pro sería mucho mejor que Microsoft Excel, porque fue escrito desde cero. Todo el código fuente de nuevo! Como si el código fuente oxidado.
La idea de que el nuevo código es mejor que el viejo es evidentemente absurdo. código antiguo se ha utilizado. Se ha probado. Lotes de errores han sido encontrados, y han sido fijados. No hay nada malo en ello. Interesada no podrá adquirir sólo los errores con los brazos cruzados en su disco duro. Au contraire, baby! ¿Es el software supone que es como un viejo Dodge Dart, que se oxida sentado en el garaje?¿El software como un oso de peluche que es bastante asqueroso si no está hecha de todo el nuevo material?
Volver a la función de la página dos. Sí, lo sé, es sólo una simple función para mostrar una ventana, pero ha crecido pelitos y cosas sobre ella y nadie sabe por qué. Bueno, te diré por qué: esas son las correcciones de errores. Uno de ellos corrige ese error que Nancy tenía cuando ella trató de instalar la cosa en un equipo que no tiene Internet Explorer.Otro error que revisiones que se produce en condiciones de baja memoria. Otro error que correcciones que se produjo cuando el archivo está en un disquete y los Yankees de usuario a cabo el disco en el centro. Esa llamada a LoadLibrary es fea, pero se puede ver el código en las versiones anteriores de Windows 95.
Cada uno de estos errores tomó varias semanas de uso del mundo real antes de que fueran encontrados. El programador podría haber pasado un par de días reproduciendo el error en el laboratorio y arreglarlo. Si es como un montón de errores, la solución podría ser una línea de código, o incluso podría ser un par de caracteres, pero una gran cantidad de trabajo y el paso del tiempo en esos dos personajes.
Cuando usted lanza lejos el código y empezar de cero, va a tirar todo ese conocimiento. Todos los recogidos correcciones de errores. Años de trabajo de programación.
Usted está desechando su liderazgo en el mercado. Usted está dando un regalo de dos o tres años a sus competidores, y créanme, es unlargo tiempo en años de software.
Usted se está poniendo en una situación extremadamente peligrosa en la que se envío una versión antigua del código durante varios años, completamente incapaz de realizar cualquier cambio estratégico o de reaccionar a las nuevas características que exige el mercado, debido a que no tienen código fáciles de enviar. Es posible que también acaba de cerrar para el negocio de la duración.
Estás perdiendo una cantidad descabellada de dinero escribiendo código que ya existe.
¿Hay alguna alternativa? El consenso parece ser que el antiguo código base de Netscape fue realmente malo. Bueno, podría haber sido malo, pero, ¿sabes qué? Funcionó bastante maldito bien en una gran cantidad de raíces de sistemas de computación del mundo.
Cuando los programadores dicen que su código es un desastre santo (como siempre lo hacen), hay tres tipos de cosas que están mal con ella.
En primer lugar, hay problemas de arquitectura. El código no sea un factor correctamente. El código de red se están expandiendo por sus propios cuadros de diálogo de la mitad de la nada, lo que debería haber sido tratado en el código de interfaz de usuario. Estos problemas se pueden solucionar, uno a la vez, moviendo cuidadosamente el código, la refactorización, el cambio de interfaces. Se puede hacer un programador trabajar con cuidado y comprobación de sus cambios de una sola vez, para que nadie más se interrumpe. Incluso arquitectónica bastante grandes cambios se puede hacer sin tirar el código. En el proyecto Juno que pasó varios meses rearchitecting en un punto: sólo moviendo cosas de sitio, limpiarlas, la creación de clases base que tenía sentido, y la creación de interfaces entre los módulos afilados. Pero lo hicimos con cuidado, con nuestra base de código existente, y no introdujo nuevos errores o tirar código de trabajo.
Una segunda razón los programadores piensan que su código es un desastre es que es ineficiente. El código de representación en Netscape se rumoreaba que era lento. Pero esto sólo afecta a una pequeña parte del proyecto, que se puede optimizar o incluso reescribir. No es necesario volver a escribir toda la cosa. Cuando se optimiza para la velocidad, el 1% del trabajo que usted obtiene el 99% de la explosión.
En tercer lugar, el código puede ser doggone feo. Uno de los proyectos que trabajé en realidad tenía un tipo de datos llamado FuckedString.Otro proyecto que había comenzado con la convención de las variables miembro de partida con un guión bajo, pero más tarde pasó a la más estándar "m_". Así, la mitad de las funciones que comience con "_" y la otra mitad con "m_", que parecía feo. Francamente, este es el tipo de cosas a resolver en cinco minutos con una macro en Emacs, no partiendo de cero.
Es importante recordar que al iniciar desde cero no hayabsolutamente ninguna razón para creer que va a hacer un mejor trabajo de lo que hizo la primera vez. En primer lugar, es probable que ni siquiera tienen el mismo equipo de programadores que trabajaron en la versión uno, por lo que en realidad no tienen "más experiencia".No eres más que va a hacer la mayoría de los viejos errores de nuevo, e introducir algunos nuevos problemas que no estaban en la versión original.
La antigua cantinela deconstruir una a tirar es peligroso cuando se aplica a gran escala para aplicaciones comerciales. Si está escribiendo código de forma experimental, es posible que desee romper la función que escribió la semana pasada cuando se piensa en un mejor algoritmo. Eso está bien. Es posible que desee refactorizar una clase para que sea más fácil de usar. Eso está bien, también. Pero tirar todo el programa es una locura peligrosa, y si Netscape ya contaba con supervisión de un adulto con experiencia en el sector de software, es posible que no se han disparado en el pie tan mal.

programador Solitario: Macho Driven Development

este es un articulo publicado aqui:http://geeks.ms/blogs/lontivero/archive/2010/05/31/macho-driven-development.aspx y me  parecio muy interesante, hasta comico, pero muy real..


Macho-Driven Development

Un verdadero macho programador puede escribir scripts en Ruby o en algún otro lenguaje elegante y sofisticado pero siempre preferirá un verdadero lenguaje de programación, aún para hacer una simple suma, uno en el que pueda usar punteros y operar con bits. Y es que todos sabemos que los punteros y los bits son absolutamente de machos.
Tampoco les agrada mucho la idea de TDD (y muchísimo menos de alguno de sus primos mas coquetos, como BDD), porque un buen programador programa, eso es lo que hace. Las pruebas las deben hacer los testers y los testers, como todo el mundo sabe, son en su mayoría mujeres.
Ni que hablar de esas extrañas prácticas como la de programar de a dos! Que es eso de sentarse juntos y compartir un teclado como dos tontos?! Encima, el limpia vidrios del edificio de seguro los miraría con cara inquisidora. Ni que hablar! Eso tiene que ser menos productivo definitivamente.
El verdadero macho programador tiene una cualidad distintiva: es el que hace que el código ande. Otros, por el contrario, siempre están discutiendo aspectos estéticos como los nombres de los identificadores, el tamaño de los métodos, patrones y toda clase de minucias que solo retrasan el proyecto y no agregan ningún valor para el cliente.
Este programador es pragmático al 100%, si el problema puede solucionarse mediante una bandera y un par de instrucciones goto, él se anima a hacerlo. Esto es lo que los clientes quieren y lo que los gerentes quieren, pero los programadores menos machos prefieren perderse en sus ñoñeces y a lo único que atinan es a culpar a los machos de todo bug que anda  dando vueltas.
Pero si la cualidad por la que se destacan frente los clientes es por hacer las cosas, y rápido; por lo que sobresalen realmente en su interior es por su absolutamente excepcional creatividad. Esta es la que parece que toda la organización intenta extirparle. Esto lo hacen tratando de restringir su libertad creadora mediante sumisión a estúpidos estándares de programación, revisiones de código, pruebas unitarias, programación de a pares y en casos extremos, hasta con auditorías para ver si el nombrecito del archivito era correcto y estaba en la carpetita que debía estar.
Creo que ya está bueno de estos machos creativos. No se puede permitir que cada uno programe como se le dé la gana. Esta es una profesión y por lo tanto debe ejecutarse en forma rigurosamente profesional, realizando el trabajo según los “protocolos” conocidos.
Los preconceptos y las miradas ideológicas sobre tales o cuales tecnologías no puede tener cabida en nuestro ámbito. El antiguo pensamiento de “mi lenguaje es mucho mejor que ese otro”, además de antiguo es infantiloide pero aún persiste. Da avergüenza ajena cuando se lo escucha.
En cuanto a ese lado artístico, he conocido muchísimos desarrolladores que se consideran a si mismos como artistas, en algunos casos se perciben como grandes artistas, y la verdad es que están bastante fuera de lugar. Todos en nuestro interior tenemos algo de artistas, eso es definitivamente muy bueno. Lo que no es bueno es que lo volquemos al código.

miércoles, 28 de julio de 2010

Principios de Diseo POO

Principios de Diseño Orientado a Objetos

  1. SRP - Single Responsibility Principle (Principio de Responsabilidad Única)
  2. OCP - Open/Closed Principle (Principio Abierto / Cerrado)
  3. LSP - Liskov Substitution Principle (Principio de Sustitución de Liskov)
  4. DIP - Dependency Inversion Principle (Principio de Inversión de Dependencias)
  5. ISP - Interface Segregation Principle (Principio de Segregación de Interfaces)
Algunos apuntes encontrados en Wikipedia (inglés)
http://en.wikipedia.org/wiki/Single_responsibility_principle
http://en.wikipedia.org/wiki/Open/closed_principle
http://en.wikipedia.org/wiki/Liskov_substitution_principle

1. SRP - Single Responsibility Principle (Principio de Responsabilidad Única)


Enunciado formal: "Una clase debería tener solo una razón para cambiar"



Vamos a tomar un pequeño conjunto de clases para nuestro ejemplo, empezaremos con una y veremos los males que nos aquejan.


Nuestra clase Cliente es verdaderamente potente, sabe hacer tantas cosas!!!!, con solo tener una instancia de ella puedo resolver una gran cantidad de problemas.

Veamos que cosas sabe hacer:

1 - Persistirse
2 - Eliminarse
3 - Crear una salida HTML que muestre sus atributos
4 - Hacer reportes referidos a ella misma
5 - Calcular su edad en el mercado

Todo parece muy cómodo, pero analicemos como se comporta esta clase frente al cambio, su capacidad de adaptación.

  • Cambio mi motor de base de datos, de XXSql paso a NNSql.
    Debo cambiar mi clase Cliente.
  • Cambio la forma de crear la salida HTML
    Debo cambiar mi clase Cliente.
  • Agrego un reporte o modifico uno existente
    Debo cambiar mi clase Cliente.
  • Cambio la política para calcular la presencia en el mercado
    Debo cambiar mi clase Cliente.
Esto evidentemente es malo, existen distintos eventos cuya consecuencia es un cambio en la clase Cliente.
Si vemos un poco mas allá de nuestras narices notaremos que además esto implicará cambios en aquellos artefactos que recurren a la clase Cliente para resolver alguna colaboración.
Bueno el problema es que nuestra clase Cliente tiene muchas responsabilidades, incluso algunas que exceden claramente sus responsabilidades naturales, me refiero a las responsabilidades de Cliente en su contexto de negocio.
Se dice entonces que Cliente es poco cohesiva, sabe hacer más de lo que necesita, maneja temas en los cuales no es experto.

Posiblemente esa falta de cohesión nos lleve a otro problema, para mi es una regla que se cumple con rigor matemático,acoplamiento.

Un cambio en Cliente requerirá cambios en quienes consumen la clase Cliente, los cambios se propagan en nuestro diseño, el impacto de un cambio es alto, afecta a varios artefactos.

Pero, volvamos a nuestro principio de OOD, Object Oriented Design, Responsabilidad única.

Este principio ataca el problema descripto, su enunciado dice:

No debe existir más de una razón para cambiar una clase.

En nuestro escenario Cliente debería ser algo parecido a la siguiente figura:
Que sucede entonces con aquellos metodos que ya no existen en Cliente?, bueno será nuestro trabajo buscar quienes tienen la responsabilidad de resolver esas cuestiones. Lo importante aquí es que Cliente atienda sus responsabilidades directas, aquellas en las que es experto.

También es destacable que deberá relacionarse, u otras clases deberán relacionarse con ella, para resolver las cuestiones en las que Cliente no es el experto, pero requieren de su colaboración.

Eso nos lleva a otros principios que ayudarán a manejar las colaboraciones en forma desacoplada.



2. OCP - Open/Closed Principle (Principio Abierto / Cerrado)



Enunciado formal: "Entidades de Software (clases, módulos, funciones, etc) deberían ser abiertas para la extensión y cerradas para la modificación"


Traducido sería: el diseño que incluye nuestra clase, una vez concluida su implementación, no debería cambiar, porque si lo hace, podría generar un efecto en cadena sobre todas las clases que la usan. Pero se puede extender al permitir seguir agregando clases clientes con solo implementar la interfaz y sin tener que cambiar el código de implementación de la clase Impresora.


Abierto / cerrado 

Volvamos ahora a nuestra nueva clase Cliente, en el punto anterior mejoramos su cohesión eliminando algunos métodos, todos sabemos que alguien deberá encargarse entonces de asumir la responsabilidad de implementar esa funcionalidad.

Una posible solución para lo relacionado con la persistencia podría ser la siguiente:

Muy bien otra vez contamos con unas clases muy bonitas, las responsabilidades ahora parecen estar asignadas correctamente, y de hecho lo están.


Propongamos un cambio en el requerimiento y veamos.

Nuestra clase ClienteDB recurre a un susbsistemas de APIs específicas de XXSql. Ahora nos piden que debemos armar una implementación para que la base de datos sea ZZSql.


Nuevamente un cambio tiene impacto directo un cambio en el sistema de base de datos puede requerir un cambio en Ventas. Por caracter transitivo ventas ha quedado acoplado la API de XXSql.

Problema planteado, que nos dice el principio Abierto/Cerrado?
Los artefactos software deben ser abiertos para su extensión, pero cerrados ante una modificación.

En resumidas cuentas lo que quiere decir esto es que un cambio en el entorno de un artefacto no debería implicar un cambio en el artefacto. Esto no solo es válido para clases, se aplica también a métodos y cualquier otro artefacto software.

La aplicación del principio a nuestro problema podría ser agregar una interface o una clase abstracta que sea bien conocida por Ventas, ClienteDB debería implementar la interface o heredar de la clase abstracta.

















En el diagrama se puede apreciar la implementación para una cuestión más terrenal, mockobjects y test unitarios.


3. LSP - Liskov Substitution Principle (Principio de Sustitución de Liskov)



Enunciado formal: "Subtipos deben ser sustituibles por sus clases bases"





Vamos a aprovechar la capacidad de extensión que nos brindan los lenguajes OO, estamos frente a nuestra clase Cliente, con algunos cambios ya que los requerimientos del sistema han cambiado con el transcurso del tiempo y ahora un nuevo requerimiento nos exige considerar Clientes presenciales y Clientes virtuales.
Hacemos OOP, Object Oriented Poragramming, contamos con los beneficios de la herencia, heredemos de Cliente.
La funcionalidad nueva esta relacionada con la obtención de la autorización de una transacción comercial. 

























El experto en autorización requiere que el cliente se identifique, pero el ClienteVirtual implementa el metodo Identificarse() disparando una Exception. Su lógica de negocio no provee un mecanismo de identificación.
El método Obtener entonces deberá tener un tratamiento especial para ClienteVirtual.

Posiblemente el programador haga algo así:

if( typeof... )
//Tratamiento para ClienteVirtual
else
//Tratamiento para Cliente

El problema entonces es que CentroAutorización ya no puede tratar a ClienteVirtual como Cliente, debe conocer las características de la sub clase porque esta altera el comportamiento de la clase Cliente. ( Comportamiento, no implementación de comportamiento).

La solución en este caso es revisar eol diseño, posiblemente ClienteVirtual no este en la línea de herencia de Cliente, tal como pensamos en principio.

No atender estas cuestiones hace que nuestro diseño sea críptico, que los programadores no puedan confiar en la extensión de las clases y deban conocer el comportamiento de de cada una de ellas.

Bueno, para evitar esto debemos respetar el principio de sustitución. El mismo expresa:

Toda clase debe poder ser reemplazada por cualquiera de sus subclases

La aplicación de este principio garantiza de alguna manera el éxito en la aplicación de los principios de Responsabilidad única y Abierto / cerrado.

4. DIP - Dependency Inversion Principle (Principio de Inversión de Dependencias) 



Enunciado formal: "los clientes tienden a ser propietarios de las interfaces y aquellos que ofrecen los servicios las implementan" 


Inversión de dependencia



Modelamos, sea en papel, en UML, en nuestra mente, como sea, lo hacemos. Creamos artefactos, clases por lo general, y relacionamos esos artefactos unos con otros.



Cuando hacemos esto, relacionar artefactos, establecemos dependencia entre ellos. Un artefacto deberá conocer a otro. El artefacto B requiere un artefacto del tipo C y otro del tipo D.

Vamos a implementar un pequeño modulo de registro de eventos para tener un ejemplo concreto de como nos afectan las dependencias en un modelo.

Nuestro módulo de registro incluirá unas pocas clases, veamos un diagrama:


Lo primero que se aprecia es la asignación correcta de responsabilidades, hemos asimilados los principios OOD vistos hasta ahora. :)


Por supuesto siempre existe un contexto, ese contexto nos dará un marco para poder determinar problemas potenciales.
Si miramos el diagrama tenemos una violación potencial al principio Abierto / Cerrado.
Este modulo tiene como fin ser incluido en cualquier aplicación que desarrollemos y su objetivo es poder registrar información en algún dispositivo de salida.
Un ejemplo sería registrar errores en tiempo de ejecución, inicios de sesión por parte de los usuarios de un sistema, lo que creamos necesario.
Ese es mi contexto, puedo decir que mis mensajes serán muy uniformes, esos mensajes forman parte de mi dominio, son un concepto bien conocido, no existen grandes posibilidades de cambio en el corto plazo. Esto es una definición, no una estimación.
Por otra parte esa misma definición me habla de algún dispositivo de salida, allí la cosa es mas abierta, deberé de alguna manera estar preparado al cambio.
Volviendo al diagrama ahora puedo señalar algunas cuestiones:
  1. La clase LogHelper depende de Message
  2. La clase LogHelper depende de TextFile
El primer caso, teniendo en cuenta el contexto, la definición del negocio, esa dependencia no me preocupa. Alguien podría señalar que produce acoplamiento, en mi contexto no lo consideraré como tal. ( No hacer esto podría aportar complejidad innecesaria al modelo, una buena práctica es mantener la simplicidad. )

El segundo caso es más complejo, mi definición habla de algún dispositivo de salida, mi primer dispositivo es TextFile, cambiar o agregar algún otro dispositivo de salida implicará cambios profundos en LogHelper.

Este último problema va más allá del acoplamiento, nuestro modelo esta acoplado y además es rígido.

El principio de Inversión de dependencia nos ayuda a eliminar o acotar este tipo de problemas, que nos dice el principio?

Los módulos de nivel superior no deben depender de módulos de bajo nivel.
Ambos deben depender de abstracciones.
Los detalles deben depender de abstracciones y no lo contrario.
Veamos ahora algunos cambios en el diagrama que reflejen la aplicación del principio.

LogHelper ya no depende de TextFile, lo hace de OutPutProvider, la notación itálica nos indica que es una clase abstracta.
Hemos logrado que nuestro modulo de registro no sea tan rígido, será mucho más simple lograr su reutilización.

Quiero resaltar un concepto, en la definición del principio hablamos de Módulo de Nivel Superior.

Estos son menos propensos al cambio, son los que expresan nuestro negocio, representan el dominio del problema, su mención no es casual.

En cada Nivel atenderemos un Negocio determinado, aplicar Inversión de dependencia implica conocer los límites, el borde de cada nivel.

5. ISP - Interface Segregation Principle (Principio de Segregación de Interfaces)

Enunciado formal: "Clientes no deberían depender de métodos que no utilizan"



Existen situaciones en las que una misma clase será consumida por distintos clientes, agentes que solo necesitan conocer un conjunto acotado de responsabilidades de esa clase. Sin embargo esas clases siguen representando un concepto único en el modelo.

Es una situación ambigua, la clase sigue siendo cohesiva y quienes la consumen manejan un concepto acotado de la misma en el dominio.

Supongamos una clase Cliente, nuestra clase es consumida por agentes que están interesados en distintos aspectos:
Estos atributos parecen estar directamente vinculados con las responsabilidades de Cliente, no hemos violado ningún principio, nuestra clase es cohesiva.
En estos términos veamos ahora como afecta esto a los artefactos consumidores de Cliente.
  1. Despacho
    Solo necesita conocer el Domicilio
  2. BuzonEletronico
    Solo necesita cono cer la dirección electrónica.
Si vamos un poco mas allá nos damos cuenta también que estos artefactos que consumen la clase Cliente manejan conceptos que parciales respecto a la clase que consumen.
Un cambio en Cliente, implica cambios profundos nuevamente, la reutilización de Despacho y BuzonElectronico se ve seriamente limitada, y la lista continúa....
Algo entonces esta fuera de lugar, veamos que nos dice el principio de segregación de interface:
Los clientes no deben ser forzados a depender de interfaces que no utilizan.
Apliquemos el principio, creemos interfaces acotadas que serán consumidas por BuzonElectronico y por Despacho, Cliente ahora implementará esas interfaces.
Tenemos ahora un modelo mas elegante, mas cohesivo, poco acoplado.
Conclusiones:
Los principios de diseño nos permiten adelantarnos a los problemas, son conceptos que debemos manejar en forma natural, debemos integrarlos a nuestra forma de pensar al modelar o implementar aplicaciones orientadas a objeto.
La cuestión no termina aquí, es el comienzo, sobre estos principios se construyen muchos conceptos teóricos mas avanzados, se construyen patrones, etc.




la "Ley de Deméter": Habla sólo con tus amigos inmediatos. Traduciendo el enunciado formal
Un método M de un objeto O solo debería invocar métodos:
  • suyos
  • de sus parámetros
  • objetos que cree o instancie
  • objetos miembros de la clase (atributos)
Así se consigue que la dependencia de la estructura entre las clases no vaya arrastrando más de un nivel. Eso si, provoca algún nivel de indirección más.

el principio del “punto de control individual”.

 el cambio puede realizarse en un único punto del código. Nos limitamos a modificar el procedimiento:
public class StandardOutReporter {
public static void report (String msg) {
System.out.println (msg + “a” + nueva Fecha());
}
}
Matthias Felleisen llama a esto el principio del “punto de control individual”. En este caso, el mecanismo nos resulta familiar: ya que se denominó abstracción por parametrización, porque cada llamada al procedimiento:
StandardOutReporter.report (“Comenzando descarga”);
es una instanciación de la descripción genérica, con el parámetro msg ligado a un valor especial.


miércoles, 30 de junio de 2010

crear Animaciones para la web

Sin más, a continuación les dejo la lista de enlaces de páginas que permiten crear GIFs animados:

Lista de enlaces:

sábado, 5 de junio de 2010

jajaja a apple le paso como el platano: flash se ejecuta en ipad

Según se ha venido informando, Apple ha
desterrado el formato Flash de sus unidades móviles. El presidente de
Apple, Steve Jobs, ha declarado que Flash es un formato obsoleto y
superado, que después de haber cumplido su cometido histórico debe ser
relevado por soluciones como HTML5.




Como es natural, Adobe
ha protestado insistentemente ante la decisión de Apple de excluir a
Flash de los populares productos iPad e iPhone. Incluso numerosos
desarrolladores y usuarios han sentido descontento por la decisión de
Apple.

Ante tal situación , la empresa RevShock, dedicada a la
publicidad móvil, ha creado una nueva herramienta que permite ejecutar
flash en los dispositivos portátiles de Apple. La herramienta es
denominada Smokescreen
y utiliza JavaScript y HTML5. En su blog,
Simon Willison, de RevShock, explica el funcionamiento de Smokescreen.

y este  no es  le unico  el MIT  ( intituto tecnologico de  massachusets )  desarrollo  como  un trabajo de  investigacion  un reproductor de  flash  tambien totalmente en java script...   eso es  trabajar por la investigacion

miércoles, 26 de mayo de 2010

programacion en jsp



 los estándares de programación para clases Java y páginas
JSP, porque generalmente se parte programando sin ninguna estructura, y
esto desencadena en que en una Empresa se tienen distintos “estilos” de
programación, lo cual hace más difícil entender el programa realizado
por otra persona.



Los estándares están definidos por Sun en los
siguientes lugares:



http://java.sun.com/docs/codeconv/


http://java.sun.com/developer/technicalArticles/javaserverpages/code_convention/



Nosotros vamos a presentar un resumen de estos
estándares mediante una plantilla base de los 2 módulos básicos de
programación, un clase Java, y un página JSP, estas plantillas pueden
servir a un departamento de Control de Calidad para verificar que los
programas se ciñen al estándar Java, pero la mejor forma de seguir estos
estándares es utilizar un IDE (ambiente de desarrollo) como Eclipse, o
usar verificadores de código automático.



Otra cosa que muestran estas plantillas es la forma
de comentar los fuentes, para que se pueda obtener el JavaDoc
correspondiente (documentación automática de Java).



Plantilla de Codificación Java.



Esta plantilla Java se puede extender a otras
clases como Servlets.



Una clase Java tiene el siguiente orden:


  1. Comentarios de Inicio
  2. Definición Package
  3. Declaraciones de Import
  4. Declaraciones de la Clase

4.1. Comentario
Documentación de la Clase


4.2. Estamento class


4.3. Atributos o
Variables Estaticas


4.3.1.
public


4.3.2.
protected


4.3.3.
private


4.4.
Atributos


4.4.1.
public


4.4.2.
protected


4.4.3.
private


4.5.
Constructores


4.6.
Metodos



La siguiente plantilla resume los principales
estándares de codificación propuestos por Sun.



/*


*
@(#)Plantilla.java version 1.01 2007/01/01


* Copyright (c) 2007 SOA agenda.


*/


package com.soaagenda.ejemplos;


import com.soaagenda.librerias.*;
//import de librerias y clases a utilizar



/**


* Descripción de la Clase,
ejemplo: Plantilla que muestra


* principales estándares
de codificación.


*


* @version 1.01 01 Ene 2007


* @author
SOA Team


*/


public class Plantilla extends ClasePadre {


/* Comentario de
implementacion, ejemplo: Esta clase no tiene funcionalidades . */



/** atributo1
comentario documentacion atributo


* puede
ser de mas de una linea


*/


public static int
atributo1; //comentario linea: primero las variables estaticas,


//en orden 1.-public,
2.-protected, 3.-private



/** atributo2
comentario documentacion */


public Integer
atributo2; //luego var de instancia, mismo orden 1.-public,
2.-protected, 3.-private



/** atributo3
comentario documentacion */


protected Integer
atributo3;



/**


* Descripción para el
constructor.


*/


public Plantilla() {


// …implementacion …


}





/**


* Descripción de un
metodo.


* @param par1
descripcion primer parametro


* @param par2
descripcion segundo parametro


* @return descripcion
de salida (return) del metodo, en caso que no es void


*/


public
String hacerAlgo(Integer par1, String par2) {


int entero = 0; //una declaración de variable
por linea y al inicio del {bloque}



/* A continuacion
mostraremos ejemplos de la identación y formato de las distintas
sentencias Java*/


if (entero == 0) {


int entero2 =
1; //una declaración de variable por linea y al inicio del {bloque}


} else if (entero == 1) {


entero++; // solo un
estamento por linea


} else {


entero–;


}



for
(int i=0; i < 5; i++){


entero=i;


}



while (entero >
0){


entero–;


}



do {


entero++;


}
while (entero < 10);



switch
(entero) {


case
0:


entero++;


break;


case
2:


entero–;


break;


default:


entero=1;


break;


}



try {


entero=2/entero;


} catch (Exception
e) {


System.out.println(”error
división”);


}
finally {


entero=1;


}



return (”Ok”);


}



}



Buenas Practicas Básicas de Programación Java.



  • Acceso a Instancia y Variables de
    Clase
    : Evitar el uso de variable publicas.


  • Asignación Variables: Evitar
    asignar mas de una variable en un misma sentencia.
    • a = b = c +1; //evitar esto!!
    • if (c++ == d++) { //evitar
      esto!!



  • Uso de Constantes: Usar
    siempre cantantes para valores fijos.
    • if (c == 1) { //evitar esto!!
    • if ( c == ESTADO_ACTIVO ) {
      //asi si!!



  • Uso Paréntesis: Usar explícitamente para definir precedencia, para
    mejor entendimiento del programador.

    • if ( a = = b && c = =
      d || e == f ) { //evitar esto!!
    • if ( ( (a = = b)
      &&
      (c = = d) ) || (e = = f) ) {
      //así si!, no hay forma de entender precedencia.



  • Valores de Retorno: Evitar “return” de condiciones simples.
    • if (booleanExpression) {
      //evitar esto!!


return
true;




        
}else{


                         

return false;



          }




  • return booleanExpression;
    //esto si!!
  • if (condition) { //evitar
    esto!!

return x;


} else {


return Y;


}



  • return ( (condicion)
    ? x : y); //esto si!!


  • Expresiones
    condicionales ‘?’:
    La condición
    debería ir siempre entre paréntesis.

    • x >=0 ? x : -x; //evitar
      esto!!
    • ( x >=0 ) ? x : -x; //así
      si!!



  • Clases como parámetros
    de entrada:
    de forma de
    reducir la cantidad de parámetros de entrada de un método, de ser
    orientado a objetos, y hacer mas estable el método, por ejemplo para un
    método “actualizarCliente()” puede que ahora solo necesitemos
    actualizar 2 variables “nombre” y “email”, y solo esas pasamos como
    parametros, pero si mañana necesitamos una tercera, debemos
    cambiar todas las llamadas al método del sistema, por otro lado si
    pasamos una clase Cliente, solo se cambia la clase internamente.

    • public void actualizaCliente(
      String rut, String nombre, String email) //evitar esto!!
    • public void actualizaCliente(
      ClaseCliente cliente) // esto si!! es Orientado Objetos



Plantilla de Codificación JSP.



El orden dentro de una pagina JSP es:


  1. Comentarios de Inicio
  2. Directivas JSP
  3. Directivas Librerías de Tags
  4. Declaraciones JSP
  5. HTML y tags JSP


La siguiente plantilla muestra los principales
estándares JSP, esta plantilla se centra en los estándares JSP, y no
incluye estándares HTML.





<%–


- Author:
SOA Team


- Date: 28
Marzo 2007


-


- Derechos Reservados Soa
Agenda.


- @(#)


- Description: Estos son
los “Comentarios de Inicio” de la Plantilla Ejemplo Estandares JSP.


–%>



<%– 2.-Directivas JSP
–%>


<%@ page session=”true”


import=”java.util.*”


errorPage=”../principal/paginaError.jsp”


%>



<%– 3.-Directivas Librerias Tags
–%>


<%@ taglib
uri=”/WEB-INF/jsp/libreriatags.tld” prefix=”tags” %> <%– Aqui van
las librerias de tags –%>



<%– 4.-Declaraciones JSP: instancias
variables, y metodos de la JSP
–%>


<%


private
int entero;



public int transformaEntero(float
Numero) {



//implementaciòn


}


%>



<%– 5.-HTML y tags JSP –%>


<html>


<head>


<title>Titulo
de la Pagina que aparece en el Browser</title>


</head>


<body>


<jsp:useBean
id=”cliente” class=”com.SOAagenda.segurosvida.Cliente” /> <%–
declaracion de un javabeans –%>


<h1>


Rut:


<tagsSAgenda:formateaRut
value=”${cliente.getRut()}” /> <%– un tag que usa al beans –%>


</h1>


<hr
/>






<table
border=”1″ cellpadding=”5″>


<%– Un if en JSP y ejemplo identación
–%>



<% if (entero
== 0) { %>




<tr>




<td>Nombre:</td>




<td><%=
cliente.getNombre()%></td> <%– expresion explicita –
%>



</tr>



<%
} %>



<tr>



<td>Apellidos:</td>


<%– expresion Javabeasn muestra –%>



<td><jsp:getProperty
name=”cliente” property=”apellidos”/></td>



</tr>


</table>


<%– incluir otra pagina –%>


<%@ include
file=”../principales/piePagina.jsp” %>


</body>


</html>




Buenas Practicas de Programación JSP.



  • Solo Lógica de Presentación:
    Una pagina JSP debe evitar tener lógica de negocio, y lo que
    “nunca” debería tener es lógica de acceso a base de datos, se debe
    tener ojalá solo lógica de presentación, esto es, solo instrucciones de
    creacion de JavaBeans, instrucciones para mostrar sus atributos
    (getters) y uso de funciones de presentación (como
    transformaciones), también puede incluir cualquier estamento
    condicional (if, else, while, do while, switch).


· Una pagina jsp debe evitar tener definición de
métodos:



public
int procesarPago() { //esto NO!!



//implementación



}




· Debe evitarse tener llamadas a
método de negocio:


cliente.calculaSaldo();//esto
NO!!




Si puede
tener llamadas a getters de un bean:



cliente.getSaldo();
//esto SI!!.



· Debe evitarse tener grandes porciones de código
Java, que no tengan que ver con lógica de presentación , por ejemplo si
dentro de los tags jsp”<% %>” hay sobre 10 líneas, este código ya
es “sospechoso” de incluir lógica de negocio, lo mas probable es que
dicha lógica deba ir dentro de un Servlet, o clase Java:


<%


//…mas
de 10 líneas entre estos tags JSP , es Sospechoso!!



         %>








viernes, 21 de mayo de 2010

3 herramientas para diseñar webs



Clean CSS
Un optimizador
de css que ademas te formatea el codigo adecuadamente

CSS Grid
Calculator

Esta aplicacion te permitira hacer
rapidamente layouts calculando tamaños y posiciones de los bloques
(divs)

TypeTester
Con
ella podras hacer un preview para decidir que tipo de fuente queda mejor
en tu diseño
Probando
varios tipos de fuentes al tiempo con Typetester