viernes, 30 de julio de 2010
rehacer una aplicación desde 0
programador Solitario: Macho Driven Development
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
- SRP - Single Responsibility Principle (Principio de Responsabilidad Única)
- OCP - Open/Closed Principle (Principio Abierto / Cerrado)
- LSP - Liskov Substitution Principle (Principio de Sustitución de Liskov)
- DIP - Dependency Inversion Principle (Principio de Inversión de Dependencias)
- ISP - Interface Segregation Principle (Principio de Segregación de Interfaces)
http://en.wikipedia.org/wiki
http://en.wikipedia.org/wiki
http://en.wikipedia.org/wiki
1. SRP - Single Responsibility Principle (Principio de Responsabilidad Única)
- 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.
Posiblemente esa falta de cohesión nos lleve a otro problema, para mi es una regla que se cumple con rigor matemático,acoplamiento.
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.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
Una posible solución para lo relacionado con la persistencia podría ser la siguiente:

Propongamos un cambio en el requerimiento y veamos.
Problema planteado, que nos dice el principio Abierto/Cerrado?
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.

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:
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. :)- La clase LogHelper depende de Message
- La clase LogHelper depende de TextFile
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?
Ambos deben depender de abstracciones.
LogHelper ya no depende de TextFile, lo hace de OutPutProvider, la notación itálica nos indica que es una clase abstracta.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:

- Despacho
Solo necesita conocer el Domicilio - BuzonEletronico
Solo necesita cono cer la dirección electrónica.
Tenemos ahora un modelo mas elegante, mas cohesivo, poco acoplado.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: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.
- suyos
- de sus parámetros
- objetos que cree o instancie
- objetos miembros de la clase (atributos)
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:
- GIF Make
- Gickr
- Gifup
- Gifninja
- Gifworks
- http://www.3dtextmaker.com/cgi-bin/3dtext.pl *
- http://www.gifss.com/texto3d/
- http://wigflip.com/screedbot/en/# **
- http://textanim.com/?lg=sp#text *
- http://cooltext.com/ **
- http://glowtxt.com/ *
- http://dabuttonfactory.com/ *
- http://nombresanimados.net
- PAGINAS PARA CREAR BANNER
AdDesigner - Diseño y descarga de banners para utilizar en tu sitio web.
Banner 4 U - Creacion de banners y botones.
Bannerite - Creacion de banners comerciales en 24 horas.
Creación de Banner - Creamos Banner en Flash, gif o Jpg para Campañas Publicitarias
Mediabuilder - Crea gratuitamente un banner con animación de forma instantanea gracias a esta aplicacion de Animation Factory's.
Pincel Digital - Sitio dedicado a la creacion de logos y banner en forma gratuita y mucho mas...
QuickBanner - Creacion online y gratuita de banners en varios tamaños y con diferentes tematicas.
sábado, 5 de junio de 2010
jajaja a apple le paso como el platano: flash se ejecuta en ipad
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:
- Comentarios de Inicio
- Definición Package
- Declaraciones de Import
- 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!!
- if (c == 1) { //evitar esto!!
- 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.
- if ( a = = b && c = =
- Valores de Retorno: Evitar “return” de condiciones simples.
- if (booleanExpression) {
//evitar esto!!
- if (booleanExpression) {
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!!
- x >=0 ? x : -x; //evitar
- 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
- public void actualizaCliente(
Plantilla de Codificación JSP.
El orden dentro de una pagina JSP es:
- Comentarios de Inicio
- Directivas JSP
- Directivas Librerías de Tags
- Declaraciones JSP
- 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

