¿Necesitan una reescritura las bases de datos relacionales?

Hoy en High Scalability enlazan a un artículo que 'denuncia' la obsolescencia del diseño e implementación de las actuales bases de datos relacionales: The End of an Architectural Era (It’s Time for a Complete Rewrite). Con una implementación que tiene en cuenta las arquitecturas actuales con sus cuellos de botella en cuanto a CPU, memoria y recursos de red, como ajustar el tamaño de los árboles-B al tamaño de la caché L2 o hacer los procesos de consulta en cada nodo con un solo hilo han conseguido rebajar hasta en dos órdenes de magnitud en el test TPC-C.

Este artículo forma una serie con “One Size Fits All”: An Idea Whose Time Has Come and Gone y One Size Fits All? – Part 2: Benchmarking Results en los que resalta no solo que el diseño y la implementación de los RDBMS son algo obsoleto sino que no son lo más adecuado para todos los escenarios (como ya se han dado cuenta los que se han encontrado con el problema)

Y ya un poco offtopic en este tema me gustaría resaltar una frase:

In the programming language community, there has been an explosion of “little languages” such as Python, Perl, Ruby and PHP. The idea is that one should use the best language available for any particular task at hand. Also little languages are attractive because they are easier to learn than general purpose languages. From afar, this phenomenon apears to be the death of “one size fits all” in the programming language world

O sea que en el futuro se llevará el programador políglota (bueno, o no, depende de quien mande...)

¿Necesitan una reescritura las bases de datos relacionales? en barrapunto

Sam Ruby y Erlang

Asisto con una mezcla de envidia y escepticismo a la conversión a Erlang de Sam Ruby. Sam Ruby es un típico goleor tecnológico ™ Siempre está a la última en cuanto a estándares y lenguajes sobre la web. De hecho, algunos los hace él :) Como buen experimentador de tecnología, como buen gurú, hace sus apuestas de futuro. La última apuesta de Ruby, muy interesante, es a varias bandas: REST, Hadoop, Erlang/OTP y los Microformatos.

Asisto con envidia sobre todo por la fase de enamoramiento compulsivo por la que está pasando (muy interesante para los demás, por cierto) con Erlang, aunque resulta extraña en alguien con tanta experiencia como él. Sino no se puede explicar que diga, en su última entrada, algo tan bonito como:

Con muchos frameworks y lenguajes, tengo la sensación de que estoy trabajando con un armario de metal con capas de pintura para barcos; cuando se le hace un rasguño salen a relucir los bordes afilados. Con Erlang tengo la sensación de un armario victoriano de caoba; cuando uno raya en la madera simplemente sale a relucir más valiosa madera.

Pero este enamoramiento nos está dando a los demás la posibilidad de seguir sus pasos y disfrutar de su código, que no está nada mal... El último paso ha sido un conversor de Atom a JSON, pero anteriormente ha hecho alguna cosita más, como envíar XHTML-IM sobre TLS con Erlang y una pequeña entrada sobre Comunicación entre procesos en Erlang. A ver si dura :)

Sam Ruby y Erlang en barrapunto

La humildad como virtud del programador

Y no me refiero a modestia frente a los otros (que también puede ser una buena cualidad) sino humildad con uno mismo y con lo difícil de hacer realmente bien este trabajo. En este sentido, sin más, le cedo la palabra a Jonathan Edwards, quien en Beautiful Code dice:

Una lección que he aprendido por la vía difícil es que no somos lo suficientemente listos. Incluso los programadores más brillantes cometen errores estúpidos con frecuencia. No solo errores de tecleo (typos) sino errores básicos de diseño que ponen en una situación difícil al código, y que a posteriori deberían haber sido obvios. La mente humana no es capaz de comprender en su conjunto la complejidad de un programa de tamaño moderado, mucho menos los sistemas monstruosos que construimos hoy en día. Esta es la amarga pastilla que nos tenemos que tragar, porque programar atrae y recompensa al inteligente, y su cultura fomenta la arrogancia intelectual. Me ha ha sido de inmensa ayuda trabajar con el supuesto de que soy demasiado estúpido para hacer las cosas correctamente. Esto me hacer usar de modo conservador aquello que ha funcionado, testear cautelosamente las nuevas ideas antes de confiar en ellas y por encima de todo, apreciar la simplicidad.

Curiosamente habla de un libro que me gustaría mucho adquirir y cuya existencia comenté por aquí.

Sobre el mismo tema, me gustaría recordar una famosísima cita de Brian Kernighan:

Depurar es el doble de difícil que escribir el código por primera vez. Entonces, si escribes código tan inteligentemente como te sea posible, no vas a ser, por definición, suficientemente listo para depurarlo.

Actualización: Creo que no ha quedado claro (he escrito la entrada demasiado rápido), pero lo que me parece curioso del comentario de Jonathan Edwards, es que es una justificación de porqué no escribió en Beautiful Code a pesar de estar invitado para ello, con una explicación tan inspirada que irónicamente merecería estar en el libro... :)

La humildad como virtud del programador en barrapunto

Varios sobre concurrencia: JVM, clasificaciones y consejos

Una ración de enlaces relacionados con la programación concurrente:

• El título lo dice todo: Where the metal meets JVM (An interview with Cliff Click) (Encontrado vía Pensamientos ágiles) Interesantísimo repaso a la implementación de la concurrencia en la máquina virtual de Java y de su relación con el hardware subyacente, con sutilezas en cuanto al modelo de memoria de cada arquitectura. Una buena conclusión, después de leerlos sería: no te fíes de que funcione, estudia bien las especificaciones, no vaya a ser que te lleves sorpresas con el run anyware ;)
• Gracias a sammael, dos artículos sobre también sobre el mismo tema: Introduction to nonblocking algorithms y Synchronization optimizations in Mustang, ambos de Brian Goetz. Un vistazo a java.util.concurrent y algunos detalles sobre el presente y futuro de la concurrencia en java. Complementarios al anterior.
• Herb Sutter en "How Much Scalability Do You Have or Need?" vuelve a clasificar las soluciones para aprovechar la concurrencia del hardware; en este caso se clasifica mediante la escalabilidad que se necesita, desde usar un solo core hasta la explotación de todos los recursos disponibles.
• "10 Ways to Reduce Lock Contention in Threaded Programs" de Michael Suess, que también cita a Goetz. Tanto el primer enlace como éste subrayan la dificultad de pasarse de listo y tratar de programar sin bloqueos. Aquí se califica de optimización prematura y se proponen alternativas muy interesantes como granularizar los bloqueos (y evitar el big lock que seguramente debería ser la primera implementación...) o usar bloqueos de lectura o de escritura (si están disponibles y es posible). Se trataría del primer paso (los primeros diez pasos) en la optimización

Varios sobre concurrencia: JVM, clasificaciones y consejos en barrapunto

Un vistazo a Threading Building Blocks

Según se puede leer en Ars technica: Intel open sources multicore programming tool Intel libera Threading Building Blocks, una herramienta hasta ahora propietaria que ayuda a la programación concurrente. La noticia ha salido en muchos sitios con comentarios interesantes (Slashdot, OSNews o en barrapunto)

Había oído hablar de esta herramienta en la entrevista a Sanjiv Shah de OpenMP en thinking parallel, pero como él trabaja en Intel siempre parece más sospechoso tratándose de un producto comercial. Ahora que lo han liberado he estado echándole un vistazo y bueno, creo que tiene su ámbito de aplicación y que puede ser muy interesante para facilitar algunas tareas sin reinventar alguna rueda.

Por analizar un poco la librería, consta como de cuatro partes:

• Algortimos para bucles paralelos: parallel_for, parallel_reduce, parallel_while. Me ha parecido de lo más interesante de la librería porque es muy fácil de implementar y te ahorra mucha gestión. Al algoritmo se le pasa un contenedor sobre el que operar y un functor y el lo procesa en paralelo automágicamente, aunque parece ser algo parametrizable.
• Contenedores seguros a accesos concurrentes: concurrent_hash_map, concurrent_vector, concurrent_queue. Usan internamente los bloqueos de grano fino y estructuras de datos sin bloqueos. Que bien que no haya que hacerlo por uno mismo, tiene pinta de ser complicadillo y muy fácil hacerlo mal
• Utilidades para gestión de la concurrencia: mutexes de diverso tipo (si, recursivos también), locks, operaciones atómicas
• Un gestor de tareas: una ayuda para programar orientado a tareas, threads más ligeros que los del sistema.

Desde que lo han hecho opensource le han asignado un domino propio, http://www.threadingbuildingblocks.org/ en el que hay bastante información. En particular el tutorial al que le he echado un vistazo es Intel® Threading Building Blocks: Tutorial

Por dar alguna nota no positiva... bueno, de momento solo soporta plataformas desde Intel Pentium 4, porteriores y compatibles, aunque en una de las FAQ del proyecto dicen que soportar todos los procesadores, sistemas operativos y compiladores es una las piedras angulares del proyecto. Veremos.

También me ha llamado la atención que dijesen (extraído del artículo de ars technica):

Java and .NET versions of TBB are currently being evaluated by Intel, and may eventually be announced. But Intel maintains that C++ is the company's priority, and it's where they'll be focusing the engineering resources that they're adding to the project.

Puede ayudar a hacer un poco más multiplataforma el código paralelizado en C++, aunque ya existen muchas librerías que lo hacen, como Boost.Thread. Supongo que estará bien usarlo cuando se necesita mucho rendimiento, una aproximación más sencilla no vale y paralelizarlo de este modo sale rápido y óptimo.

Un vistazo a Threading Building Blocks en barrapunto

¿Testeo o corrección?

Andaba yo descubriendo otro blog, el de Andrew Koenig, cuando, a raíz de dos post suyos seguidos (uno de aserciones contra excepciones y otro sobre la depuración) he reparado en el tema... últimamente se hace mucho hincapié en el desarrollo guiado por pruebas, pero según se puede ver en el segundo post, hay veces que las pruebas, e incluso el uso, no son garantía de corrección.

Por eso es tan importante que las pruebas sean realistas. Por eso es tan importante extraer información del sistema en todas la etapas del ciclo de vida. Por eso es tan importante un buen sistema de registro del sistema. Pero sobre todo, por eso es importante pensar bien antes de codificar.

También me ha recordado uno esos principios de desarrollo polémicos: Los fallos, cuanto antes mejor (Fail Fast). Es uno de los principios en el diseño de Erlang. Como dice Joe Armstrong en una entrevista reciente:

La filosofía de Erlang fue siempre construir sistemas con un montón de procesadores baratos y permitir que fallen. No prevenimos el fallo; vivimos con él y recuperamos el sistema cuando ocurren.

Hay que recordar que se trata de fallos irrecuperables, no de casos raros dentro de la lógica del programa. Es mejor dejar claro un error fatal que tratar de continuar cuando no se puede y que se pierda el rastro de lo sucedido...

Por supuesto el título es falaz, debería haber sido Testeo y corrección y todos contentos, pero espero que se me permita el recurso :)

¿Testeo o corrección? en barrapunto

Leyes sobre el desarrollo de software con nombre propio

Leo en haacked un listado de leyes que tienen algo que ver con el desarrollo de software y que además tienen nombre propio. Las hay serias y las hay humorísticas o simplemente pesimistas. Entre divertido, iluminador y deprimente.

De las que más me gustan:

• La ley de Postel: Sé conservador con lo que envías, liberal con lo que recibes. Ya hablé de ella por aquí en ¿Postel o Dracón?
• La ley de Parkinson: El trabajo se expande hasta consumir(*) todo el tiempo previsto para él. (*)Al menos, añadiría yo ;)
• El principio de Kerchkhoff: En criptografía un sistema debería ser seguro incluso si todo acerca del sistema es de conocimiento público excepto una pequeña cantidad de información: la clave.

Habla también de las típicas leyes de estos casos, Murphy, Pareto, Sturgeon, Brooks...

Actualización: Joey deVilla inspirado en el post anterior ha hecho una recopilación francamente impresionante de leyes o dichos referidos al desarrollo del software.

Leyes sobre el desarrollo de software con nombre propio en barrapunto

Beautiful Code

El bloguerío de esto de la programación anda revuelto por la publicación de un libro que parece muy interesante Beautiful Code: Leading Programmers Explain How They Think. Y es extraño que ande tan revolucionado sin una causa económica (al parecer lo que se saque con este libro irá a AI) pero viendo los autores quizás sea para tanto; que me suenen: Brian Kernighan, Tim Bray, Charles Petzold, Diomidis Spinellis, Douglas C. Schmidt, Yukihiro Matsumoto... aunque seguro que me dejo a alguien importante :) Cinco de ellos han sido ya nombrados por aquí, que cosas...

El libro consta de 33 capítulos en los que otros tantos autores piensan en alto sobre la arquitectura de sus proyectos (o de los proyectos de otro) los compromisos que se tomaron en su construcción y cuando fue importante romper las reglas. Dado lo heterogéneo del grupo de autores seguro que hay de todo un poco, pero el tema me parece tan interesante que inmediatamente lo he puesto en mi lista de deseos de anobii, aunque creo que dentro de poco se caerá de la lista :)

Por hacerme eco de algunos de los los comentarios que ha generado, Bryan Cantrill reflexiona sobre la recursividad en el mundo real y recibe interesantes respuestas. Alberto Savoia, uno de los autores, en "Pardon My French, But This Code Is C.R.A.P." reflexiona sobre el código malo, que es mucho más abundante, parafraseando a Strurgeon ("90% of everything is crap." - Sturgeon’s Law (one of many variants) "When applied to software, Sturgeon’s Law is hopelessly optimistic." - Savoia’s Corollary to Sturgeon’s Law) y a Sartre ("Hell is other people." - J. P. Sartre "Hell is other people’s code." - T-Shirt seen recently in Mountain View, CA) :)

Beautiful Code en barrapunto

Varios sobre concurrencia y patrones de diseño

Ración de enlaces:

• The Pillars of Concurrency por Herb Sutter Un resumen de los distintos escenarios en lo que se debe aplicar la concurrencia y de las posibles soluciones presentes y futuras. Comentado en LtU, The Pillars of Concurrency
• Un par de vídeos (que aún no he visto, pero que tienen muy buena pinta): C++ Threads por Lawrence Crowl y Concurrency/message passing Newsqueak por Rob Pike (En la tendencia de que los materiales se cuelguen más "en bruto", vídeos y entrevistas en audio y video en lugar de transcritos... más fácil de hacer pero peor para buscar algo concreto y al ser en lenguaje oral es posible que peor para los no nativos. Aunque estos parece que con las diapositivas se pueden seguir bien...)
• Un par de enlaces para reflexionar acerca de los patrones de diseño: Rethinking Design Patterns de Jeff Atwood, que viene a recordar los argumentos que se citaron por aquí en Enlaces varios (IV), que los patrones de diseño son síntomas de defectos en los lenguajes de programación. También Patterns I Hate #2: Template Method, que parece ser una serie en la que se medita sobre lo que se gana y se pierde con algunos patones.

Varios sobre concurrencia y patrones de diseño en barrapunto

Artículos de Alexandrescu sobre C++

Leo a través de la sección de programación de reddit que Andrei Alexandrescu ha puesto en su página, disponibles para descarga y consulta los artículos que ha publicado en C/C++ User's Journal. Para quienes no lo conozcan, Andrei Alexandrescu es el autor de Modern C++ Design uno de los libros más influyentes y que más bien (¿y mal?) ha hecho por el C++ y sus lectores/escritores.

Me han llamado la atención especialmente Lock-Free Data Structures, Lock-Free Data Structures with Hazard Pointers y C++ and The Perils of Double-Checked Locking aunque solo sea por la introducción a la programación con bloqueos y sin bloqueos que me ha parecido hasta didáctica. También hay otros artículos sobre punteros inteligentes, constructores de movimiento y otras técnicas y temas diversos. Más para leer...

Artículos de Alexandrescu sobre C++ en barrapunto