A veces no es necesario usar lenguajes esotéricos para crear un código que nadie sea capaz de entender a simple vista... de hecho, lo hacemos muy frecuentemente en nuestro día a día 😉. Basta nombrar inapropiadamente unas cuantas variables, acoplar y desacoplar sin criterio o usar una mala indentación para que nuestro código ya venga "ofuscado" de serie, sin usar ninguna herramienta externa.
Sin embargo hay otro nivel de maldad, que consiste en el abuso de la flexibilidad de sintaxis en algunos lenguajes para construir expresiones diabólicamente enrevesadas. Hace poco me topé por casualidad con un buen ejemplo de ello en JavaScript, un código que, a simple vista, es imposible de entender:
// ¿Qué retorna esta expresión?
(_$=($,_=[]+[])=>$?_$($>>+!![],($&+!![])+_):_)(255)
Obviamente, podemos copiarla y pegarla en la consola de nuestro navegador, y rápidamente veremos de qué se trata. Sin embargo, me pareció interesante dedicar unos minutos a intentar comprender el código, así que vamos a ir troceando y refactorizando esta expresión ilegible hasta convertirla en algo que, al menos, podamos digerir.
Publicado por José M. Aguilar a las 8:05 a. m.
Etiquetas: buenas prácticas, conceptos, javascript
Pero aunque indudablemente los tipos booleanos o flags son una fórmula muy compacta para almacenar información, el mundo suele ser mucho más complejo y estas simplificaciones son a menudo origen de problemas y trampas para nuestro yo del futuro.
En este post vamos a ver algunos escenarios en los que este tipo de dato puede llegar a complicarnos la vida.
Como probablemente ya sabréis, NDepend es una de esas herramientas que están ahí de siempre, ayudando a desarrolladores y arquitectos a mejorar la calidad de nuestro software gracias a sus potentes y flexibles herramientas de análisis de proyectos.
Hace tiempo ya echamos por aquí un vistazo, pero creo que es interesante darle otra vuelta y refrescar conocimientos.
Publicado por José M. Aguilar a las 8:05 a. m.
Etiquetas: arquitectura, buenas prácticas, calidad, herramientas
Por ejemplo, echando un vistazo al siguiente controlador podemos ver claramente una violación del Principio de Responsabilidad Única (SRP) en un controlador que conoce demasiados detalles sobre la forma de proceder al registrar un pedido:
public class OrderController: Controller
{
private readonly IOrderServices _orderServices;
[...] // Other private members
public OrderController(IOrderServices orderServices, IUserServices userServices,
IMailingService mailingServices, ISmsServices smsServices,
IPdfGenerator pdfGenerator, IMapper mapper
)
{
_orderServices = orderServices;
_userServices = userServices;
[...] // Other assignments...
}
[HttpPost]
public Task<IActionResult> Submit(OrderViewModel orderViewModel)
{
if(!ModelState.IsValid)
{
return View(orderViewModel);
}
var orderDto = _mapper.Map<OrderDto>(orderViewModel);
var orderResult = await _orderServices.AddAsync(orderDto);
if(!orderResult.Success)
{
return RedirecToAction("OrderError", new { error = orderResult.Error }));
}
var userPreferences = await _userServices.GetNotificationPreferencesAsync(CurrentUserId);
var pdfUrl = await _pdfGenerator.GenerateOrderAsync(orderResult.Details);
if(userPreferences.NotificationMode == NotificationMode.Sms)
{
await _smsServices.NotifyNewOrderAsync(orderResult.Details, pdfUrl);
}
else
{
await _mailingServices.NotifyNewOrderAsync(orderResult.Details);
}
return RedirectToAction("ThankYou", new { id = orderResult.Details.OrderId } );
}
...
}
En dicho post comentaba también algunas cosas que podíamos hacer para solucionar el problema, así como una recomendación de lo que no debíamos hacer: disimular dependencias instanciando directamente componentes o utilizando otros "sabores" de inyección que hicieran menos evidente la relación de nuestra clase con otras de las que depende.Pues bien, como hoy estamos algo rebeldes, vamos a ver las técnicas que nos permitirían hacerlo cuando sea necesario o, dicho de otra forma, qué alternativas tenemos para usar dependencias desde los controladores sin que estas sean suministradas mediante inyección en su constructor.
Precaución: estas técnicas son consideradas antipatrones o, como mínimo, code smells en la mayoría de los escenarios, así que usadlas poco, con precaución y siempre con conocimiento de causa ;)
Por ello, en ASP.NET Core MVC, lo habitual es que implementemos nuestros controladores atendiendo a este principio, y para ello utilicemos la técnica de inyección de dependencias en el constructor:
public class InvoiceController: Controller
{
private readonly IInvoiceServices _invoiceServices;
private readonly IMapper _mapper;
private readonly ILogger<InvoiceController> _logger;
public InvoiceController(
IInvoiceServices invoiceServices,
ILogger<InvoiceController> logger,
IMapper mapper)
{
_invoiceServices = invoiceServices;
_logger = logger;
_mapper = mapper;
}
...
}
Nota: aunque en este post estemos hablando de controladores ASP.NET Core MVC, las ideas que vamos a comentar aquí son también aplicables a ASP.NET MVC "clásico" e incluso a otro tipo de frameworks que comparten los mismos conceptos.
Publicado por José M. Aguilar a las 8:55 a. m.
Etiquetas: aspnetcoremvc, aspnetmvc, buenas prácticas, patrones
var invoice = _invoiceRepository.GetById(18);
if(invoice == null)
{
// Hacer algo
}
¿Qué podría salir mal, verdad?Pues aunque pueda parecer raro, hay casos en los que la comparación anterior no funcionaría bien... o mejor dicho, no funcionaría como esperamos.
Hace unos días leía un post de Khalid Abuhakmeh en el que hacía referencia a una charla de Channel 9 en la que Mads Torgersen recomendaba no utilizar la doble igualdad para comparar con
null
(minuto 33:00, aprox.)Aparte de muchas alegrías y algún que otro disgusto, lo que tengo claro es que esta trayectoria me ha dado una visión bastante amplia de cómo funciona el mundo del desarrollo de software y las personas que trabajamos en él.
Como guardarme estos conocimientos me parecía demasiado egoísta, he decidido compartir con todos vosotros los que considero que son los diecisiete consejos definitivos que debéis seguir si queréis triunfar en el mundo del desarrollo de software.
Por lo que he ido aprendiendo estos años, seguir estas reglas os llevará a conservar indefinidamente vuestros empleos o clientes, aumentaréis vuestro valor en el mercado, mejoraréis salarios y vuestro grado de felicidad y satisfacción personal crecerá hasta límites insospechados.
He de decir que, antes de compartirlos con todos vosotros, varias personas ya los han seguido y sus vidas profesionales han mejorado considerablemente. Por ejemplo, Juan M. R. trabajaba como programador junior en una conocida cárnica hace 6 meses y hoy dirige el equipo técnico en una startup en San Francisco. También, Nacho G. L. pudo firmar hace poco el contrato fijo con el que soñaba, incluso con un aumento de sueldo. Rafael P. G. era un programador del montón y ahora es un reputado project manager por el que se pelean las mejores empresas del mundo.
“Sin los grandes consejos de José María,Podéis ser los próximos en dar el salto, sólo depende de vosotros.
mi vida como desarrollador seguiría siendo un infierno”
– Ricardo M. C., 2017
Publicado por José M. Aguilar a las 12:10 a. m.
Etiquetas: buenas prácticas, inocentadas, recomendaciones
En este caso, me ha entusiasmado dar por casualidad con el "bus factor", un término que seguro muchos conocíais pero para mi ha sido un descubrimiento reciente, que básicamente da forma a la pregunta que seguro que todos nos hemos hecho sobre la continuidad de algunos proyectos ante determinados acontecimientos inesperados.
Imaginemos que todo el equipo de desarrollo de un proyecto va caminando por la calle, y un autobús que circulaba cerca pierde el control y les arrolla de forma violenta. ¿A cuántos miembros del equipo tendría que afectar fatalmente este accidente para poner en gran peligro la continuidad del proyecto?
Y ya se dieron cuenta de esto los padres de la informática, aquellos pioneros que hace cincuenta años andaban sentando las bases sobre las que se sustentan las tecnologías, herramientas y lenguajes que utilizamos hoy.
La programación sin ego, o egoless programming, es una forma de programar basada en el aprendizaje continuo y colaboración entre personas, dejando de lado los aspectos puramente personales y comportamientos ególatras que podemos tener algunas veces. La idea fue acuñada por Jerry Weinberg en su libro The Psychology of Computer Programming, publicado publicado en 1971.
En este libro aparecieron por primera vez los Diez Mandamientos del Egoless Programming, que creo que deberían ser unas normas de lectura y aplicación obligatoria en nuestra profesión.
Los Diez Mandamientos del egoless programming
1. Entiende y acepta que cometerás errores.La cuestión es encontrarlos pronto, antes de que lleguen a producción. Afortunadamente, salvo para los pocos que desarrollan software de guiado de misiles, los fallos tienen raramente consecuencias fatales en nuestra industria, así que podemos, y deberíamos, aprender, reírnos, y seguir adelante.
2. Tú no eres tu código.
Recuerda que el objetivo de una revisión es encontrar problemas, y se encontrarán problemas. No te lo tomes personalmente cuando un error tuyo se descubra.
3. No importa cuánto “karate” sepas, siempre alguien sabrá más.
Esa persona puede enseñarte algunos movimientos nuevos si se lo pides. Busca y acepta información de otros, especialmente cuando piensas que no es necesario.
4. No reescribas código sin consultarlo antes.
Hay una fina línea de separación entre “corregir código” y “reescribir código”. Conoce la diferencia y realiza los cambios en el marco de una revisión de código, y no actuando como un justiciero solitario.
5. Trata a los que saben menos que tú con respeto, educación y paciencia.
La gente no técnica que trata con desarrolladores de forma frecuente casi siempre tienen la opinión de que en el mejor de los casos somos divas, y en el peor, llorones. No refuerces este estereotipo con ira e impaciencia.
6. La única constante en el mundo es el cambio.
Permanece abierto a ello y acéptalo con una sonrisa. Mira cada cambio a tus requisitos, plataforma o herramientas como un reto, no como un inconveniente contra el que hay que luchar.
7. La única autoridad real deriva del conocimiento, no de la posición.
El conocimiento genera autoridad, y la autoridad engendra respeto. Así que si quieres ser respetado en un entorno egoless, cultiva el conocimiento.
8. Lucha por lo que crees, pero acepta la derrota con deportividad.
Entiende que a veces tus ideas serán ignoradas. Incluso si resulta que estabas en lo cierto, no seas vengativo o digas “te lo dije” más de un par de veces, ni hagas de tu difunta idea una mártir o un grito de guerra.
9. No seas “ese tío de la habitación”.
No seas ese tío programando en una oficina oscura que emerge sólo para comprar coca-cola. Ese tío está fuera de la vista, del tacto, fuera de control y no tiene cabida en un entorno abierto y colaborativo.
10. Critica el código y no a la gente.
Sé amable con el desarrollador pero no con el código. Haz comentarios relacionados con los estándares locales, especificaciones de la aplicación, incrementos de rendimiento, etc.
Publicado en Variable not found.
Aunque creo que este mismo documento o versiones anteriores lo he leído en otras ocasiones, la verdad es que sigue resultándome muy interesante porque me recuerda normas y convenciones que conviene tener en cuenta al desarrollar marcos de trabajo y componentes. No hay que olvidar que estas directrices han sido refinadas y mejoradas con los años, acumulando ya la experiencia de muchos años y muchos desarrolladores que han trabajado en .NET framework, así que se trata de una base de conocimiento nada despreciable. De hecho, estas pautas son las bases del diseño de frameworks dentro de la propia Microsoft.
Y como a menudo me encuentro con equipos que no tienen guías de estilo ni convenciones de codificación formalizadas, he pensado que quizás sería interesante traducirlas para que puedan ser usadas como punto de partida para crear sus propias normas y, en cualquier caso, siempre dan buenas ideas que podemos aplicar en el día a día para hacer mejor nuestros componentes.
Es una lectura cortita, ¡que aproveche!
Y ciertamente, me ha parecido muy interesante porque es un escenario que encuentro habitualmente en empresas de desarrollo: comprenden los beneficios de reducir el acoplamiento entre componentes, pero les parece algo demasiado complejo como para aplicar en su día a día porque desconocen cuáles son y cómo usar las herramientas de que disponemos para conseguirlo.
Por tanto, en este post vamos a ver, paso a paso y de forma totalmente práctica, cómo evolucionar desde un controlador MVC fuertemente acoplado a clases del modelo hasta otro totalmente desacoplado usando inyección de dependencias y contenedores de inversión de control.
Y aunque las técnicas y ejemplos que mostraremos están muy enfocados a controladores MVC, los conceptos tratados son aplicables en cualquier tipo de tecnología y arquitectura.
Si trabajamos con un array, podemos consultar la propiedad
Length
; si se trata de una colección, podemos utilizar la propiedad Count
, que también nos devolverá el mismo dato de forma directa.Sin embargo, cuando procesamos información es frecuente tratar con tipos de datos enumerables cuya implementación exacta desconocemos, y en los que no tenemos acceso a ninguna propiedad que nos permita conocer el número de elementos exactos que tiene almacenados. Por ejemplo, esto ocurre cuando obtenemos un conjunto de datos en forma de
IEnumerable
o trabajamos con LINQ sobre alguna fuente de información.Pues bien, en estos casos hay que ser algo prudentes con la forma de consultar el número de elementos. Me he topado con código
Count()
, facilitado por LINQ para las enumeraciones y otras colecciones de datos, con objeto de saber si una lista estaba vacía:var prods = services.GetProductsByCategory(category);
if (prods.Count() > 0)
{
// Hacer algo con los elementos de la lista
}
else
{
// No hay elementos
}
Seguro que ya os habréis percatado de que eso está mal, muy mal. El método
Count()
recorrerá uno por uno los elementos para contarlos, retornando el número exacto de ellos. En escenarios de un gran número de elementos, o cuando es costoso obtener cada elemento (como al traerlos de una base de datos) puede suponer un consumo de recursos enorme.Y justo por esto existe el método
Any()
, que comprueba únicamente si existe al menos un elemento en la colección. Internamente este método itera sobre la colección retornando true
cuando encuentra el primer elemento, por lo que es mucho más eficiente que el anterior:var prods = services.GetProductsByCategory(category);
if (prods.Any()) // Mucho mejor :-)
{
// Hacer algo con los elementos de la lista
}
else
{
// No hay elementos
}
La utilización de
Any()
también es interesante para comprobar la existencia de elementos que cumplan una condición, expresada en forma de predicado; retornará true
cuando encuentre el primer elemento que lo haga cierto:if (pedidos.Any(p => p.Pendiente))
{
// Mostrar alerta, hay al menos un pedido pendiente
}Estamos en la puerta de un Estadio y queremos saber si vamos a ser los primeros en entrar al recinto… ¿le preguntaríamos al portero el número exacto de aficionados que ya están dentro para, si es cero, saber que somos los primeros? ¿O nos bastaría simplemente con preguntarle si hay alguien? ;-P
Publicado en: Variable not found
Hey: ¡estoy en Twitter!
Publicado por José M. Aguilar a las 12:01 a. m.
Etiquetas: .net, buenas prácticas, c#, desarrollo, linq, trucos, vb.net
Recientemente se ha publicado la tercera versión de NDepend, que ofrece interesantes novedades respecto a las anteriores, como la integración absoluta con Visual Studio, el soporte para soluciones multi-proyecto, potentes mecanismos de búsqueda, edición múltiple de CQL, o el seguimiento de cambios, además de las tradicionales características del producto.
Para habilitar esta característica es necesario instalar el plugin en el IDE, que se realiza desde el propio entorno visual de NDepend:
De esta forma, ya no es necesario acudir a la herramienta Visual NDepend para realizar búsquedas, comprobar reglas o navegar a través de la base de código: lo haremos directamente desde VS, utilizando los menús contextuales. Y gracias a ello, podemos disfrutar de las nuevas opciones de navegación, que nos permitirá surcar el código utilizando rutas distintas a las habituales:
Además, como comenta Patrick Smacchia, padre de la criatura, el rendimiento del entorno prácticamente no se resiente, dado que los análisis se ejecutan en segundo plano de forma incremental.
Recordar, por último, que NDepend es una aplicación comercial, pero dispone de una versión limitada gratuita utilizable por universidades, desarrolladores open source e incluso, durante un tiempo determinado, de prueba en proyectos comerciales.
Página del producto: http://www.ndepend.com/
Publicado en: Variable not found
Hey, ¡estoy en twitter!
Publicado por José M. Aguilar a las 11:49 p. m.
Etiquetas: .net, buenas prácticas, calidad, desarrollo, herramientas
21. Las leyes de Bryce
Así las llama él, aunque algunas encajarían mejor en una recopilación de frases célebres. Ahí van algunas, aunque pueden encontrarse más de 150 aquí.Tim Bryce es un controvertido escritor y consultor de gestión de recursos de información (IRM), famoso entre otras cosas por sus aseveraciones sobre el ego, las manías y extrañezas de los desarrolladores, y sus consejos para manejarlos apropiadamente. Aparte de su habilidad para hacer amigos entre los programadores, es sin duda un gran experto en el mundo de las compañías de desarrollo de software, con más de 30 años a sus espaldas en este campo.
Tal y como el uso de la tecnología va aumentando, disminuyen las habilidades sociales
El 85% del trabajo de desarrollo de todos los sistemas consiste en introducir modificaciones y mejoras
A la vez que la capacidad del hardware incrementa, el software se vuelve más pesado
Olvidar al ser humano durante el diseño del sistema provocará que el ser humano se olvide del sistema en el momento de echarlo a andar
[...]
22. Primer principio de Spaf
Si eres responsable de seguridad pero no tienes autoridad para establecer reglas y castigar sus incumplimientos, tu cargo real en la organización es asumir la culpa cuando ocurra algo grave
Eugene Spafford, más conocido como "Spaff", es un reputado experto en seguridad informática y profesor de la Purdue Univertity. Según parece, fue uno de los primeros en escribir un libro sobre virus informáticos en 1989, utilizar el término autopsia software para referirse al análisis de aplicaciones para intentar localizar a sus autores, y un sinfín de aportaciones al mundo de la seguridad en sistemas informáticos.
Además, es tan prolífico creando frases y analogías a la hora de explicar conceptos de informáticos que Mahesh V. Tripunitara, uno de sus estudiantes, mantiene una página donde las recoge: "The Page of Spaf's Analogies".
23. Ley de Alzheimer de la programación
Si lees un código que escribiste hace más de dos semanas es como si lo vieras por primera vezEfectivamente, el psiquiatra y neurólogo alemán Aloysius Alzheimer no enunció esta ley a primeros del siglo pasado, pues estaba muy ocupado estudiando las enfermedades mentales de sus pacientes. Sin embargo, el síntoma de pérdida de memoria tan habitual en ellos propició la utilización de su nombre en esta Ley tan ligada a la escritura de código limpio, documentado y sencillo.
24. Ley de Amara
Tendemos a sobreestimar el efecto de la tecnología en el corto plazo y a subestimarla a largo plazoEsta ley, causa de la existencia de problemas debidos a excesos de optimismo o de la formulación de predicciones disparatadas, fue enunciada por Roy Amara, que fue presidente del Instituto para el Futuro, un grupo de investigación sin ánimo de lucro dedicado al análisis de tendencias que ayuden a la toma de decisiones basándose en predicciones sobre el futuro.
26. Principio de Liskov
Los subtipos deben ser sustituibles por sus clases basesO en otras palabras, que un subtipo no debe modificar el comportamiento esperado de la clase de la que hereda; de esta forma, si el subtipo puede sustituir a su clase base sin causar daños, la herencia será correcta. Citando a Enrique Place en PHPSenior,
"No basta con ser hay que comportarse como tal".
Barbara Liskov es profesora del Massachusetts Institute of Technology (MIT) y fue la primera mujer en conseguir el doctorado en informática de Estados Unidos.
25. Ley de Hick
El tiempo que se tarda en tomar una decisión aumenta a medida que se incrementa el número de alternativasPuede sonar a obvio, pero la cuestión es que William Edmund Hick, pionero en psicología experimental y ergonomía, fue capaz de idear, a mediados del siglo pasado, la fórmula que explica por qué tardamos tanto tiempo en responder a un cuadro de diálogo con botones para Aceptar, Cancelar, Reintentar, Ignorar y Omitir:
T = blog2(n + 1)Cosas de las matemáticas, seguro. :-D
27. Principio de Hanlon
Nunca le atribuya a la maldad lo que puede ser explicado por la estupidezA pesar de su nombre, no está claro quién definió con tanta claridad su confianza en la capacidad del ser humano. Bill Clarke, Goethe, William James, Napoleón Bonaparte, Richard Feynmann, Einstein, Robert A. Heinlein (cuyo apellido podría haber degenerado en "Hanlon"), o un desconocido Robert J. Hanlon del que no existen demasiadas referencias podrían ser los padres de esta Ley tan utilizada por los hackers para definir situaciones creadas como consecuencia del trabajo de incompetentes sin mala intención.
28. Ley de Joy
El número de empleados inteligentes en una empresa es una función logarítmica del número de empleados totalesTambién formulada como "no importa quien seas, la mayoría de la gente inteligente trabaja para otro", la Ley dictada por Bill Joy ofrece una visión un tanto pesimista (¿realista?) de nosotros mismos y nuestro entorno de trabajo. Pero ojo, que no lo decía cualquiera, que este señor es co-fundador de Sun y, probablemente, estuviera describiendo lo que veía.
29. Ley de Lister
La gente bajo presión no piensa más rápidoBonita frase para escribir en un post-it y pegárselo en la frente a alguien a ver si se da por aludido. Y es que efectivamente, la presión y la velocidad de pensamiento no son magnitudes proporcionales, pero es Tim Lister, un consultor, formador y escritor experto en gestión de riesgos en procesos de desarrollo de software, el que lo enunció de esta forma tan tajante y certera.
30. La navaja de Occam
En igualdad de condiciones la solución más sencilla es probablemente la correctaEn el siglo XIV, Guillermo de Ockham, fraile franciscano y filósofo, postulaba de esta forma el principio de economía, utilizada en disciplinas tan dispares como la teología, informática o lingüística. De hecho, podríamos considerarlo la base de principios como KISS (Keep It Simple, Stupid), o YAGNI (You ain't gonna need it), asociados habitualmente a la programación extrema pero válidos en cualquier tipo de desarrollo.
Una curiosidad, el tercer episodio de la primera temporada de la serie House tenía este título, haciendo referencia a la solución del caso médico propuesto.
Fuentes:
- Global Nerdy: Laws of software development
- Jugando a crear: Leyes del desarrollo de software
- Wikipedia: List of eponymous laws
- sysprog.net: Computer laws
- Haacked: 19 Eponymous Laws Of Software Development
Publicado en: Variable not found.
Publicado por José M. Aguilar a las 11:24 p. m.
Etiquetas: buenas prácticas, curiosidades, epónimos, frases célebres, leyes, software
11. Ley de Linus
Dados suficientes ojos, todos los errores son obviosPues sí, Linus Torvalds, uno de los más famosos artífices de Linux tal y como es conocido hoy en día, no sólo desarrollaba software, también emitía este tipo de aseveraciones en las que exponía las ventajas del modelo de desarrollo cooperativo y abierto frente al propietario; otros simplemente ven esta teoría como una barbaridad desde el punto de vista de la seguridad y mantenimiento de los sistemas.
Aunque la frase fue cosa de Linus, fue Eric S. Raymond, un hacker a la antigua usanza, el que la popularizó y le dio el nombre de su creador.
12. Ley de Reed
La utilidad de grandes redes, y en particular las sociales, crecen exponencialmente con el tamaño de la redDavid P. Reed, científico americano, enunció esto que parece obvio en los tiempos actuales dado el tamaño y utilización de este tipo de redes. En esta entrada de la wikipedia podéis encontrar una introducción del soporte teórico en el que se basa, que explica en esencia la facilidad con la que crece el número de subgrupos posibles entre usuarios en relación al número de usuarios o de pares.
13. Ley de Moore
La potencia de los ordenadores se duplica cada dos años, reduciendo además su costeRepetida hasta la saciedad en revistas de cacharreo, y constatada desde hace décadas, fue promulgada por Gordon Earl Moore, quien por cierto es co-fundador de Intel, fijaos si lo tenía claro el muchacho, en 1965 (!). No sé si entonces utilizó la bola de cristal, era una declaración de intenciones, o simplemente es un genio, pero desde luego su ley es una referencia de la medida del avance en los ordenadores y demás dispositivos basados en tecnología similar, y un objetivo mínimo a cumplir.
14. Ley de Wirth
El software se ralentiza más deprisa de lo que se acelera el hardwareBrillante la frase de Niklaus Wirth, que allá por el año 1995, aún sin conocer Windows Vista, observó su entorno y predijo la situación actual: cada vez el software es más lento y pesado, a pesar de que según la Ley de Moore tendría que ser al contrario. Este señor, una eminencia, es conocido sobre todo por haber dirigido la creación de los lenguajes Pascal, Modula y algunos otros menos difundidos.
¿Será coincidencia que en ese mismo año, 1995, fue el lanzamiento oficial de Java? ;-P
15. Ley de Zawinski
Todo programa intenta expandirse hasta que pueda leer emails. Aquél que no pueda ser expandido hasta ese punto, será sustituido por otro que sí tenga esa capacidadLo que más me ha llamado la atención de Jamie Zawinski aparte de su metafórica ley que critica el crecimiento, a veces sin sentido, del software, es su página web personal. No os la perdáis, pues es bastante indicativa del tipo de individuo de que se trata, todo un friki, padre entre otros de una versión de Netscape, Grendel, Netscape Mail & News, Lucid Emacs, etc. También es curioso que es propietario de un club nocturno en San Francisco, este sí que sabe ;-)
16. Las tres Leyes de Clarke
El conocido científico y escritor británico Sir Arthur Charles Clarke enunció estas tres leyes porque, según comentaba,Primera Ley de Clarke
Cuando un anciano y distinguido científico afirma que algo es posible, probablemente está en lo correcto. Cuando afirma que algo es imposible, probablemente está equivocado.
Segunda Ley de Clarke
La única manera de descubrir los límites de lo posible es aventurarse hacia lo imposible.
Tercera Ley de Clarke
Cualquier tecnología lo suficientemente avanzada es indistinguible de la magia.
"si tres leyes fueron suficientes para Newton, modestamente decido parar aquí".
Arthur C. Clarke fue autor de un gran número de libros, relatos y obras de divulgación, destacando su novela y participación en el guión de 2001: Una odisea en el espacio.
17. El principio de Dilbert
Las compañías tienden a ascender sistemáticamente a sus empleados menos competentes a cargos directivos para limitar así la cantidad de daño que son capaces de provocarEste complemento perfecto para el Principio de Peter fue observado por Scott Adams, autor de Dilbert, una popular tira cómica sobre el mundo de la empresa que se publica en 1200 periódicos de todo el mundo.
Scott Adams es considerado uno de los 50 pensadores más influyentes en el mundo de la empresa, incluso por encima de personajes como Steve Jobs o Al Gore. Se trata, además, de un epónimo curioso en cuanto a que su nombre no proviene directamente de su autor, sino de la obra de su autor.
18. Ley de Gilder
El ancho de banda aumenta a un ritmo tres veces superior a la potencia de los ordenadoresPues sí, cualquiera lo hubiera dicho hace unos años... pero la verdad es que hoy en día la velocidad en las conexiones a la red son increíbles. Y por suerte, sin subir proporcionalmente el coste ;-)
George Gilder es un controvertido escritor e intelectual americano, entusiasta de la tecnología e internet, que en la actualidad dirige el Gilder Technology Report, un sitio exclusivo de información de ámbito económico y tecnológico. Según comentan, "sus hijos no estudian español, sino C++" (visto en Wikiquote).
19. Ley de Amdahl
El incremento de velocidad de un programa utilizando múltiples procesadores en computación distribuida está limitada por la fracción secuencial del programa
Esta ley, de gran aplicación en el cálculo de rendimiento de sistemas cuando uno de sus componentes es mejorado o en contextos de procesamiento en paralelo, fue enunciada por Gene Myron Amdahl en 1967, en sus tiempos como trabajador de IBM Corporation, que abandonó varias veces por disconformidad con el escaso trato humano en esta empresa, muy encorsetada y llena de burocracia.
Según demuestra matemáticamente, llegados a un punto el rendimiento de un sistema no está relacionado con el número de procesadores instalados, sino con la eficiencia de los algoritmos empleados.
20. Ley de Myhrvold
El software es un gas; se expande hasta rellenar su contenedorClaro, esto explica por qué da igual la potencia y capacidad del ordenador que tengamos: nuestro software lo llenará como si se tratara de un globo, hasta ponerlo a reventar.
Y lo dijo ni más ni menos que Nathan Myhrvold, ex-director de tecnología de Microsoft y fundador de Intellectual Ventures, una empresa dedicada crear y patentar, pero curiosamente no a poner en explotación, inventos para sectores como el software, semiconductores, redes, lásers, biotecnología y otros dispositivos.
Continuar en 30 Leyes épónimas relacionadas con el desarrollo de software (y III).
Publicado en: Variable not found
Publicado por José M. Aguilar a las 11:22 p. m.
Etiquetas: buenas prácticas, curiosidades, epónimos, frases célebres, leyes, software
Hace unos años, el gran Phil Haack posteó sobre leyes epónimas relacionadas con el desarrollo de software en "19 Eponymous Laws Of Software Development", y seleccioné las que me resultaron más interesantes en un par de posts.
Ahora los he vuelto a maquetar y les he añadido un nuevo conjunto de leyes muy interesantes para todos los que nos dedicamos al mundo del desarrollo de software, y muchas de ellas incluso aplicables a otros ámbitos.
1. Ley de Postel
Sé conservador en lo que hagas y liberal en lo que aceptes de los demásEsta frase, de Jonathan Bruce Postel, también llamada Principio de Robustez, es la piedra filosofal del protocolo TCP, y está recogida en la RFC 793, sección 2.10, de septiembre de 1981.
2. Ley de Parkinson
El trabajo se extiende siempre hasta rellenar la totalidad del tiempo disponible para completarloEsta ley fue postulada inicialmente en 1955 por C. Northcote Parkinson en The Economist y más tarde entró a formar parte de su libro, basado principalmente en las experiencias de la administración británica.
3. Principio de Pareto
Para muchos fenómenos, el 80% de las consecuencias derivan del 20% de las causasVilfredo Pareto fue un estudioso de la economía y sociología del siglo XIX, y se fijó que el 80% de las propiedades y riqueza estaban repartidas entre el 20% de la población, enunciando su famoso principio. A partir de ahí, se piensa que esta proporción es cierta en múltiples ocasiones, hasta en el número de bugs en el código fuente de un software, o el tiempo de desarrollo de funcionalidades.
4. Revelación de Sturgeon
El noventa por ciento de cualquier cosa es basuraTheodore Sturgeon era un autor de ciencia ficción americano que escribió esta frase defendiendo a este tipo de literatura de críticos que opinaban que el 90% era una porquería.
Hay un corolario que dice
"La revelación de Sturgeon es cierta salvo para la basura, donde el 100% es basura".
5. El principio de Peter
En una jerarquía, todo individuo tiende a subir hasta alcanzar su nivel de incompetenciaSeguro que todos conocéis ejemplos de ello: un fabuloso desarrollador es ascendido a directivo en una empresa, la cual gana un gestor pésimo y pierde un programador excelente. Doble penalización. Lawrence J. Peter, pedagogo de profesión, ya lo enunció en 1968 en el libro El principio de Peter.
6. Ley de Hofstadter
La realización de un trabajo siempre dura más de lo esperado, incluso habiéndose tenido en cuenta la Ley de HofstadterEsta genial y recursiva Ley creada por el científico, filósofo y académico estadounidense Douglas Hofstadter es absolutamente cierta. Y si no, pensad un poco, ¿cuántas veces habéis estimado plazos en un desarrollo, lo habéis incrementado de forma considerable por los imprevistos y aún así os habéis quedado cortos?
7. Ley de Murphy
Si algo puede ir mal, lo haráLa famosa ley, también enunciada en forma de tostada que recurrentemente cae con la mantequilla hacia abajo, fue dictada por Edward A. Murphy, Jr., mientras trabajaba para la fuerza aérea americana como ingeniero, diseñando un sistema de cohetes experimental. Sería lógico pensar que el experimento acabó en tragedia, pero parece ser que la creación y consideración de esta ley les ayudó a evitar graves desastres en sus pruebas.
8. Ley de Brooks
Incluir trabajadores en un proyecto retrasado hará que éste avance aún más lentamenteFred Brooks postuló esta ley en su famoso libro The Mythical Man-Month: Essays on Software Engineering como resultado de su experiencia en IBM. Existen variantes y corolarios como
"Una señora es capaz de tener un hijo en nueve meses, pero este plazo no puede disminuir por muchas mujeres embarazadas que pongamos a ello". Simplemente genial.
9. Ley de Conway
Cualquier software refleja la estructura organizacional de quien lo produjoA pesar de que suena a guasa, la ley de Melvin Conway no puede ser más cierta. Una empresa con tres grupos de desarrollo tenderá a generar software distribuido en tres subsistemas, reflejo fiel de las relaciones entre los grupos participantes. Y por cierto, extrapolando un poco... ¿habéis pensado alguna vez que el software que se hace en vuestra empresa es un desastre? ¿creéis que con esta ley podríais obtener alguna conclusión? ;-D
10. Principio de Kerckhoffs
En términos de criptografía, un sistema debería ser seguro incluso si todo sobre el mismo se conoce públicamente, salvo una pequeña porción de informaciónEs increíble que Auguste Kerckhoffs lingüista y criptógrafo alemán, enunciara en el siglo XIX este principio, base de todos los sistemas de criptografía de clave pública actuales.
Publicado en: http://www.variablenotfound.com/.
Publicado por José M. Aguilar a las 11:20 p. m.
Etiquetas: buenas prácticas, curiosidades, epónimos, frases célebres, leyes, software