martes 11 de agosto de 2009

Los 10 mandamientos para crear buen código

Una cadena de enlaces... encontré éste link desde la página de Angel "Java" López; quien a su vez referencia la página donde encontró el original: making good software.

El artículo, la traducción, me parecen tan buenos, y los comentarios agregados tan puntuales y prácticos, que cometeré el pecado de copiarlo textualmente:

Los 10 mandamientos para crear buen código
(10 commandments for creating good code)

1. DRY - Don't repeat yourself – No se repita
DRY es usualmente el principio más fácil de entender, pero el más difícil de aplicar. Significa que cuando encontramos código similar en uno o más lugares, deberíamos abstraerlos en un nuevo método y cambiar los anteriores fragmentos de código para que llamen al nuevo método con los parámetros apropiados.
DRY es posiblemente el principio de codificación más universal, yo nunca he encontrado un desarrollador que argumentara que repetir código es bueno, pero, he encontrado desarrolladores que olvidan este principio cuando codifican pruebas unitarias, como ejemplo: imaginen que han cambiando la interface de una clase que tiene montones de pruebas unitarias, si no han usando DRY, tendrán que cambiar a mano las llamadas a esa interface para cada caso de prueba.


"Pienso que podemos repetirnos, siempre y cuando tengamos planeado el refactoreo del código. Si siguen Test-Driven Development, no hay que hacer hincapié en este principio siempre, sino tenerlo presente en la etapa de refactoreo. A veces, no tenemos claro cuál es la implementación que necesitamos abstraer, hasta que tengamos varios casos resueltos."

2. Write short methods – Escriba métodos cortos
Hay tres buenas razones para escribir métodos cortos:
i. El código será más fácil de leer
ii. El código será más fácil de reusar (métodos cortos tienden a tener bajo acoplamiento).
iii. Él código será más fácil de probar.


"Sí, siempre trato de escribir código con métodos cortos. Pero, de nuevo, se puede saltear esto, siempre que luego tengamos planeado el refactoreo (y no la semana que viene, sino tenerlo con frecuencia, y temprano, ver mandamiento 7)"

3. Use good names for your classes, methods and variables – Use buenos nombres para sus clases, métodos y variables
No hay nada más lindo que ver el código de otro programador y no necesitar leer la documentación porque los nombres de las clases y los métodos nos dicen todo, así, que tome este camino y haga la vida más fácil para todos, gaste siempre unos pocos segundos antes de nombrar cualquier elemento en el código.


"Recuerdo cuando los linkeditores que usaba no permitian nombres públicos con más de 7 caracteres. O cuando trabajaba con un intérprete BASIC que solamente se fijaba en las dos primeras letras de cada variable, para ubicar su valor. Desde que las herramientas modernas nos han liberado de esas restricciones, no dudo en usar nombres descriptivos. Ken Thompson siempre se lamentó de haber nombrado creat() a una función del Unix/C original"

4. Assign the right responsability to each class – Asigne la responsabilidad correcta a cada clase
Una clase, una responsabilidad: esto sonará familiar a quienes conozcan los principios SOLID, pero no hay cualquier responsabilidad, sino la correcta, así que si tenemos una clase Customer, no le asignaremos a ella la responsabilidad de crear una nueva acción de ventas, apenas le asignaremos la responsabilidad de manejar todos los datos relacionados con un cliente.


"Creo que esto viene aún antes de refactoreo, pero bueno, si no lo consiguen de primera, pueden solucionarlo en la etapa de revisión. Pero tanto si hace diseño antes, como si van descubriendo la funcionalidad necesaria con TDD, veamos de respetar este mandamiento"

5. Keep your code organized – Mantenga su código organizado
Esta organización está a dos niveles:
- Organización física: Cualquiera sea la estructura que esté usando, paquetes, espacios de nombres, carpetas… Organice sus clases de tal manera que sea fácil e intuitivo encontrar dónde está el código.
- Organización lógica: Cualquier cosa que se relacione lógicamente con otras, deberá acceder a los demás miembros del grupo, pero si pertenece a otro estructura lógica, tendrá que acceder a ellos usando una interface. Estos grupos lógicos son comúnmente implementados como capas, servicios…


"Es necesario. Y revela una disciplina de organización, que hace más fácil nuestro trabajo y que otros trabajen con nosotros"

6. Create lots of unit test - Cree montones de pruebas unitarias
Mayor cantidad de pruebas, mejor, ellas son su red de seguridad para todos los cambios que habrá que realizar en el código en el futuro.


"Yo mencionaría pruebas funcionales, además de unitarias. Pero tiene que haber pruebas. Si no siguieron TDD, sigan TAD (Test After Development), pero no pueden ir por la vida mostrando código sin pruebas asociadas. Recuerden: código “legacy” no es código COBOL, es código en el último lenguaje inventado, pero sin pruebas"

7. Refactor often and sooner – Refactoree con frecuencia y temprano
El desarrollo de software es un continuous discovery process (proceso continuo de descubrimiento), para mantenernos al día con buen código que cubrar los nuevos o cambiantes requerimientos es esencial refactor the code as we go (refactorear el código mientras lo desarrollamos). Como esta es una tarea riesgosa hay 2 precondiciones principales para evitar introducir nuevos errores en el sistema.

i. Tener montones de pruebas unitarias
ii. Hacer pequeños pasos de refactoreo por vez. En el desarrollo de software hay pocas cosas más desconcertantes que comenzar el refactoreo de 2000 líneas de código y encontrarse que después de 3 horas de trabajo es necesario volver atrás a la versión original, porque ahora nada funciona y perdimos la pista de cuál cambio está causando el problema.

"Si siguieron TDD, este es un mandamiento que se cumple solo. Sería igual bueno entrenarnos para no tener que hacer mucho refactoreo, hacer las cosas bien desde el principio. Pero no siempre es posible. Veo que con entrenamiento se puede ir mejorando en esto. Es una síntoma de avace, el ir cumpliendo con los principios casi desde el principio"

8. Comments are evil – Los comentarios son malignos
Este es uno un poco controversial, a muchos de nosotros nos enseñaron que los comentarios son buenos, y actualmente es mejor tener un comentario en una pieza obscura de código que solamente el código mismo. Lo que este punto indica es que aún mejor que tener un comentario para una pieza obscura de código es no tener ese código para nada, y refactorearlo hasta que sea una bonita y leíble pieza de código. Por favor, lean este otro post para una mejor explicación de por qué 'los comentarios son malignos'.

"Los comentarios que deberían ser admitidos son los que ayudan a alguna herramienta de documentación. O los que tienen una explicación del uso de la función, con un ejemplo (vean código Smalltalk, como ejemplo)"

9. Code to an interface, not to an implementation – Codificar contra la interface, no contra la implementación
Esta es una clásica, codificar contra la interface nos liberará de los detalles de implementación, solamente definimos un contrato y llamamos las operaciones definidas en el contrato, esperando que la implementación actual será pasada a nuestro código o se decida en ejecución.


"Pienso que esto es sólo necesario, llegado el caso. Podemos codificar contra lo concreto, como primeros pasos, y luego, descubrir la interface o interfaces que estamos usando. De nuevo, si usamos TDD (Test-Driven Development), hay algunos de los mandamientos que se cumplen solos desde el principio, y otros, que se pueden relajar, porque luego viene el refactoreo. Este es uno de esos casos que pueden relajarse al principio"

10. Have code reviews – Tener revisiones de código
Todos cometemos errores, y no hay nada mejor que preguntar a otra persona para que nos ayude a tener una revisión rápida e informal de nuestro código. Para hacer estas revisiones, es mejor no esperar hasta que el código esté completo, es mejor preguntar por revisiones en cuanto alguna parte importante del código se haya completado o cuando hayas pasado unos días desde la última revisión.


"Veo que es poco frecuente encontrarse con revisiones de código. Es algo que debería hacerse. Vean cómo Google implementó un sistema de revisión de código distribuido, para que no haga falta reuniones previas y coordinadas para hacer esta actividad:
Mondrian Code Review On The Web (...)"

Muy buen post, muy de mi agrado. Agradezco y espero no se moleste el señor Angel Lopez, por el "retwitteo" copy/paste que acabó de hacer.

Fuente: Angel "Java" Lopez - NET, Java, PHP y Desarrollo de Software
Continuar leyendo...

miércoles 28 de enero de 2009

El primer Bug informático

Un clásico en la historia de la computación:
"First actual case of bug being found"

La palabra "bug" se usa para denominar a los errores en los programas, y que dicho término se debía a que, alguna vez, se encontró una polilla en el interior de una computadora, lo cual provocó un error en el funcionamiento de la misma.

La fotografía es de esta polilla, sobre las notas del ingeniero que la descubrió.

Esto ocurrió en el año de 1945 y la polilla estaba entre los contactos de un relé de una computadora Mark II. El descubrimiento se debió a Grace Murray Hopper, quien era la encargada de la operación de la computadora.

Fuente: Tecnoculto.

Acá encontré información más detallada al respecto (en inglés): waterholes, donde sostiene que ocurrió en agosto de 1947, y no en 1945 como más arriba se detalla:
"Things were going badly; there was something wrong in one of the circuits of the long glass-enclosed computer.
Finally, someone located the trouble spot and, using ordinary tweezers, removed the problem, a two-inch moth. From then on, when anything went wrong with a computer, we said it had bugs in it."

Las cosas empezaron a ir mal; había una falla en los circuitos de computadora.
Finalmente, alguien localizó el problema y, usando unas pinzas, removió el problema: Una polilla de 2 pulgadas. Desde ese momento, cuando algo empieza a ir mal con una computadora, decimos que tiene un bug


Adicionalmente, en jameshuggins sostienen que (también en inglés):
La polilla fue encontrada en el relay #70, panel F, el 9 de septiembre de 1947.
(Ya no agosto, como está en waterholes, ni en 1945 como está en tecnoculto)

Bonus: software bug, en wikipedia.

Claro, las palabras bug, debugging, etc, aunque son mundialmente conocidas... solamente mantienen el contexto exacto en su idioma original: el english.
Continuar leyendo...

sábado 27 de diciembre de 2008

Abrir carpetas en una sola ventana

Por eliminar un virus, jugar con el regedit, y jugar con:
Herramientas → Opciones de Carpeta → Tipos de Archivos ;
Fregué el modo de abrir carpetas en Windows; a pesar de tener la configuración correcta: "Abrir las carpetas en la misma ventana" en "Examinar carpetas";
Igual, cada vez que abría una carpeta contenida en otra, las habría en distintas ventanas, y se me acumulaban ventanas abiertas innecesarias. (Ver imagen)


Configuración normal:


Entonces, en vista de que de la forma anterior no me funcionaba, recurrí a hacer los siguientes pasos para solucionarlo:

1. Abrir el editor de registros (regedit.exe)

* Se puede acceder desde: Inicio→Ejecutar... ; y escribiendo "regedit"

2. Al acceder al registro, expandir las carpetas así:
HKEY_CLASSES_ROOT → Directory → shell


3. En el bloque derecho, dale doble clic al elemento "(Predeterminado)", y escribe el valor "none" (sin comillas).
Quedando como en la 3º imagen.

voilà.

fuente: noticias3d.
Continuar leyendo...

domingo 21 de diciembre de 2008

Validación de Windows (Windows Genuine Advantage)

De la noche a la mañana me apareció el mensaje:


Podría ser víctima de una falsificación de software.
Esta copia de Windows no ha superado el proceso de validación de Windows original.

Un mensaje de WGA (Windows Genuine Advantage) el cual -valga la redundancia- verifica que la versión del windows que utilizas, sea original.

Y ese mensaje me sorprendió muchísimo, pues yo pagué $2 por el CD que me vendieron de windows XP (nótese el sarcasmo :)

En fin, la solución no fue tan difícil de hallar (felizmente)

Primero, es necesario descargar éste archivo:
http://rapidshare.com/files/50794944/RemoveWGA.rar

RemoveWGA, una herramienta que acaba con esa limitación, puesto que respeta la
función de validación de Microsoft Genuine Advantage Notificacions, pero elimina la fastidiosa función notificadora, evitando que vuelva a ejecutarse.
El programa es sencillo, y trabaja en Windows XP - SP1 y SP2.
Es un ejecutable en un comprimido .rar.

El segundo archivo:
http://rapidshare.com/files/50150298/GENUINISADOR.zip

Es un archivo .reg en un comprimido .zip, para editar el registro, validando tu windows "original" que microsoft no logró reconocer.

Como apunte adicional, si no quieren descargar ese archivo, pueden copiar el texto en bloc de notas y guardar el archivo con la extensión .reg. El contenido debe ser el siguiente:
Windows Registry Editor Version 5.00

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion\WPAEvents]

"OOBETimer"=hex:ff,d5,71,d6,8b,6a,8d,6f,d5,33,93,fd
"LastWPAEventLogged"=hex:d5,07,05,00,06,00,07,00,0f,00,38,00,24,00,fd,02

[HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows NT\CurrentVersion]
"CurrentBuild"="1.511.1 () (Obsolete data - do not use)"
"InstallDate"=dword:427cdd95
"ProductId"="69831-640-1780577-45389"
"DigitalProductId"=hex:a4,00,00,00,03,00,00,00,36,39,38,33,31,2d,36,34,30,2d,\
31,37,38,30,35,37,37,2d,34,35,33,38,39,00,5a,00,00,00,41,32,32,2d,30,30,30,\
30,31,00,00,00,00,00,00,00,00,0d,04,89,b2,15,1b,c4,ee,62,4f,e6,64,6f,01,00,\
00,00,00,00,27,ed,85,43,a2,20,01,00,00,00,00,00,00,00,00,00,00,00,00,00,00,\
00,00,00,00,00,00,00,00,00,00,00,31,34,35,30,34,00,00,00,00,00,00,00,ce,0e,\
00,00,12,42,15,a0,00,08,00,00,87,01,00,00,00,00,00,00,00,00,00,00,00,00,00,\
00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,94,a2,b3,ac
"LicenseInfo"=hex:9e,bf,09,d0,3a,76,a5,27,bb,f2,da,88,58,ce,58,e9,05,6b,0b,82,\
c3,74,ab,42,0d,fb,ee,c3,ea,57,d0,9d,67,a5,3d,6e,42,0d,60,c0,1a,70,24,46,16,\
0a,0a,ce,0d,b8,27,4a,46,53,f3,17
(Fin del archivo)

Fuente: upseros.
Continuar leyendo...

jueves 4 de diciembre de 2008

Algoritmo de Booth en Java

El algoritmo de Booth, es un método para multiplicar en binario.

Este algoritmo es enseñado en cursos como "Introducción a la Arquitectura de computadores" o "Arquitectura y Organización de computadores".

Para entenderlo (en mis épocas no me lo enseñaron... si es que existía) acudí a google, que me dirigió a emezeta, donde lo programé mientras recién lo aprendía.

Para la implementación, creé 3 clases:
  1. OperacionesBinarias
  2. AlgoritmoBooth
  3. IU_Principal


(Explicadas detalladamente en un post cada una... visitar el link para mayor información)

Primera Imagen: Interfaz de Usuario del programa

Ejemplo de operación 1: 250 x -40
ejemplo de operación 2: 12 x 16
Continuar leyendo...

viernes 31 de octubre de 2008

Humor Nerd / Geek I

Algo de humor en el blog, para mantenerlo con contenido, y no desestresar las mentes sobre-cargadas de tanto estudio:
  1. En una fiesta de funciones están bailando seno de x con coseno de x.
    Seno de x se da cuenta de que e^x está sentado solo a un costado de la pista. Entonces se le acerca a y le dice: "¡Ven a bailar, INTÉGRATE!".
    - No, para qué?. ¡Da igual!
  2. P: ¿Qué es un oso polar?
    R: Un oso rectangular, después de un cambio de coordenadas.
  3. P: ¿Qué le dijo un vector a otro?
    R: "Oye, tienes un momento?".
  4. P: ¿Qué es un "niño complejo"?
    R: Uno con la madre real y el padre imaginario.
  5. Dios es real, hasta ser declarado entero.



Lo he recibido por correo cientos de veces, pero esta vez, lo encontré y me animé a copiarlo de aquí:
Fuente: tecnoculto.
Continuar leyendo...