<?xml version="1.0" encoding="utf-8"?><?xml-stylesheet type='text/xsl' href='http://diegumzone.spaces.live.com/mmm2008-07-24_12.50/rsspretty.aspx?rssquery=en-US;http%3a%2f%2fdiegumzone.spaces.live.com%2ffeed.rss' version='1.0'?><rss version="2.0" xmlns:slash="http://purl.org/rss/1.0/modules/slash/" xmlns:msn="http://schemas.microsoft.com/msn/spaces/2005/rss" xmlns:live="http://schemas.microsoft.com/live/spaces/2006/rss" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:cf="http://www.microsoft.com/schemas/rss/core/2005" xmlns:wfw="http://wellformedweb.org/CommentAPI/"><channel><title>ZonaDiegum</title><description>Algo de Arquitectura de Software. Algo de Ocio. Mucho de Ambos a la Vez.</description><link>http://diegumzone.spaces.live.com/</link><language>en-US</language><pubDate>Mon, 13 Oct 2008 12:46:33 GMT</pubDate><lastBuildDate>Mon, 13 Oct 2008 12:46:33 GMT</lastBuildDate><generator>Microsoft Spaces v1.1</generator><docs>http://www.rssboard.org/rss-specification</docs><ttl>60</ttl><live:identity><live:id>1933461980449276005</live:id><live:alias>diegumzone</live:alias></live:identity><image><title>ZonaDiegum</title><url>http://blufiles.storage.live.com/y1pGM2iz9Y9OXR2gTHlYpf4myRf94qmP6t9je24XfRmRfihEZaezCqZUz5UDR73j2RL</url><link>http://diegumzone.spaces.live.com/</link></image><cf:listinfo><cf:group ns="http://schemas.microsoft.com/live/spaces/2006/rss" element="typelabel" label="Type" /><cf:group ns="http://schemas.microsoft.com/live/spaces/2006/rss" element="tag" label="Tag" /><cf:group element="category" label="Category" /><cf:sort element="pubDate" label="Date" data-type="date" default="true" /><cf:sort element="title" label="Title" data-type="string" /><cf:sort ns="http://purl.org/rss/1.0/modules/slash/" element="comments" label="Comments" data-type="number" /></cf:listinfo><item><title>UML, Al Fin en Visual Studio (versión 2010, "Rosario")</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1559.entry</link><description>&lt;p&gt;&lt;img alt="smile_omg" src="http://spaces.live.com/rte/emoticons/smile_omg.gif" width=201 height=201&gt;   &lt;img alt="smile_secret" src="http://spaces.live.com/rte/emoticons/smile_secret.gif" width=197 height=197&gt;   &lt;img alt="smile_party" src="http://spaces.live.com/rte/emoticons/smile_party.gif" width=196 height=196&gt; 
&lt;p&gt;&lt;a href="http://channel9.msdn.com/posts/VisualStudio/Visual-Studio-Team-System-2010-Week-on-Channel-9/"&gt;&lt;img style="border-right-width:0px;border-top-width:0px;border-bottom-width:0px;border-left-width:0px" border=0 alt="Semana Visual Studio 2010 en Channel9" src="http://p2f8sa.blu.livefilestore.com/y1pjr72kDSZTjEbvBcQfn73J40VREGSBuRr9hjObpDL8JHkqvl3ed3Y1xf4w8fZT2u_B4DmP50vAocX1-gEhuVwOQ?PARTNER=WRITER" width=644 height=472&gt;&lt;/a&gt;&lt;br&gt;&lt;strong&gt;Semana Visual Studio 2010 en Channel9&lt;/strong&gt; 
&lt;p&gt;  
&lt;p&gt;&lt;a href="http://msdn.microsoft.com/en-us/vstudio/products/cc948977.aspx"&gt;&lt;img style="border-right-width:0px;border-top-width:0px;border-bottom-width:0px;border-left-width:0px" border=0 alt="Camino a " src="http://p2f8sa.blu.livefilestore.com/y1pjXlseow6aLI7nXk5txYVFDkMn7tqh5PwT-IE-K6qLjYnG7EC0UHMLgJXDIRXPS6yiAW2nX1rFURpetYVM4go8g?PARTNER=WRITER" width=644 height=472&gt;&lt;/a&gt; &lt;br&gt;&lt;strong&gt;Camino a &amp;quot;Rosario&amp;quot;&lt;/strong&gt; 
&lt;p&gt;&lt;br&gt;&lt;a href="http://channel9.msdn.com/shows/ARCast.TV/ARCastTV-Peter-Provost-on-whats-coming-for-Architects-in-Visual-Studio-Team-System/"&gt;&lt;img style="border-right-width:0px;border-top-width:0px;border-bottom-width:0px;border-left-width:0px" border=0 alt="Peter Provost cuenta para nosotros (arquitectos) que viene en Visual Studio 2010" src="http://p2f8sa.blu.livefilestore.com/y1puH6Yj0uswqYc_nPKayQydCNT_Z2n9nEtU03vifshpv318NS4TpDwt7534zCY3Y5KjqvND7tkqF1pm7eA-Tj66g?PARTNER=WRITER" width=644 height=472&gt;&lt;/a&gt; &lt;br&gt;&lt;strong&gt;Peter Provost cuenta para nosotros (arquitectos) que viene en Visual Studio 2010&lt;/strong&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+UML%2c+Al+Fin+en+Visual+Studio+(versi%c3%b3n+2010%2c+%22Rosario%22)&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Architecture</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1559.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1559.entry</guid><pubDate>Tue, 30 Sep 2008 17:34:42 GMT</pubDate><slash:comments>1</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1559/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1559.entry#comment</wfw:comment><dcterms:modified>2008-09-30T17:36:03Z</dcterms:modified></item><item><title>Verde Que Te Quiero Verde: Computación Sustentable</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1524.entry</link><description>&lt;p&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;margin:0px 5px 0px 0px;border-right-width:0px" border=0 alt="Nuestro rancho" align=left src="http://blufiles.storage.msn.com/y1poMxLLDsW7b_A14wAK5fZNrQTFyZkHG0lYLDT7V-kpatT3ii6b1ZDxdy1nGiq6CZg?PARTNER=WRITER" width=150 height=151&gt;&lt;font style="background-color:#ffc000" color="#ffffff" size=5 face="Lucida Handwriting"&gt; Aquellos que siguen &lt;/font&gt; &lt;a href="http://blogs.msdn.com/diegumzone" target="_blank"&gt;mi blog en inglés&lt;/a&gt; saben que el número del &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/default.aspx" target="_blank"&gt;Journal&lt;/a&gt; a aparecer hacia fin de año (es decir, no el siguiente Journal sino el que sigue a éste) estará &lt;strong&gt;&lt;a href="http://blogs.msdn.com/diegumzone/archive/2008/08/20/microsoft-architecture-journal-issue-18-call-for-papers.aspx" target="_blank"&gt;abocado a explorar técnicas de computación &lt;em&gt;&lt;strong&gt;eco-friendly&lt;/strong&gt;&lt;/em&gt;&lt;/a&gt;. &lt;/strong&gt;Esto es, que no dañen al medio ambiente (o que lo hagan, cuando sea inevitable, en la menor medida posible) 
&lt;p&gt;Me está asesorando &lt;a href="http://blogs.technet.com/lcurtis/default.aspx" target="_blank"&gt;&lt;strong&gt;Lewis Curtis&lt;/strong&gt;&lt;/a&gt;, arquitecto de infraestructura de Microsoft y una de las voces más activas en la búsqueda de iniciativas que permitan alinear más y más la tecnología a las necesidades de la sociedad -en todos sus estratos: social, empresarial, educativo, etc- con, al mismo tiempo, un mínimo impacto de daño en el ya desequilibrado equilibrio ecológico y que además, ya que estamos, permita reducir el consumo energético de todo el parque tecnológico, habida cuenta del encarecimiento en los costos que la generación de energía viene experimentando (que tarde o temprano se trasladan al consumo) 
&lt;p&gt;De visita por mi oficina, &lt;a href="http://blogs.technet.com/lcurtis/default.aspx" target="_blank"&gt;&lt;strong&gt;Lewis&lt;/strong&gt;&lt;/a&gt; me tiró unas ideas interesantes acerca de la correcta manera de entender y abordar la &amp;quot;&lt;strong&gt;Computación Verde&lt;/strong&gt;&amp;quot; (&lt;strong&gt;&lt;em&gt;Green Computing&lt;/em&gt;&lt;/strong&gt;). Sintetizo su enfoque aquí 
&lt;p&gt;  
&lt;p&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" border=0 alt="6 aristas" src="http://p2f8sa.blu.livefilestore.com/y1pm3oowOswVi07aTie3idLJUZGPNu02JiZCh78C1N4_ZUjmRmht_EA2Taecg8RyuHkYM_-FHMa574NiUsgH_Gkqg?PARTNER=WRITER" width=644 height=484&gt; 
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Físico&lt;/strong&gt;. En esta perspectiva se estudian alternativas para mitigar el calor liberado por el uso intensivo de las unidades centrales de procesamiento (CPUs). La concentración creciente de CPUs en espacios físicos de dimensiones reducidas torna los centros de datos (datacenters) en verdaderos infiernos. Literalmente hablando. Aquí no son solamente los fabricantes de CPU (Intel, AMD, etc) quienes están batallando para lograr una mejor ecuación &lt;em&gt;performance-per-watt&lt;/em&gt; (rendimiento por electricidad consumida) sino que existen algunos estudios que detallan la ideal posición física de las CPUs para que estén lo suficientemente separadas como para que el incremento de temperatura no se potencie pero a la vez lo suficientemente cerca como para maximizar el aprovechamiento del espacio físico 
&lt;li&gt;&lt;strong&gt;Plataforma Operativa&lt;/strong&gt;. Cuando se asignan procesos a servidores, se lo hace normalmente en función de la carga esperada de trabajo que estos procesos van a tener. El estudio de un consumo más eficiente de recursos dio lugar a dos tácticas: la optimización y la consolidación. La optimización del uso de la plataforma operativa se puede alcanzar de varias maneras, sea mediante la asignación correcta de recursos (CPUs, ancho de banda, etc) como por la detección de estado ocioso prolongado y consecuente hibernación, entre otras (esto, claro está, es también lograble desde el mismo hardware). La consolidación tiene que ver con la aglomeración de varios procesos en un mismo hardware, de modo de maximizar el uso de recursos&lt;br&gt;Claro, acá puede impactar el hecho de que diferentes procesos pueden requerir una diferente plataforma operativa, lo que limita las chances de consolidación. Pero esto es mitigado gracias a los avances alcanzados en virtualización de plataformas, lo que ha permitido tirar viejo hardware, costoso de mantener, sin discontinuar las aplicaciones que en el mismo corrían -en muchos casos sistemas legados o legacy systems, los cuales hasta cierto punto pueden resultar tan caros de mantener como de migrar- 
&lt;li&gt;&lt;strong&gt;Regulaciones&lt;/strong&gt;. A nivel gubernamental los países están avanzando (?) en metas de reducción de niveles de dióxido de carbono (CO2), el principal responsable del &lt;strong&gt;efecto invernadero&lt;/strong&gt; (&lt;em&gt;&lt;strong&gt;greenhouse effect&lt;/strong&gt;&lt;/em&gt;). A la corta o a la larga eso se va a trasladar a un sistema de premios y castigos en la calidad y cantidad de energía que las compañías -y a renglón seguido los hogares- consuman. Probablemente esto vaya ligado a excensiones o gravámenes impositivos 
&lt;li&gt;&lt;strong&gt;La &amp;quot;Nube&amp;quot;&lt;/strong&gt;. Las aplicaciones hosteadas en la web misma, y con esto no me refiero a accesibles vía web ya que esto incluye a aplicaciones hosteables en un servidor hogareño, sino a aquellas aplicaciones cuyo &amp;quot;dueño&amp;quot; las recibe distribuidas &lt;strong&gt;como un servicio&lt;/strong&gt; (&amp;quot;&lt;strong&gt;&lt;em&gt;as a Service&lt;/em&gt;&lt;/strong&gt;&amp;quot;), en lugar de hacerse responsable de su ubicación física y operación; decía que tales aplicaciones plantean desafíos tanto para el que las consume -quien no debe hacerse cargo del datacenter con lo cual acá tiene un significativo problema menos- como del que las provée, quien tiene ante sí la oportunidad de optimizar la granja de servidores, consolidando los clientes de tales aplicaciones &lt;strong&gt;SaaS&lt;/strong&gt; (por &lt;strong&gt;&lt;em&gt;Software as a Service&lt;/em&gt;&lt;/strong&gt; o &lt;strong&gt;Software como Servicio&lt;/strong&gt;). En la ecuación general, bajo este esquema de tiempo compartido (tiempo de ejecución, claro, o creíste que pusimos SaaS y nos rajamos todos de vacaciones... Zaas! &lt;img alt="smile_omg" src="http://spaces.live.com/rte/emoticons/smile_omg.gif"&gt;), el consumo de recursos y de energía es inferior al esperado por el esquema tradicional donde cada consumidor se hostea su aplicación en sus propios servidores (lo que se conoce como &lt;em&gt;&lt;strong&gt;on premise delivery&lt;/strong&gt;&lt;/em&gt;)&lt;br&gt;Cuanto mayor sea la penetración del esquema &amp;quot;&lt;strong&gt;&lt;em&gt;as a Service&lt;/em&gt;&lt;/strong&gt;&amp;quot;, mayor el ahorre global. Sin embargo, claro, pasar de la nada a este esquema no es fácil, sobre todo si se necesita que la parte hosteada en la nube interopere con lo que nos quede &lt;strong&gt;&lt;em&gt;on premise&lt;/em&gt;&lt;/strong&gt;. Qué de la atomicidad de las transacciones, qué del &lt;strong&gt;&lt;em&gt;single sign-on&lt;/em&gt;&lt;/strong&gt; (&lt;strong&gt;login único&lt;/strong&gt; o &lt;strong&gt;SSO&lt;/strong&gt;), qué de muchas otras tantas cosas como disponibilidad, tiempo de respuesta, etc 
&lt;li&gt;&lt;strong&gt;Inteligencia Sustentable&lt;/strong&gt;. Imaginate un tablero de control donde podés monitorear la energía consumida por tu plataforma respecto de la actividad real que cada una está haciendo. Imaginate que podés establecer umbrales de consumo, disparar alarmas. Imaginate que podés tirar estadísticas históricas de ese consumo a fin de determinar tendencias y consiguientemente predecir la demanda futura esperable. No hace falta imaginarse demasiado porque existen esos monitores. &lt;strong&gt;Scry&lt;/strong&gt;, &lt;a href="http://www.cognos.com/" target="_blank"&gt;&lt;strong&gt;Cognos&lt;/strong&gt;&lt;/a&gt; (adquirido por &lt;strong&gt;IBM&lt;/strong&gt;) por mencionar algunos de ellos 
&lt;li&gt;&lt;strong&gt;Código de Aplicación&lt;/strong&gt;. Y llegamos al último, que a su vez engloba a todos los anteriores. En pocas palabras, no es cuestión de echarle la culpa de todo a la infraestructura, al soft de base e ilusionarse con la idea de que la solución pase nada más que por ahí. Por ejemplo, en nuestra apliación distribuida, dónde se conserva el estado de la sesión de cada usuario conectado? Es ese estado persistido al cabo de un tiempo en que el usuario no da señales de vida (y siempre antes de que expire su sesión), a fin de liberar la memoria para otras sesiones activas? Son los servicios state-less (una instancia única para todos) o stateful (una instancia individual por cada sesión que los consume)? Y qué hay para decir del ancho de banda? Se usa en forma eficiente? Qué significa &amp;quot;ancho de banda eficiente&amp;quot;? Enviar la menor cantidad posible de información en cada interacción o tratar de anticipar cierta información que el caso de uso pueda necesitar con una alta probabilidad? Y qué se puede decir del paralelismo en plataformas de más de un núcleo? Se saca tajada del procesamiento paralelo o el binario de la aplicación está pensado para el denominador común mono-núcleo? Podría seguirme extendiendo pero creo que con ésto queda demostrado que nosotros desarrolladores de soft no podemos hacernos los osos por muy ecológico que sea todo este tema&lt;/ul&gt;
&lt;p&gt;Bueno, la consigna es enviar propuestas de artículos para computación verde que tengan un enfoque práctico (es decir, más allá del mero mensaje de que ahorremos gas, apaguemos luces y no imprimamos mails si los podemos leer de la pantalla). El plazo de envío se extiende hasta el 10 de Septiembre. Más detalles para hacernos llegar tu propuesta, &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/bb219087.aspx" target="_blank"&gt;acá&lt;/a&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Verde+Que+Te+Quiero+Verde%3a+Computaci%c3%b3n+Sustentable&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>The Architecture Journal</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1524.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1524.entry</guid><pubDate>Wed, 27 Aug 2008 07:48:58 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1524/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1524.entry#comment</wfw:comment><dcterms:modified>2008-08-27T07:48:58Z</dcterms:modified></item><item><title>Mi Primer Journal Está en la Calle (#16, Identidades y Acceso)</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1496.entry</link><description>&lt;p&gt;&lt;a href="http://download.microsoft.com/download/a/7/6/a76e5770-19b1-415b-8b6c-6ff5c7b71574/J16_EN.zip" target="_blank"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" border=0 alt="Portada y editorial del numero 16 de The Architecture Journal" src="http://naw2ow.blu.livefilestore.com/y1pxLMHk9VQEqUQ7HiM2g8OMecl2Uy11VRDvVOfnKeLfJogAT6UJmY3Gh72Esp0QrR6yJ7eXpQk9nhMEn1YeocctA?PARTNER=WRITER" width=644 height=441&gt;&lt;/a&gt; 
&lt;p&gt;&lt;font style="background-color:#ffc000" color="#ffffff" size=5 face="Lucida Handwriting"&gt; Dos años atrás, &lt;/font&gt; cuando &lt;a href="http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!295.entry" target="_blank"&gt;un artículo mío era publicado en una revista independiente de TI&lt;/a&gt;, un colega me dijo, &amp;quot;&lt;a href="http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!295.entry#comment" target="_blank"&gt;Vos deberías escribir para &lt;em&gt;The Architecture Journal&lt;/em&gt;.&lt;/a&gt;&amp;quot; No podía haber predicho que me iba a encontrar ahora escribiendo para esta revista en mi nuevo rol de editor. Le quiero agradecer a &lt;a href="http://simonguest.com/" target="_blank"&gt;Simon Guest&lt;/a&gt;, por esta oportunidad y este enorme compromiso -durante su lapso, la cantidad de lectores se más que duplicó, pasando de 30 mil a más de 62 mil 
&lt;p&gt;En este número, te invitamos a pensar en la &lt;strong&gt;Arquitectura de Identidades&lt;/strong&gt; de tu organización. El manejo de identidades está evolucionando hoy del escenario simple, aislado, al escenario federado, en una forma que te puede sorprender 
&lt;p&gt;Empezamos este decimosexto viaje con la introducción de &lt;em&gt;Fernando Gebara Filho&lt;/em&gt; a los conceptos y estrategias en identidades, cómo han evolucionado y el camino por recorrer. Después, &lt;em&gt;Jesús Rodríguez&lt;/em&gt; y &lt;em&gt;Joe Klug&lt;/em&gt; examinan un surtido de estrategias para hacer de las identidades componentes de primera línea en el portfolio de aplicaciones federadas. &lt;em&gt;Gerrit van der Geest&lt;/em&gt; y &lt;em&gt;Carmen de Ruijter Korver&lt;/em&gt; consideran el desafío de establecer un entorno de confianza a nivel de aplicación ya que las identidades de usuario, en un mundo orientado a servicios, deben fluir desde el consumidor de un servicio hacia el prestador 
&lt;p&gt;Para el perfil de arquitecto de este número, lo atajamos a &lt;em&gt;Kim Cameron&lt;/em&gt;, autor de &amp;quot;&lt;a href="http://www.identityblog.com/stories/2005/05/13/TheLawsOfIdentity.pdf" target="_blank"&gt;&lt;strong&gt;Las Leyes de la Identidad&lt;/strong&gt;&lt;/a&gt;&amp;quot;, cuyas ideas en identidades federadas están dando forma a la siguiente generación de tecnologías de identidad de Microsoft. (Algo gracioso pasó el día que visité a Kim para esta entrevista: me olvidé mi tarjeta de acceso por lo que necesité que Kim &amp;quot;certifique&amp;quot; mi identidad en la entrada) 
&lt;p&gt;Retomando nuestro paseo, &lt;em&gt;Mario Szpuszta&lt;/em&gt; describe cómo el sistema de salud austríaco convirtió una crisis administrativa de &lt;em&gt;provisioning&lt;/em&gt; en una clara oportunidad para crear una federación de identidades abierta. Luego &lt;em&gt;Vittorio Bertocci&lt;/em&gt; explica cómo ciertos patrones de arquitectura nos ayudan a construir soluciones que consideran demandas (&lt;em&gt;claims&lt;/em&gt;), de modo que cuando &amp;quot;&lt;strong&gt;la Nube&lt;/strong&gt;&amp;quot; llegue a las compañías, el manejo de identidades no se va a ver necesariamente nublado 
&lt;p&gt;Finalmente, &lt;em&gt;Mike Morley&lt;/em&gt; y &lt;em&gt;Barry Lawrence&lt;/em&gt; revelan cómo sincronizaron identidades en varios sistemas y aplicaciones legadas (&lt;em&gt;legacy applications&lt;/em&gt;) desde una consola administrativa individual a través de un &lt;em&gt;framework&lt;/em&gt; de consolidación 
&lt;p&gt;  
&lt;p&gt;Querido lector, quisiera ser el primero en darte la bienvenida a &lt;a href="http://download.microsoft.com/download/a/7/6/a76e5770-19b1-415b-8b6c-6ff5c7b71574/J16_EN.zip" target="_blank"&gt;este número&lt;/a&gt;, y deseo que te &lt;em&gt;sientas identificado&lt;/em&gt; con sus artículos. A disfrutarlo! 
&lt;p&gt;  
&lt;p align=right&gt;Diego Dagum 
&lt;p align=left&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" border=0 alt="Editorial del numero 16 de The Architecture Journal" align=left src="http://naw2ow.blu.livefilestore.com/y1pM1JsMXiKsnjFZsZ_8htdTqVgqoKoLU-2tUF_0UvUXMlwp25ewfiIkhgkBX2MjGRlYzozytATHTdUwK_uNYOqOQ?PARTNER=WRITER" width=653 height=827&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Mi+Primer+Journal+Est%c3%a1+en+la+Calle+(%2316%2c+Identidades+y+Acceso)&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>The Architecture Journal</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1496.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1496.entry</guid><pubDate>Sun, 03 Aug 2008 01:11:50 GMT</pubDate><slash:comments>2</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1496/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1496.entry#comment</wfw:comment><dcterms:modified>2008-08-03T01:20:36Z</dcterms:modified></item><item><title>Call for Papers Para el Número 17 de The Architecture Journal</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1485.entry</link><description>&lt;p&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;margin:0px 5px 0px 0px;border-right-width:0px" border=0 alt="Yo quiero escribir para el Journal" align=left src="http://blufiles.storage.msn.com/y1pyrBr3F-Vf-coLREeWp8odMclTHEOS41318Xkj50uhIxlm2yv4iOA5m5qQfVJGYff?PARTNER=WRITER" width=354 height=398&gt; &lt;font style="background-color:#ffc000" color="#ffffff" size=5 face="Lucida Handwriting"&gt;El próximo número &lt;/font&gt;del &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/default.aspx" target="_blank"&gt;&lt;strong&gt;Architecture Journal&lt;/strong&gt;&lt;/a&gt; se va a enfocar en &lt;strong&gt;Computación Distribuida&lt;/strong&gt; 
&lt;p&gt;Nos estamos arrimando a un punto de inflexión con el &lt;em&gt;hardware&lt;/em&gt; y las tecnologías de hoy donde lo que hace unos pocos años atrás era apenas una visión hoy se va haciendo realidad -desde distribuir aplicaciones a dispositivos microscópicos hasta datacenters del tamaño del estadio de Boca y aún más, que ofrecen correr aplicaciones &lt;em&gt;en la nube&lt;/em&gt; 
&lt;p&gt;No importa qué tan chico o grande, la distribución y la concurrencia de servicios múltiples puede introducir un número de desafíos 
&lt;p&gt;El foco de esta edición es entender cuáles son esos desafíos y cómo superarlos 
&lt;p&gt;  
&lt;p&gt;Si esto logra inspirarte lo suficiente como para querer llevar tus opiniones a los más de 60000 lectores que el &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/default.aspx" target="_blank"&gt;&lt;strong&gt;Journal&lt;/strong&gt;&lt;/a&gt; tiene (solamente contando la edición en inglés, sin considerar las otras tres traducciones), por favor averiguá más datos en &lt;a href="http://blogs.msdn.com/diegumzone/archive/2008/07/12/microsoft-architecture-journal-issue-17-call-for-papers.aspx" target="_blank"&gt;mi blog en la lengua de William&lt;/a&gt; (foto)&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Call+for+Papers+Para+el+N%c3%bamero+17+de+The+Architecture+Journal&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>The Architecture Journal</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1485.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1485.entry</guid><pubDate>Sat, 12 Jul 2008 00:03:08 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1485/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1485.entry#comment</wfw:comment><dcterms:modified>2008-07-12T00:05:59Z</dcterms:modified></item><item><title>Recontruir Desde Adentro: Libro de Danija sobre Refactoring</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1460.entry</link><description>&lt;p&gt;&lt;a href="http://www.wrox.com/WileyCDA/WroxTitle/productCd-0470179791.html" target="_blank"&gt;&lt;img style="margin:0px 5px 5px 0px" align=left src="http://blogs.msdn.com/blogfiles/diegumzone/WindowsLiveWriter/DanihasBookonRefactoringforewordbyme_C367/image_3.png"&gt;&lt;/a&gt;  &lt;p align=right&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;&amp;quot;&lt;em&gt;La optimización temprana es la causante de todos los males&lt;/em&gt;&amp;quot;&lt;/font&gt; &lt;/font&gt; &lt;p align=right&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;-Sir Charles Antony Richard Hoare, computador científico británico, después parafraseado por Donald Knuth en su libro &lt;em&gt;El Arte de Programar Computadoras&lt;/em&gt;&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font face="Times New Roman"&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; Días atrás, &lt;/font&gt;&lt;font size=3&gt; mirando un documental sobre la vida del director de cine sudamericano Fabián Bielinsky, me llamó la atención algo que dijo en una entrevista. Decía que, cuando se filman escenas, usualmente pasa que una toma determinada no sale como el director inicialmente asumió que iba a ser. A veces esa escena se hace de vuelta hasta que el director consiga lo que quería, en tanto que en otras ocasiones se deja no más como salió, en la medida en que así como está queda bastante mejor que la idea original. Bielinsky concluía que el verdadero arte de hacer cine es saber decidir cuándo intentarlo de nuevo y cuando dejar lo que salió de entrada&lt;/font&gt;&lt;/font&gt;&lt;font size=3&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Sorprendentemente, si así viene la mano con las películas, codificar componentes es muy parecido a filmar escenas. Siempre es posible encontrar una mejor solución a un algoritmo dado. Así que, con el sombrero de gerente en la cabeza, tenemos que decidir cuándo congelar una siempre posible mejora a efector del la carga GANTT, el presupuesto, las fechas de entrega y la satisfacción general del usuario, y cuándo ir por más&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Y es acá donde enfrentamos la necesidad de refactorización: una serie de técnicas y mecanismos para mejorar la calidad -comprensibilidad, mantenibilidad, modularidad, extensibilidad, etc- de segmentos de código mediante la reformulación de sus sentencias en una forma en que la conducta general no cambie. En otras palabras, el comportamiento de los componentes afectados no debería variar como una consecuencia del proceso pero su calidad, y ojalá su vida útil, debería ser incrementada&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;La experiencia ha mostrado que algunas porciones de nuestro código van a ser, a la corta o a la larga, candidatas a refactorización, y las razones son varias:&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;ul&gt; &lt;li&gt;&lt;font size=3 face="Times New Roman"&gt;Del lado del usuario, los usuarios no están completamente seguros de la aplicación que quieren hasta que ven instalado y corriendo lo que ellos pidieron originalmente. No es chiste! Al principio empiezan requiriendo algo que tienen en la cabeza pero vagamente (y eso es natural: de ninguna manera los estoy acusando). Olvidarse situaciones especiales cuando nos describen un caso de uso es como tener caries: no digo que sea bueno pero sí que es algo normal. Un efecto secundario indeseable de este tira y afloja es que nuestro código podría empezar a perder cierto grado de cohesión; sus diversos módulos pueden empezar a acoplarse arriba de los niveles aceptables como consecuencia de cambios de último minuto debidos a presiones del &lt;em&gt;time to market&lt;/em&gt; &lt;/font&gt; &lt;li&gt;&lt;font size=3 face="Times New Roman"&gt;De nuestra perspectiva, la del desarrollo de software, nosotros no tenemos una idea cabal de a qué el código se va a parecer mientras estamos modelando. Al igual que los usuarios, nosotros también creémos que tenemos unas ideas impresionantes (o al menos buenas ideas al fin) hasta que tratemos de poner algunas de ellas en práctica. Equivocarse no es malo. Lo que es malo es obsecarse en cambiar de parecer sólo para evitar admitir que lo que habíamos considerado una gran idea no era, de hecho, tan fácil de implementar. Y acá de nuevo, cuando el tiempo agrega su presión, entregar un componente lo más rápido que podamos puede también dañar su calidad &lt;/font&gt; &lt;li&gt;&lt;font size=3 face="Times New Roman"&gt;Del lado de la tecnología, finalmente, hay una presión invisible aunque algo omnipresente a acompañar las tendencias de la industria. Ejemplos típicos son las APIs evolucionadas de .NET o Java (AJAX, servicios web, etc) que tornan obsoletas a las versiones previas, o estrategias generales como Arquitectura Orientada a Servicios (SOA), Modelo-Vista-Controlador (MVC), Mapeo entre Objetos y Relaciones (O/R-M), etc. Una vez más, en la medida en que reaccionamos a estas tendencias nuestro código es sometido a cierta manipulación que, a medida que el tiempo pasa, puede erosionar su calidad&lt;/font&gt;&lt;/ul&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Mientras tanto, el mundo real nos muestra que esmerarnos en mejorar la calidad de nuestro código es algo que tendemos a hacer en forma innata. Las técnicas de refactorización no son sino el más alto grado de maduración de esos intentos espontáneos, reforzadas con algunas herramientas de soporte disponibles por ahí para garantizar el éxito del proceso&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;La buena noticia es que podemos aplicar refactorización localmente, al nivel de un componente o método, allí donde estemos aplicando cualquier otra modificación; o globalmente, a nivel de módulo o aplicación, asignándole rango de proyecto. Decidir la dosis correcta de refactorización dependerá de la brecha de calidad a cerrar, el tiempo restante, el presupuesto disponible (siempre será más fácil justificar la refactorización donde ya teníamos algo más que hacer que donde ninguna actualización había sido pedida aún), entre otros factores&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;A lo largo de este libro, el autor abordará tópicos de refactorización desde la visión de sus beneficios a las maneras actuales de ponerlo en práctica. Danijel Arsenovski ha estado involucrado en técnicas de refactorización, tanto en las plataformas .NET como Java, desde sus versiones más tempranas. Dio varias conferencias, charlas y talleres en esta materia, dirigiendo proyectos exitosos de refactorización en la industria bancaria&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Como uno de los líderes en herramientas de desarrollo, Microsoft ha estado comprometido a distribuir los mejores recursos para la gente que día a día lidia con actividades de codificación y proyectos de software en su totalidad. Mediante su indiscutidamente ganador entorno integrado Visual Studio, Microsoft hace de la refactorización una facilidad &lt;em&gt;out-of-box&lt;/em&gt; apenas a un click de distancia de tu código. A lo largo de las páginas de este libro, Danijel te mostrará cómo la refactorización puede ser practicada en Visual Basic tan fácil como hacer copy / paste o cualquier otra actividad de edición!&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Me atrevo a decirte, estimado, que vas a encontrar en este libro una de las guías más probadas y fundamentales en estas técnicas. Que disfrutes este libro!&lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt; &lt;/font&gt; &lt;/font&gt; &lt;p&gt;&lt;font size=3&gt;&lt;font face="Times New Roman"&gt;Diego Dagum&lt;br&gt;Evangelista Técnico, Microsoft Corp.&lt;br&gt;&lt;em&gt;Kingsgate, Invierno de 2007&lt;/em&gt;&lt;/font&gt; &lt;/font&gt; &lt;p&gt;  &lt;p&gt;(Lo que acabás de leer es el prólogo que escribí para &lt;a href="http://www.wrox.com/WileyCDA/WroxTitle/productCd-0470179791.html" target="_blank"&gt;el libro de Danija &amp;quot;Professional Refactoring in Visual Basic&amp;quot; - Ediciones Wrox&lt;/a&gt;)&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Recontruir+Desde+Adentro%3a+Libro+de+Danija+sobre+Refactoring&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Management</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1460.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1460.entry</guid><pubDate>Sun, 01 Jun 2008 07:01:14 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1460/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1460.entry#comment</wfw:comment><dcterms:modified>2008-06-02T01:32:50Z</dcterms:modified></item><item><title>Crisis = Oportunidad. América Latina A No Dormirse</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1455.entry</link><description>&lt;p&gt;&lt;img src="http://a330.g.akamai.net/7/330/2540/20080205212153/www.homeaccentstoday.com/articles/blog/1960000396/20080205/crisis-opportunity.jpg" width=312 height=254&gt;&lt;br&gt;&lt;strong&gt;La palabra Crisis, escrita en Chino, comparte un&lt;br&gt;caracter con la palabra Oportunidad. No es así&lt;br&gt;por casualidad&lt;/strong&gt; 
&lt;p&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; No &lt;/font&gt; es un secreto para nadie que el mundo se encamina a una recesión impulsada, esta vez, no por Brasil o Asia o Rusia sino por la primera economía mundial. Si se frena la locomotora (nos guste o no, es la primera unidad del &lt;em&gt;convoy&lt;/em&gt;), los vagones que eran arrastrados inevitablemente van a perder impulso (nuevamente, nos guste o no) 
&lt;p&gt;Curiosamente en medio de estas crisis es cuando, usando un poco de inteligencia, podemos ver el lado bueno en los cambios de contexto. Como la fábula del burro que iban a sacrificar y para eso habían hecho un foso, lo habían tirado al fondo y pensaban enterrarlo vivo: el burro logro salir del foso porque en la medida que la tierra que tiraban se iba asentando, hacía pie en ésta 
&lt;p&gt;En el artículo que te linkeo &lt;a href="http://www.esj.com/news/article.aspx?EditorialsID=3136" target="_blank"&gt;acá&lt;/a&gt;, Gartner predice que en la medida que el parate económico de la primer superpotencia (la única hoy, bah) el &lt;em&gt;outsourcing&lt;/em&gt; (tercerización) de servicios de software va a aumentar en forma considerable. El que la venía mirando con cariño, se va a decidir en la medida en que necesite mantener sus servicios de software (si es posible, incrementarlos para -en la crisis de demanda- mejorar la calidad de su oferta). El que ya estaba tercerizando y conoce las ventajas en lo que a reducción de costos se refiere, probablemente quiera cerrar un cachito más la brecha. Y finalmente, el que hasta ahora no pensaba en tercerizar, si empieza a estar con el agua al cuello quizás al menos comience a explorar esta alternativa (algo es algo) 
&lt;p&gt;Gartner predice que India primero y China después van a ser los grandes polos de atracción de tercerizadores. Latinoamérica no sale mencionada, no en el informe de Gartner al que yo no tuve acceso, sino en la nota que lo destaca 
&lt;p&gt;De todas maneras, si la montaña no viene a Mahoma, habrá que ir a la &lt;em&gt;mountain&lt;/em&gt; no más... A preparar esas &lt;em&gt;brochures&lt;/em&gt; en inglés. Primer mundo: allá vamoooooosssssssss!!!!!!! &lt;img alt=blacksheep src="http://spaces.live.com/rte/emoticons/blacksheep.gif"&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Crisis+%3d+Oportunidad.+Am%c3%a9rica+Latina+A+No+Dormirse&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Management</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1455.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1455.entry</guid><pubDate>Sun, 11 May 2008 20:52:00 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1455/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1455.entry#comment</wfw:comment><dcterms:modified>2008-05-11T21:58:00Z</dcterms:modified></item><item><title>Arquitectos al Divan</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1452.entry</link><description>&lt;p&gt;&lt;img alt=image align=left src="http://blufiles.storage.msn.com/y1pHldoPC-Ru1iy6U4Rd8VXWvDFb3cD134qQlBmx3rmRhHsgm4uvVNHIY776qxVVf23xREe6ObWs-A?PARTNER=WRITER" width=395 height=450&gt; 
&lt;p&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; Semanas &lt;/font&gt; atrás liberamos &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/cc505966.aspx" target="_blank"&gt;la edición 15&lt;/a&gt; del &lt;a href="http://msdn.microsoft.com/en-us/arcjournal/default.aspx" target="_blank"&gt;&lt;strong&gt;Architecture Journal&lt;/strong&gt;&lt;/a&gt; (&lt;em&gt;&lt;a href="http://msdn.microsoft.com/en-us/arcjournal/cc505966.aspx" target="_blank"&gt;on line&lt;/a&gt;&lt;/em&gt;, &lt;a href="https://www.msarchitecturejournal.com/default.aspx" target="_blank"&gt;revista en papel&lt;/a&gt; y &lt;a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=dd466bbb-1b7d-438e-9f9a-954ce2058f15&amp;amp;displaylang=en" target="_blank"&gt;&lt;em&gt;reader&lt;/em&gt;&lt;/a&gt;). El tema de este trimestre es &lt;a href="http://msdn.microsoft.com/architecture/role" target="_blank"&gt;&lt;strong&gt;El Rol del Arquitecto&lt;/strong&gt;&lt;/a&gt;, que es algo que siempre da que hablar. Más allá de cualquier tema que podamos cubrir de arquitectura de software (SOA, SaaS, O/R-M, etc) el éxito de un enfoque arquitectónico no lo va a dar por sí solo su diseño sino las habilidades del arquitecto en transmitir una idea en forma convincente, generar adhesión y lograr apoyos (tanto de arriba -léase guita- como de abajo -mano de obra leal que haga lo que los planos decían-) 
&lt;p&gt;Al fin y al cabo, como decía el dicho, de carne somos y eso vale tanto para los arquitectos como para los que tienen que lidiar con ellos en el día a día (jefes de proyecto, gerentes de TI, desarrolladores, operadores, DBAs, jefes de seguridad informática, etc) 
&lt;p&gt;Por esta razón hemos liberado un &lt;a href="http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=2126&amp;amp;SiteID=1" target="_blank"&gt;nuevo foro de discusión sobre el &lt;strong&gt;Rol del Arquitecto&lt;/strong&gt;&lt;/a&gt;. La consigna del mismo no es debatir temas de &lt;a href="http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=228&amp;amp;SiteID=1" target="_blank"&gt;arquitectura en general&lt;/a&gt; (onda &amp;quot;qué me conviene, ADO.NET o NHibernate?&amp;quot;) -eso ya tiene &lt;a href="http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=228&amp;amp;SiteID=1" target="_blank"&gt;su foro&lt;/a&gt;- sino lo que vendrían a ser nuestros &lt;em&gt;soft skills&lt;/em&gt; como liderazgo, apertura intelectual, capacidad de aprendizaje y evolución, etc 
&lt;p&gt;Te recomiendo que afiles tus conocimientos de inglés y te pegues una vuelta. Se han armado unos debates bastante interesantes (&amp;quot;debe un arquitecto programar? cuánto?&amp;quot;, &amp;quot;cómo lidiar con el jefe cuando nos fuerza a hacer la arquitectura contemplando cosas que nunca hubieramos elegido?&amp;quot;, &amp;quot;por qué no se puede ser arquitecto apenas se sale de la facu?&amp;quot;) 
&lt;p&gt;Y muchas otras 
&lt;p&gt;  
&lt;p&gt;Oíme, haceme caso. No gastés guita en psicólogo y vení a discutir de estos temas &lt;a href="http://forums.microsoft.com/MSDN/ShowForum.aspx?ForumID=2126&amp;amp;SiteID=1" target="_blank"&gt;al foro&lt;/a&gt;. Como es de esperar, minitas no va a haber pero en eso al menos no estabas mejor en el psicólogo&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Arquitectos+al+Divan&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Management</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1452.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1452.entry</guid><pubDate>Fri, 09 May 2008 00:57:30 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1452/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1452.entry#comment</wfw:comment><dcterms:modified>2008-05-09T00:57:30Z</dcterms:modified></item><item><title>Consultorio Dr. Diegumoff. Hoy: Responsabilidades del Arquitecto</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1449.entry</link><description>&lt;p&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" border=0 alt="Hospitales_OK_1" src="http://blufiles.storage.msn.com/y1pHldoPC-Ru1h7iqQZwvRZm1ntnRX05nZwdOvJDsE0R2FoJzgndXv6kQW3ZS0hPefQMvmW9IcYswk?PARTNER=WRITER" width=466 height=273&gt;  &lt;br&gt;&lt;strong&gt;Parálisis de Diseño? Implementación Precoz? Consulte al Dr. Diegumoff&lt;/strong&gt; 
&lt;p&gt;  
&lt;p&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; Recibí &lt;/font&gt; una consulta interesante de Jorge, un lector del blog, docente de la carrera de computación científica en la Universidad de Ciencias Informáticas (Cuba). Preferí -previa autorización de él- llevar el caso en forma abierta, de modo que todos puedan dar su visión al respecto 
&lt;p&gt;  
&lt;div align=right&gt;
&lt;table border=1 cellspacing=3 cellpadding=3 width="90%"&gt;
&lt;tbody&gt;
&lt;tr bgcolor="#ffffff"&gt;
&lt;td valign=top width="90%"&gt;
&lt;p align=left&gt;&lt;b&gt;From:&lt;/b&gt; Jorge&lt;b&gt;&lt;br&gt;Sent:&lt;/b&gt; Friday, April 18, 2008 7:59 PM&lt;br&gt;&lt;b&gt;To:&lt;/b&gt; &lt;a href="mailto:diegum@hotmail.com"&gt;Diegum&lt;/a&gt; 
&lt;p align=left&gt;  
&lt;p align=left&gt;(...) 
&lt;p align=left&gt;Leí tu blog “Rol del arquitecto: Reglas del Juego” y coincido contigo en lo que comentas sobre los roles en la teoría y la asignación de los mismos en la práctica, lo cual lleva a que muchas veces no se defina bien dentro de un proyecto hasta donde llegan las responsabilidades del arquitecto y a veces algunas se queden sin cubrir. Pero me pregunto si entre las responsabilidades del arquitecto también caen la definición de los siguientes elementos: 
&lt;p align=left&gt;· Plataforma de desarrollo. 
&lt;p align=left&gt;· Sistemas Operativos. 
&lt;p align=left&gt;· IDE a usar. 
&lt;p align=left&gt;· Lenguaje de programación. 
&lt;p align=left&gt;· Herramienta de modelado. 
&lt;p align=left&gt;· Herramientas de control de versiones. 
&lt;p align=left&gt;· Herramienta de gestión del proyecto. 
&lt;p align=left&gt;· Estándares de información. 
&lt;p align=left&gt;· Estilos y patrones arquitectónicos. 
&lt;p align=left&gt;Esta pregunta se debe a que un alto cargo de la universidad esbozó esto como tareas del arquitecto y la verdad que no coincido con él en este sentido, incluso busqué en algunas metodologías de desarrollo y por ejemplo en RUP estas determinaciones forman parte del flujo de trabajo de Ambiente, y no le corresponden al arquitecto, menos la de estilo y patrones arquitectónicos. 
&lt;p align=left&gt;Saludos, y gracias de nuevo por permitirme contar contigo. 
&lt;p align=left&gt;Jorge.&lt;/tbody&gt;&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;  
&lt;p&gt;Estimado Jorge, el caso que se te planteó es de esas típicas discusiones donde todas las partes involucradas parecen tener algo de razón, lo que vuelve muy complicado de determinar quién está en errado y quién no &lt;img alt="smile_wink" src="http://spaces.live.com/rte/emoticons/smile_wink.gif"&gt; 
&lt;p&gt;Es muy probable que si afirmamos que sólo al arquitecto le cabe definir la plataforma de desarrollo, los sistemas operativos sobre los que la solución va a correr, elegir el IDE, etc, estemos equivocados. No obstante, sería falso también decir que al arquitecto no le cabe ningún rol en las decisiones a tomar en esos primeros puntos de la lista 
&lt;p&gt;La mano es así: arquitectos los hay con distinto nivel jerárquico, esto basado en su background, antigüedad en la empresa donde trabajan, antigüedad en la industria del software, etc. Asimismo, tenemos arquitectos de soluciones (que son los que vienen de haber programado durante varios largos años) y arquitectos de infraestructura (aquellos a los que les tocó instalar y mantener servidores, redes, puestos clientes y periféricos durante un lapso no menor) 
&lt;p&gt;Es muy raro -aunque no imposible- que te topes con alguien que la tenga clara en desarrollo y a la vez la tenga clara en infraestructura. Cuando te digo &amp;quot;tenerla clara en ambas cosas&amp;quot; no me refiero a saber Java y ser capaz de instalar Linux, sino a ser capaz de diseñar soluciones que corran en una plataforma definida por ellos y que la cosa escale así de repente todos los usuarios se decidieron a dar enter al mismo tiempo &lt;img alt="smile_wink" src="http://spaces.live.com/rte/emoticons/smile_wink.gif"&gt; 
&lt;p&gt;Seguramente que lo que dijo el profe pueda parecer exagerado si se lo vamos a asignar, dado un proyecto x de misión crítica, a una sola persona aunque lo probable es que sean definiciones a resolver entre dos o quizás más. Lo que sí me atrevo a asegurar es que varias de estas personas van a ostentar el rol de arquitecto (o arquitecto jefe, que es más bien un arquitecto que no participa en un proyecto dado sino que toma decisiones que afectan a todos los proyectos de la organización). Lo más probable es que estos arquitectos sean, algunos &amp;quot;de soluciones&amp;quot; (desarrollo) y otros &amp;quot;de infraestructura&amp;quot; 
&lt;p&gt;Si tengo que contar por mi caso personal (yo soy arquitecto de soluciones), hubo proyectos a los que me sumé y ciertas decisiones ya habían sido tomadas (S.O., Lenguaje de Programación, etc) y otras que aún quedaban &amp;quot;por tomar&amp;quot;. Para aquellas que aún estaban pendientes, como te contaba, no es que me tiraban toda la responsabilidad de la decisión a mí solo, sino que yo integraba un comité junto con otras personas 
&lt;p&gt;La mayoría de las veces, tal como tú lo sugieres, tuve voz pero no voto. Es decir, podía dar mi opinión pero la decisión quedaba en manos de alguien con &amp;quot;poder de compra&amp;quot;, sobre todo en aquellos casos en que la decisión implicase adoptar un producto con un modelo de licenciamiento lucrativo (que haya que pagar para poder usarlo, bah). Debo confesar acá que me frustraba que a veces mi opinión fuese ignorada (me carcomía la duda de para qué me convocaban a esos comités si luego iban a hacer lo que les pareciera. Pero, en fin, volviendo al punto y como cierre, no es que me tocara toda la responsabilidad a mí pero sí al menos una participación en la maduración de las ideas y los rumbos a tomar 
&lt;p&gt;Sin duda alguna que, no obstante, el grueso del proyecto lo iba a dedicar a &amp;quot;Estilos y Patrones Arquitectónicos&amp;quot;, el último punto que mencionó el profe y con el que sí estuviste de acuerdo 
&lt;p&gt;Saludos por la tierra del Ron&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Consultorio+Dr.+Diegumoff.+Hoy%3a+Responsabilidades+del+Arquitecto&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Management</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1449.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1449.entry</guid><pubDate>Mon, 05 May 2008 06:04:01 GMT</pubDate><slash:comments>2</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1449/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1449.entry#comment</wfw:comment><dcterms:modified>2008-05-09T01:00:47Z</dcterms:modified></item><item><title>Middle-Out: Un Gol de Media Cancha</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1438.entry</link><description>&lt;p&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; Los &lt;/font&gt; manuales suelen hablar de dos enfoques para abordar diseño de aplicaciones: el &lt;em&gt;&lt;strong&gt;top-down&lt;/strong&gt;&lt;/em&gt; (o &amp;quot;&lt;strong&gt;desde la cima hacia abajo&lt;/strong&gt;&amp;quot;) y el &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; (o &amp;quot;&lt;strong&gt;desde el fondo hacia arriba&lt;/strong&gt;&amp;quot;). Ambos enfoques son complementarios, no alternativos. Es decir, están pensados para ser ambos aplicados en un proyecto, no son dos tendencias antagónicas como ocasionalmente pueda verselo presentado. Veamoslo más en detalle 
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;&lt;em&gt;Top-down&lt;/em&gt;&lt;/strong&gt; es el enfoque &amp;quot;políticamente correcto&amp;quot; en el sentido que parte de premisas puramente organizacionales (o para no hacerme tanto el delicado, &amp;quot;necesidades de negocio&amp;quot;, bah; quise probar otra cosa porque siempre digo &amp;quot;&lt;em&gt;business needs&lt;/em&gt;&amp;quot; y ya suena un poco cacofónico pero al fin y al cabo, es eso). Se basa en un principio caro a las ciencias de la computación que es el de &amp;quot;&lt;strong&gt;divide y reinarás&lt;/strong&gt;&amp;quot; (&amp;quot;&lt;strong&gt;&lt;em&gt;divide and conquer&lt;/em&gt;&lt;/strong&gt;&amp;quot; en la bibliografía en inglés), donde se parte de un contexto macro que ciclicamente será descompuesto en sus partes constituyentes, éstas últimas en sus propias partes constituyentes y así sucesivamente hasta llegar a ciertos límites donde el proceso de introspección se detiene porque se ha logrado un modelo con cierto nivel de atomicidad tal que se pretende satisfacer con componentes ya disponibles (sean propios o de terceros, ya no es necesario &amp;quot;&lt;em&gt;&lt;strong&gt;reinventing the wheel&lt;/strong&gt;&lt;/em&gt;&amp;quot; o &lt;strong&gt;reinventar la rueda&lt;/strong&gt;. Es justamente llegados a este borde que el siguiente enfoque entra en juego 
&lt;li&gt;&lt;strong&gt;&lt;em&gt;Bottom-up&lt;/em&gt;&lt;/strong&gt; gana presencia una vez que los átomos consituyentes de las diversas capas de componentes han sido determinados. Entonces se sigue por asignar tecnologías (componentes, plataformas) como una forma de comenzar a desenmarañar la espiral de componentes en que &lt;em&gt;el modelo&lt;/em&gt; ha derivado. Y digo &amp;quot;comenzar&amp;quot; a resolver debido al &lt;em&gt;readiness&lt;/em&gt; de los componentes atómicos (qué tan listos para usar vienen). Normalmente va a ser aún menester el cumplimiento de tres etapas con los mismos: 
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Construcción&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;building&lt;/em&gt;&lt;/strong&gt;), para aquellos componentes planeados durante el &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; pero aún no disponibles 
&lt;li&gt;&lt;strong&gt;Configuración&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;customization&lt;/em&gt;&lt;/strong&gt;), de los grados de libertad que el componente habilita para permitir adaptarse a un grado amplio de necesidades de modo de pelear hasta donde se pueda &lt;a href="http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!460.entry" target="_blank"&gt;la batalla por la reusabilidad&lt;/a&gt;. Esta etapa transcurre especialmente durante el &lt;strong&gt;periodo de desarrollo&lt;/strong&gt; en el &lt;strong&gt;ciclo de vida&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;software development life cycle&lt;/em&gt;&lt;/strong&gt; o &lt;strong&gt;SDLC&lt;/strong&gt;) 
&lt;li&gt;&lt;strong&gt;Afinamiento&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;tuning&lt;/em&gt;&lt;/strong&gt;), especialmente durante el período de implementación -aunque empieza tímidamente al principio, desde la &lt;strong&gt;planificación de capacidad&lt;/strong&gt; (o &lt;strong&gt;&lt;em&gt;capacity planning&lt;/em&gt;&lt;/strong&gt;) cuando se presupuesta la carga que la solución pueda llegar a alcanzar. Desde luego que ninguna de estas dos etapa se enmarca estrictamente en una fase del ciclo de vida sino que tienen fases donde logran más protagonismo. Podría darse, como una consecuencia del &lt;strong&gt;&lt;em&gt;tuning&lt;/em&gt;&lt;/strong&gt;, que se termine revisando la &lt;strong&gt;customización&lt;/strong&gt; o la misma &lt;strong&gt;construcción&lt;/strong&gt; de los componentes&lt;/ul&gt;&lt;/ul&gt;
&lt;p&gt;Para los puristas metodológicos, esa secuencia de enfoques (&lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; y &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt;) era condición necesaria y suficiente para decir &lt;em&gt;alea jacta est&lt;/em&gt; (o &lt;em&gt;la suerte está echada&lt;/em&gt;, como cuando Julio César desafió la autoridad del senado romano cruzando el río Rubicón pese a las advertencias de que no siga avanzando, aunque algunos historiadores dicen que pronunció &lt;em&gt;alea jacta est&lt;/em&gt; queriendo significar &lt;em&gt;la jalea está hecha&lt;/em&gt; -al parecer a este Julio le tiraban los dulces-). Estaba contando que para algunas personas, esta forma de trabajo garantiza el éxito. Pero en la última década se comenzó a sospechar de que ya no. O, al menos, no necesariamente. A continuación voy a tratar de explicar cuáles son los vicios derivados, y a mostrar y explicar cuál es la alternativa que ha venido emergiendo victoriosa 
&lt;p&gt;  
&lt;p&gt;En principio el esquema planteado por estos dos enfoques ha venido asociado durante décadas a ciclos de vida en &lt;strong&gt;cascada&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;waterfall&lt;/em&gt;&lt;/strong&gt;). Esto es, una vez finalizada una etapa del ciclo de vida, ya no se volvería a ella hasta el final del proyecto (inflexibilidad de por sí arriesgadísima, como desde luego la experiencia se encargó de mostrar). Permiso aquí: no es que los promotores de &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt;/&lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; impusieran &lt;em&gt;waterfall&lt;/em&gt; sino que el &lt;em&gt;timeframe&lt;/em&gt; en que &lt;strong&gt;&lt;em&gt;top-down &lt;/em&gt;&lt;/strong&gt;y &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; fueron moneda corriente coincidió con la edad de oro del &lt;em&gt;waterfall&lt;/em&gt;. Y es que si bien estos dos enfoques se pueden aplicar a un proceso ágil, la dinámica &lt;em&gt;geeky&lt;/em&gt; impartida por este último (un diseño medio a mano alzada y a programar de una &lt;img alt="smile_teeth" src="http://spaces.live.com/rte/emoticons/smile_teeth.gif"&gt;) tornaría las sucesiones &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt;/&lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; algo toscas&lt;br&gt;Como fuera, la reputación de los procesos en cascada hoy viene (de la boca para afuera) de capa caída. En la práctica, luego de décadas de cascadas, torrentes y cataratas, la corriente del &lt;em&gt;waterfall&lt;/em&gt; todavía sigue tirando (es muy dificil romper esa cultura, sobre todo en las áreas gerenciales en que quieren ver una carta GANTT previsible -que a su vez deben presentar al directorio, si es por ellos, con que &lt;em&gt;funque&lt;/em&gt; da lo mismo-) 
&lt;p&gt;El esquema dual &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt;/&lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; también tuvo y tiene dificultades en hacer congeniar dos mundos: el de los líderes de TI y sus reportes. Generalmente son los líderes de TI o los líderes de los proyectos los que se encargan de la etapa &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt;, en tanto que los &lt;em&gt;developers&lt;/em&gt; y operadores (a veces conocidos como &lt;em&gt;profesionales de TI&lt;/em&gt; o &lt;em&gt;IT Pros&lt;/em&gt;) suelen llevar a cabo el &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; 
&lt;p&gt;&lt;em&gt;&lt;/em&gt;  
&lt;div align=right&gt;
&lt;table border=1 cellspacing=1 cellpadding=3 width="90%"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td bgcolor="#cccccc" valign=top width="100%" align=left&gt;&lt;em&gt;Se suele dar algo curioso con los arquitectos, que ya venía contando el mes pasado en mi post &amp;quot;&lt;a href="http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1420.entry" target="_blank"&gt;Reglas del Juego&lt;/a&gt;&amp;quot;. Dependiendo de la vereda en la que estén parados (si la del negocio mirando a la tecnología o si viceversa), tendrán una tendencia a participar en la etapa &lt;strong&gt;top-down&lt;/strong&gt; o en la &lt;strong&gt;bottom-up&lt;/strong&gt; respectivamente&lt;br&gt;Yo puedo decir que hoy estoy marcadamente tirado más al momentum del &lt;strong&gt;top-down&lt;/strong&gt; (o, dicho en otras palabras, cuando llega el momento de programar me borro &lt;img alt="smile_tongue" src="http://spaces.live.com/rte/emoticons/smile_tongue.gif"&gt;). En cambio, en mis tiempos como arquitecto Java EE -por aquellos días J2EE- me acuerdo que aunque creyera ser business-oriented, era eminentemente &lt;strong&gt;bottom-up&lt;/strong&gt;: no podía dejar de ver los sistemas en términos de APIs (APIs a las que dedicaba días y noches enteras en entender hasta el más mínimo detalle de sus capacidades &lt;img alt="smile_nerd" src="http://spaces.live.com/rte/emoticons/smile_nerd.gif"&gt;). Esto obviamente me desenfocaba a menudo la lente con la que debía mirar (y entender) el espacio del problema&lt;br&gt;Con todo, y a modo de conclusión, debo decir que un arquitecto debe participar tanto en la descomposición &lt;strong&gt;top-down&lt;/strong&gt; como en las decisiones a tomar durante la fase &lt;strong&gt;bottom-up&lt;/strong&gt;. Más allá de cuáles sean sus fuertes o qué le tire más, debe hacer el esfuerzo por desarrollar el otro hemisferio&lt;/em&gt;&lt;/tbody&gt;&lt;/table&gt;&lt;/div&gt;
&lt;p&gt;  
&lt;p&gt;Esto que me pasó y me sigue pasando, suele pasar en general y si le tengo que asignar un nombre, debería éste ser &amp;quot;la brecha entre &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; y &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt;&amp;quot; (&amp;quot;&lt;em&gt;&lt;strong&gt;top-down&lt;/strong&gt;/&lt;strong&gt;bottom-up&lt;/strong&gt; gap&lt;/em&gt;&amp;quot;, suena lindo, no? &lt;img alt="smile_shades" src="http://spaces.live.com/rte/emoticons/smile_shades.gif"&gt;) 
&lt;p&gt;  
&lt;table border=0 cellspacing=3 cellpadding=1 width="100%"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top&gt;&lt;img src="http://www.londonarchitecture.co.uk/Images/TheCity/TowerBridge-002.jpg"&gt; 
&lt;td valign=top width="100%"&gt;Figurativamente hablando, es como si ambos enfoques fuesen las dos secciones de un puente levadizo. No hace falta convencer a nadie de que sin una de esas secciones no habrá forma de cruzar el puente que lleve desde el espacio del problema hacia el de la solución. Pero aún estándo presentes, puede darse el caso de que las secciones no logran unirse. He aquí el famoso &lt;em&gt;gap&lt;/em&gt; o &lt;em&gt;brecha&lt;/em&gt; entre los dos enfoques&lt;br&gt;Algunas vez &lt;a href="http://liarjo.spaces.live.com/" target="_blank"&gt;Jotapé&lt;/a&gt; se refirió a esto en un &lt;a href="http://liarjo.spaces.live.com/blog/cns!4131EA552C5BB029!723.entry" target="_blank"&gt;&lt;em&gt;post&lt;/em&gt;&lt;/a&gt; recomendable. Él aborda el caso en que &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; no baja lo suficiente pero no es ciencia oculta imaginarse la otra cara del problema: un &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; demasiado centrado en sí mismo que no honra las necesidades por las cuales tuvo su &lt;em&gt;raison d'être&lt;/em&gt; (&lt;em&gt;merde!&lt;/em&gt; &lt;img alt="smile_omg" src="http://spaces.live.com/rte/emoticons/smile_omg.gif"&gt;)&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;  
&lt;p&gt;Como consecuencia de estos malestares, y quizás acompañando la caída en cáscada de los ciclos de vida &lt;em&gt;waterfall&lt;/em&gt;, un nuevo enfoque unificado ha emergido: &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; (&amp;quot;del centro hacia afuera&amp;quot;). &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; implica dar lugar a la experiencia que nos supimos ganar en tantos años de industria (por ende, si sos un recién llegado, no digo que no debas aplicar este enfoque pero quizás no vas a tener el suficiente marco de referencia), de manera tal que no vamos a partir desde el confín más &lt;em&gt;sui generis&lt;/em&gt; del espacio del problema sino que vamos a mezclar un cachito de lo que conocemos del problema con lo que la tecnología ya avisora como solución (patrones de arquitectura, de diseño, productos de mercado -sobre todo los que la organización ya adquirió y por ende ahora hay que amortizar si no queremos aparecer una mañana leyendo los clasificados de demanda de laburo &lt;img alt="smile_tongue" src="http://spaces.live.com/rte/emoticons/smile_tongue.gif"&gt;) 
&lt;p&gt;&lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; se para justo en esa mitad donde las dos secciones del puente se juntan, y avanza hacia sus extremos opuestos. Por eso mismo es fundamental lo que te decía de &amp;quot;la cancha&amp;quot; que es necesario tener para aplicar este enfoque: dónde está exactamente ese punto de unión? Sólo los que ya cruzaron varias veces estos puentes pueden saberlo con precisión 
&lt;p&gt;Se descrée que haya sido &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; el que provocó, como consecuencia, procesos de desarrollos ágiles. Más bien se considera que el enfoque &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; es una consecuencia de estos. Lo cierto es que caminan muy de la mano. El esquema iterativo e incremental de los procesos ágiles es el que permite, sea cual fuere el punto intermedio de partida, converger hacia las salidas (un &lt;em&gt;EXIT&lt;/em&gt; total &lt;img alt="smile_shades" src="http://spaces.live.com/rte/emoticons/smile_shades.gif"&gt;) 
&lt;p&gt;Lo que le da a &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; fortaleza para ganar adhesión en los estratos más altos de la gerencia es, a esta altura del partido, la percepción de que el espacio del problema no sólo no es -como regla general- del todo conocido por quienes definen la necesidad (las gerencias operativas y administrativas de la organización) sino que incluso aquello que si conocen puede cambiar de acuerdo a los vaivenes empresariales (impuestos reactivamente ante movidas de la competencia o proactivamente hacia nuevas oportunidades a encarar) 
&lt;p&gt;&lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; es, en realidad, algo que innatamente hacemos en las restantes cosas de la vida. Cuando tus amigos te proponen hacer un asado el finde les preguntás &amp;quot;quién lleva el vino?&amp;quot; siendo que no hubo un análisis desde el principio respecto de si los comensales toman alcohol, qué hacer en caso de que llueva, etc) y no hay nadie que esté, desde lo más abstracto, pensando en costo/beneficio de organizar un asado, etc 
&lt;p&gt;De todas maneras, no tengas dudas de eso, no es que &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; debe a partir de ahora ser el enfoque único y que la dupla &lt;em&gt;&lt;strong&gt;top-down&lt;/strong&gt;/&lt;strong&gt;bottom-up&lt;/strong&gt; &lt;/em&gt;pasan a mejor vida. Todavía existen escenarios donde estos enfoques van a prevalecer y en cambio &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; va a quedar descolocado. Te menciono algunos, a modo de cierre del &lt;em&gt;post&lt;/em&gt; 
&lt;ul&gt;
&lt;li&gt;El proyecto tecnológico comienza desde un análisis ya realizado en forma completa o casi completa por consultores. El &lt;em&gt;qué&lt;/em&gt; de la solución (o &lt;em&gt;el espacio del problema&lt;/em&gt;, si se quiere) ya se tiene claro y es posible que no cambie demasiado. Sólo resta completar con el &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; si bien es cierto que, en lo que respecta a nosotros, estamos empezando por el medio (pero no vamos a avanzar hacia arriba &lt;img alt="smile_wink" src="http://spaces.live.com/rte/emoticons/smile_wink.gif"&gt;) 
&lt;li&gt;Imaginate ahora un escenario similar al anterior pero donde además, antes de irse, los consultores esbozaron como parte de sus conclusiones una propuesta de implementación (tipo &amp;quot;orquestación Biztalk disparando contra el Oracle en un CICS, además de la base SQL local&amp;quot;) que fue aprobada por el comité ejecutivo del proyecto. Entonces te dan ahora la batuta a vos como arquitecto y... al menos la infraestructura ya no la vas a tener que definir porque alguien se encargó de pensar (no importa si bien o mal, la cosa es que ya lo hizo y le creyeron!! &lt;img alt="smile_tongue" src="http://spaces.live.com/rte/emoticons/smile_tongue.gif"&gt;). Te restará entonces definir la solución a montar en dicha infraestructura. Es por un lado limitado pero por el otro desestresante el no tener que decidir sobre absolutamente todo, creéme 
&lt;li&gt;Otro caso más que no sería &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; puro (aunque se le asemeja bastante) es el caso en que no hay aún una etapa &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; concretada... pero sí gran parte de la &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt;!! Que &lt;em&gt;cómo es eso&lt;/em&gt; me preguntás? La organización, luego de un excelente desempeño de labia de vendedores o consultores de una empresa externa, adquieren determinada infraestructura y definen que todo nuevo proyecto la va a usar (por los beneficios que dicho producto aporta), en tanto que viejos proyectos legados se irán migrando conforme se pueda a dicha plataforma. Como te contaba, no llega a ser un &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; 100% aunque podríamos decir que en tanto que no toda la infraestructura esté definida, empieza a tomar forma de 
&lt;ul&gt;
&lt;li&gt;Esto en verdad va a depender porque todavía la gerencia te podría indicar que, más allá de que parte del &lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; ya esté prefijado, a vos te toca partir desde el &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt; y no desde el medio. Si ése es el caso, no sería &lt;strong&gt;&lt;em&gt;Middle-Out&lt;/em&gt;&lt;/strong&gt; ni puro ni impuro: es &lt;strong&gt;&lt;em&gt;top-down&lt;/em&gt;&lt;/strong&gt;/&lt;strong&gt;&lt;em&gt;bottom-up&lt;/em&gt;&lt;/strong&gt; a la vieja usanza&lt;/ul&gt;&lt;/ul&gt;
&lt;p&gt;  
&lt;p&gt;Estimados, ha sido un placer y me despido hasta la próxima&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Middle-Out%3a+Un+Gol+de+Media+Cancha&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Management</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1438.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1438.entry</guid><pubDate>Mon, 21 Apr 2008 05:20:06 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1438/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1438.entry#comment</wfw:comment><dcterms:modified>2008-04-21T05:20:06Z</dcterms:modified></item><item><title>Identity Architectures (Arquitecturas de Identidad) - Call for Papers</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1425.entry</link><description>&lt;p&gt;&lt;font style="background-color:#ffc000" color="#ffffff" size=5 face="Lucida Handwriting"&gt; Hay &lt;/font&gt; un nuevo llamado para propuestas para el &lt;strong&gt;&lt;a href="http://msdn.microsoft.com/arcjournal"&gt;Journal de Arquitectura (#16)&lt;/a&gt;&lt;/strong&gt;. Como esa publicación es en idioma inglés, prefiero directamente referenciar al &lt;a href="http://blogs.msdn.com/diegumzone/archive/2008/04/05/microsoft-architecture-journal-issue-16-call-for-papers.aspx" target="_blank"&gt;aviso&lt;/a&gt; en la lengua de Shakespeare 
&lt;p&gt;  
&lt;p&gt;&lt;a title="http://blogs.msdn.com/diegumzone/archive/2008/04/05/microsoft-architecture-journal-issue-16-call-for-papers.aspx" href="http://blogs.msdn.com/diegumzone/archive/2008/04/05/microsoft-architecture-journal-issue-16-call-for-papers.aspx"&gt;http://blogs.msdn.com/diegumzone/archive/2008/04/05/microsoft-architecture-journal-issue-16-call-for-papers.aspx&lt;/a&gt; 
&lt;p&gt;  
&lt;p&gt;&lt;em&gt;Anyway&lt;/em&gt;, si te querés enterar antes que nadie de los futuros llamados, suscribite a este &lt;a href="http://www.microsoft.com/feeds/msdn/en-us/arcjournal/rss/rssCallForPapers.xml" target="_blank"&gt;feed&lt;/a&gt;: &lt;a title="http://www.microsoft.com/feeds/msdn/en-us/arcjournal/rss/rssCallForPapers.xml" href="http://www.microsoft.com/feeds/msdn/en-us/arcjournal/rss/rssCallForPapers.xml"&gt;http://www.microsoft.com/feeds/msdn/en-us/arcjournal/rss/rssCallForPapers.xml&lt;/a&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Identity+Architectures+(Arquitecturas+de+Identidad)+-+Call+for+Papers&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>The Architecture Journal</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1425.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1425.entry</guid><pubDate>Tue, 08 Apr 2008 20:27:49 GMT</pubDate><slash:comments>0</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1425/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1425.entry#comment</wfw:comment><dcterms:modified>2008-04-08T20:28:54Z</dcterms:modified></item><item><title>Sistemas de Alto Rendimiento: la Carrera por la Computación Paralela</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1424.entry</link><description>&lt;p&gt;&lt;font style="background-color:#002060" color="#ffffff" size=5 face=Garamond&gt; Es &lt;/font&gt; un hecho que hoy en día los equipos con dos procesadores son un estándar, y opcionalmente los hay de cuatro o más CPUs. Normalmente dos procesadores es la norma hoy en equipos &lt;em&gt;cliente&lt;/em&gt; o &amp;quot;&lt;em&gt;de escritorio&lt;/em&gt;&amp;quot; en tanto que más es norma para equipos &lt;em&gt;servidores&lt;/em&gt; 
&lt;p&gt;En estos casos se suele dar que las primeras aplicaciones que sacan provecho de estos avances son las de nivel más bajo como el sistema operativo o procesos servidores como el RDBMS (la base de datos, bah), etc 
&lt;p&gt;En una segunda oleada estos beneficios pasan a ser dejados a disposición del público masivo, como ya pasara con los procesadores gráficos que al principio quedaban accesibles sólo a través de APIs especiales como &lt;em&gt;DirectX&lt;/em&gt; y hoy cualquier mamerto con &lt;a href="http://msdn2.microsoft.com/en-us/netframework/aa663326.aspx" target="_blank"&gt;Windows Presentation Foundation&lt;/a&gt; pueden hacer aplicaciones que la gente diga &amp;quot;wow!&amp;quot; (lo de &amp;quot;&lt;em&gt;cualquier mamerto&lt;/em&gt;&amp;quot; va por mí: el &lt;a href="http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1247.entry" target="_blank"&gt;Architecture Journal Reader&lt;/a&gt;, canejo &lt;img alt="smile_shades" src="http://spaces.live.com/rte/emoticons/smile_shades.gif"&gt; jah!) 
&lt;p&gt;Que al comienzo las APIs sean realmente complejas obedece a dos razones: 
&lt;ul&gt;
&lt;li&gt;No están sus creadores lo suficientemente maduros en su entendimiento de las mismas como para poder ponerlo en términos más simples (para ello en realidad deben usarlas intensivamente de modo de extraer de esa experiencia las mejores prácticas), y 
&lt;li&gt;Como corolario de lo anterior, en cierto modo la idea es privar al público masivo de un acceso irrestricto hasta tanto no se vean formas de encapsular esos mejores usos en APIs que eviten provocar un malestar generalizado con estos avances&lt;/ul&gt;
&lt;p&gt;Pero lógicamente, ya va llegando el momento y por ende la idea es poder brindar a las plataformas de desarrollo actuales de estas herramientas que allanen la curva de aprendizaje 
&lt;p&gt;Asistimos en estos días a una carrera en el segmento de las plataformas administradas (tanto Java como .NET) para cumplimentar este objetivo. Para hacer honor al tema del &lt;em&gt;post&lt;/em&gt;, Paralelismo y Concurrencia, voy a enlistar lo que .NET y Java están armando al respecto en forma paralela y concurrente (jeh, soy un piola yo... &lt;img alt="smile_tongue" src="http://spaces.live.com/rte/emoticons/smile_tongue.gif"&gt;) 
&lt;p&gt;  
&lt;table border=1 cellspacing=1 cellpadding=1 width="100%"&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;
&lt;p align=center&gt;&lt;strong&gt;.NET Framework&lt;/strong&gt; 
&lt;td valign=top width="50%"&gt;
&lt;p align=center&gt;&lt;strong&gt;Java Standard Edition&lt;/strong&gt; 
&lt;tr&gt;
&lt;td valign=top&gt;
&lt;ul&gt;
&lt;li&gt;Se lanzó un &lt;a href="http://msdn2.microsoft.com/en-us/concurrency/default.aspx" target="_blank"&gt;portal MSDN para desarrolladores en Computación Paralela&lt;/a&gt; 
&lt;li&gt;El mismo tiene desde artículos introductorios, a contenido más específico al respecto (con ejemplos de código de lo que sería la futura API) 
&lt;li&gt;Esto va coronado con, para aquellos que quieran hacer pruebas de concepto (&lt;em&gt;proofs of concept&lt;/em&gt; o PoCs) con un &lt;a href="http://www.microsoft.com/downloads/details.aspx?FamilyID=e848dc1d-5be3-4941-8705-024bc7f180ba" target="_blank"&gt;&lt;em&gt;preview&lt;/em&gt; de &lt;strong&gt;PFX&lt;/strong&gt; (o &lt;strong&gt;Parallel Extensions for the .NET framework&lt;/strong&gt;)&lt;/a&gt; para extender &lt;u&gt;sobre&lt;/u&gt; .NET 3.5 (lo que da a entender que esta facilidad, de liberarse, será para una versión seguramente posterior) 
&lt;li&gt;También hay videos, donde no puedo dejar de recomendar &lt;a href="http://channel9.msdn.com/Showpost.aspx?postid=347531" target="_blank"&gt;el realizado por Anders Hejlsberg&lt;/a&gt;, gurú de los lenguajes de programación y padre de Delphi y C# 
&lt;li&gt;Entre otras cosas, también se puede ver cómo &lt;strong&gt;PFX&lt;/strong&gt; va a impactar en otras APIs existentes como LINQ (una API que facilita las consultas sobre colecciones de datos, sea que estos estén en memoria, en una tabla relacional, en un archivo XML o donde fuere). A esta unión lo he visto descripta como PLINQ (o &lt;em&gt;Parallel LINQ&lt;/em&gt;, a mal entendedor muchas palabras &lt;img alt="smile_regular" src="http://spaces.live.com/rte/emoticons/smile_regular.gif"&gt;)&lt;/ul&gt;
&lt;td valign=top&gt;
&lt;ul&gt;
&lt;li&gt;Para cuando la versión 5 de Java Standard Edition fue liberada (segunda mitad del 2004), una biblioteca (o &lt;em&gt;paquete&lt;/em&gt;, y que me perdonen en Chile &lt;img alt="smile_embaressed" src="http://spaces.live.com/rte/emoticons/smile_embaressed.gif"&gt;) llamada &lt;a href="http://java.sun.com/developer/technicalArticles/J2SE/concurrency/index.html" target="_blank"&gt;java.util.concurrent&lt;/a&gt; permitía sacar provecho de equipos multiprocesador aunque en forma indirecta: esta biblioteca contenía componentes que hacían uso de esa característica para que los programadores consuman dichos componentes (no para que créen los propios) 
&lt;li&gt;El Requerimiento de Especificación en que el comité que evoluciona la plataforma trabajó fue el &lt;a href="http://www.jcp.org/en/jsr/detail?id=166" target="_blank"&gt;JSR-166, Utilidades de Concurrencia&lt;/a&gt; 
&lt;li&gt;Ese mismo JSR está ahora siendo revisado para incluir facilidades que permitan programación concurrente en Java 7 (estimado para principios del 2009) 
&lt;li&gt;La estrategia se basa en dotar a Java de técnicas Fork/Join con la filosofía de descomponer un algoritmo complejo en partes secuenciales más simples, y analizar de éstas cuales en verdad no dependen mutuamente sino de otras partes en común (pero no entre sí) de modo que puedan paralelizarse 
&lt;li&gt;A quien se lo ve muy activamente trabajando en esto es a IBM, quien a través de su portal DeveloperWorks ha publicado &lt;a href="http://www.ibm.com/developerworks/java/library/j-jtp11137.html" target="_blank"&gt;dos artículos&lt;/a&gt; al respecto&lt;/ul&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;  
&lt;p&gt;Será hasta la próxima&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Sistemas+de+Alto+Rendimiento%3a+la+Carrera+por+la+Computaci%c3%b3n+Paralela&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Architecture</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1424.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1424.entry</guid><pubDate>Mon, 07 Apr 2008 21:42:04 GMT</pubDate><slash:comments>1</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1424/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1424.entry#comment</wfw:comment><dcterms:modified>2008-04-07T21:42:04Z</dcterms:modified></item><item><title>Rol del Arquitecto: Reglas del Juego</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1420.entry</link><description>&lt;p&gt;&lt;font style="background-color:#002060" color="#fafafa" size=5 face=Garamond&gt; Una &lt;/font&gt; de las principales razones por las que ha venido siendo tan dificil definir qué es un arquitecto es por la falta de acuerdo en cuanto a lo que un arquitecto debe hacer. Cómo distintas perspectivas le asignan a dicho rol distintas responsabilidades, por consiguiente el rol en sí mismo pasa a ser diferente según la perspectiva de donde se lo evalúe 
&lt;p&gt;Esto me empezó a dar vueltas en la cabeza estos últimos meses, ya que con &lt;a href="http://simonguest.com/" target="_blank"&gt;Simon&lt;/a&gt; estuvimos trabajando fuerte en el número 15 del &lt;em&gt;&lt;a href="http://www.architecturejournal.net/" target="_blank"&gt;Journal de Arquitectura&lt;/a&gt;&lt;/em&gt;, próximo a aparecer (*). El tema de este decimoquinto número es, justamente, el &lt;strong&gt;Rol del Arquitecto&lt;/strong&gt; 
&lt;p&gt;Como siempre hubo un &lt;em&gt;&lt;a href="http://msdn.microsoft.com/architecture/arcJournal/rssCallForPapers.xml" target="_blank"&gt;call for papers&lt;/a&gt;&lt;/em&gt; (que tuvo lugar durante el pasado mes de Enero), y varias propuestas fueron recibidas, de las que escogimos unas siete u ocho. De estas seleccionadas fueron luego llegando los primeros borradores, por lo que puedo decir que me he pasado el trimestre que va terminando dando vueltas cuan pollo al spiedo alrededor del bendito rol que nos toca jugar 
&lt;p&gt;Y lo que puedo anticipar de la edición que estás por recibir es que, como era de esperar, varios artículos se parecen entre sí en el sentido que hablan de un personaje con el que nos identificamos; pero al mismo tiempo discrepan entre sí, porque le atribuyen responsabilidades o conductas que nos puedan sonar cuestionables 
&lt;p&gt;Entonces pensé que, como siempre, el origen de las divergencias se remonta a la clásica subdivisión del perfil de arquitecto en 
&lt;ul&gt;
&lt;li&gt;&lt;strong&gt;Arquitecto Empresarial&lt;/strong&gt; (o &lt;strong&gt;Estratégico&lt;/strong&gt;) 
&lt;li&gt;&lt;strong&gt;Arquitecto de Desarrollo&lt;/strong&gt; (o &lt;strong&gt;Soluciones&lt;/strong&gt;) 
&lt;li&gt;&lt;strong&gt;Arquitecto de Infraestructura&lt;/strong&gt;&lt;/ul&gt;
&lt;p&gt;Yo asumo que esta subdivisión ya la manejás de taquito, pero si ése no es el caso, leéte &lt;a href="http://simonguest.com/blogs/smguest/archive/2005/12/12/Architect-Personas.aspx" target="_blank"&gt;este artículo de Simon&lt;/a&gt; que lo cuenta bastante claro 
&lt;p&gt;La clasificación no está mala y, sobretodo, no es algo que un solo &lt;em&gt;vendor&lt;/em&gt; impuso sino que hay no sólo un consenso en la industria: el framework de arquitectura conocido como TOGAF (&lt;em&gt;The Open Group Architecture Framework&lt;/em&gt;) considera cuatro Dominios de Arquitectura (&lt;em&gt;Architecture Domains&lt;/em&gt;). Estos son, a saber: 
&lt;ul&gt;
&lt;li&gt;&lt;a href="http://www.opengroup.org/architecture/togaf8-doc/arch/chap06.html" target="_blank"&gt;Arquitectura de Negocios (&lt;em&gt;Business Architecture&lt;/em&gt;)&lt;/a&gt;, mapeable al rol del Arquitecto Empresarial 
&lt;li&gt;&lt;a href="http://www.opengroup.org/architecture/togaf8-doc/arch/chap08.html" target="_blank"&gt;Arquitectura de Datos (&lt;em&gt;Data Architecture&lt;/em&gt;)&lt;/a&gt;, asociable -digamos- 65% al arquitecto de Infraestructura, 35% al de Soluciones 
&lt;li&gt;&lt;a href="http://www.opengroup.org/architecture/togaf8-doc/arch/chap09.html" target="_blank"&gt;Arquitectura de Aplicaciones (&lt;em&gt;Applications Architecture&lt;/em&gt;)&lt;/a&gt;, claramente terreno del Arquitecto de Desarrollo, y 
&lt;li&gt;&lt;a href="http://www.opengroup.org/architecture/togaf8-doc/arch/chap10.html" target="_blank"&gt;Arquitectura Tecnológica (&lt;em&gt;Tecnology Architecture&lt;/em&gt;)&lt;/a&gt;, la infraestructura propiamente tal&lt;/ul&gt;
&lt;p&gt;Pero no termina acá, también la IEEE a finales de los '90 dio forma a su especificación &lt;a href="http://www.iso-architecture.org/ieee-1471/index.html" target="_blank"&gt;IEEE 1471&lt;/a&gt; (forma corta de referirse a &lt;em&gt;Práctica Recomendada para la Descripción Arquitectónica de Sistemas de Software Intensivo&lt;/em&gt;), un estándar tanto ANSI como ISO. Esta especificación define Puntos de Vista (&lt;em&gt;Viewpoints&lt;/em&gt;) nuevamente asignables a los roles antes descriptos 
&lt;p&gt;  
&lt;p&gt;Y sin embargo... 
&lt;p&gt;  
&lt;p&gt;Esta taxonomía está bien para organizar información relacionada con estos -tomando prestado de TOGAF- dominios de arquitectura antes descriptos. Pero no tengo claro que en la práctica necesariamente se dé que haya, en una misma organización, arquitectos cubriendo estos roles. No estoy diciendo que esté bien que sea así o que esté mal, sino que en la medida en que estos roles van madurando, las organizaciones ya venían lidiando a su modo con las necesidades a cubrir. Como resultado, tenemos que 
&lt;ul&gt;
&lt;li&gt;Una misma persona cubre algunas actividades de uno o más roles, pero no todas las actividades que a ese rol le suelen asignar hoy los estándares 
&lt;li&gt;Un dado proyecto en una determinada organización puede requerir cierto nivel de cumplimiento con la definición de una arquitectura, pero a un nivel de detalle que puede resultar escaso según las normas de otra organización 
&lt;li&gt;Distintas organizaciones, partiendo de la base de que tienen distinto tamaño y diferente presupuesto de TI, lidian con distinto &lt;em&gt;headcount&lt;/em&gt; (cargos a cubrir disponibles). Como resultado, las tareas de arquitectura a realizar se van a asignar al personal disponible (nuevamente conduciendo a que la relación entre roles y personas termine siendo &lt;em&gt;cualquiera a cualquiera&lt;/em&gt; en lugar de 1:1, 1:n, m:n, etc&lt;/ul&gt;
&lt;p&gt;  
&lt;p&gt;Me siento lejos de la postura de decir que si en la práctica las cosas se dan así, es porque algo esté saliendo mal. Me ha tocado trabajar en proyectos donde ciertas decisiones que afectan a la arquitectura estaban ya tomadas (por ejemplo, &lt;em&gt;plataforma J2EE contra base de datos Oracle sobre ambiente Linux&lt;/em&gt;, etc). Siendo esas las circunstancias, un arquitecto de infraestructura tenía poco margen de acción en cuanto a tomar decisiones de plataforma se tratase. Sin embargo, aún le cabía un rol preponderante en el despliegue de la solución (y la asignación de procesos a servidores, etc). No obstante, en los hechos, esta actividad de infraestructura terminó en más de un caso siendo cubierta por el &amp;quot;arquitecto&amp;quot; (así, en genérico) que era también el que diseñaba la solución a desarrollar. Obviamente que no cualquier arquitecto de soluciones podía estar ducho en la infraestructura elegida de antemano, como para definir la mejor manera de montar la solución, pero justamente eso era lo que hacía que ciertos proyectos atraigan a cierta gente que habría quedado al margen en otros proyectos que compartieran ciertas similitudes y ciertas diferencias (por ejemplo, plataforma .NET disparando transacciones vía Host Integration Server contra un CICS el que, a su vez, accede a una base de datos DB/2) 
&lt;p&gt;  
&lt;p&gt;Podríamos concluir que los roles oficiales tienen aparejados una serie de actividades, pero que en la práctica de ese menú total de actividades habrá algunas que van a ser cubiertas en forma total, otras parcialmente y aún otras ignoradas 
&lt;p&gt;Estas actividades van a ser asignadas a diferentes arquitectos (en genérico) pero no necesariamente según rol sino considerando, en cada caso, el conocimiento que tengan del negocio y la cultura de la compañía, de la plataforma de desarrollo y de los ambientes de ejecución. En ese contexto, no va a ser descabellado aprovechar el &lt;em&gt;expertise&lt;/em&gt; de un miembro del proyecto en -digamos- aplicar sintonía fina (&lt;em&gt;fine tuning&lt;/em&gt;) a un esquema en Sybase, si bien su actividad principal sea la de definir y liderar el desarrollo de un framework de acceso a datos que encapsule la complejidad de APIs como JDBC o ADO.NET 
&lt;p&gt;Será tarea del líder de proyecto, en base a las circunstancias actuales del mismo, definir qué actividades de arquitectura estarán presentes y en qué grado, y a quién/es serán las mismas asignadas 
&lt;p&gt;____________________________________&lt;br&gt;&lt;font size=1&gt;(*) A propósito, desde el número 3 hasta el 14 (el actual) están disponibles en &lt;a href="http://msdn2.microsoft.com/en-us/arcjournal/bb201656.aspx" target="_blank"&gt;español&lt;/a&gt;&lt;/font&gt;&lt;img src="http://c.services.spaces.live.com/CollectionWebService/c.gif?cid=1933461980449276005&amp;page=RSS%3a+Rol+del+Arquitecto%3a+Reglas+del+Juego&amp;referrer=" width="1px" height="1px" border="0" alt=""&gt;&lt;img style="position:absolute" alt="" width="0px" height="0px" src="http://c.live.com/c.gif?NC=31263&amp;amp;NA=1149&amp;amp;PI=73329&amp;amp;RF=&amp;amp;DI=3919&amp;amp;PS=85545&amp;amp;TP=diegumzone.spaces.live.com&amp;amp;GT1=diegumzone"&gt;</description><category>Software Architecture</category><comments>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1420.entry#comment</comments><guid isPermaLink="true">http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1420.entry</guid><pubDate>Tue, 01 Apr 2008 05:36:07 GMT</pubDate><slash:comments>1</slash:comments><msn:type>blogentry</msn:type><live:type>blogentry</live:type><live:typelabel>Blog entry</live:typelabel><wfw:commentRss>http://diegumzone.spaces.live.com/blog/cns!1AD5096D63670065!1420/comments/feed.rss</wfw:commentRss><wfw:comment>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1420.entry#comment</wfw:comment><dcterms:modified>2008-04-01T05:49:13Z</dcterms:modified></item><item><title>Qué Debemos Recordar Sobre la Pérdida de Memoria (Memory Leaks)</title><link>http://diegumzone.spaces.live.com/Blog/cns!1AD5096D63670065!1401.entry</link><description>&lt;p&gt;&lt;strong&gt;Introducción: Pérdidas de Memoria en Java y .NET? Y el &lt;em&gt;Garbage Collector&lt;/em&gt;? Funca mal?&lt;/strong&gt;  
&lt;p&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;margin:0px 10px 0px 0px;border-right-width:0px" height=277 alt="Memory Leak" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1i2lLxWopMz7-vCcwDE42Av2k9DDsmVMl3RPdCirMDWDl74jDIMRBLqZ3N3zyC3M7I?PARTNER=WRITER" width=183 align=left border=0&gt;&lt;font style="background-color:#002060" face=Garamond color="#ffffff" size=5&gt; Se &lt;/font&gt; suponía que esta generación de lenguajes dentro del rango conocido como código administrado (&lt;em&gt;managed code&lt;/em&gt;) iba a terminar con el dolor de cabeza que habíamos padecido los que -sea en Pascal como en C o C++ o cualquier otro lenguaje que permitía referenciar memoria a través de punteros (&lt;em&gt;pointers&lt;/em&gt;)- tuvimos alguna vez que lidiar con manejo dinámico de memoria (esto es, pedirle memoria al sistema operativo y devolvérsela luego) 
&lt;p&gt;Sin embargo me decido a escribir este &lt;em&gt;post&lt;/em&gt; como respuesta a varias preguntas que he venido recibiendo de amigos que trabajan, sea con Java o con .NET, y que están padeciendo un problema que ellos pensaban que desde el &lt;em&gt;vamos&lt;/em&gt; iba a estar superado 
&lt;p&gt;Partamos por la definición: una &lt;strong&gt;pérdida de memoria&lt;/strong&gt; (en inglés aparece como &lt;strong&gt;&lt;em&gt;memory leak&lt;/em&gt;&lt;/strong&gt; o &lt;em&gt;fuga de memoria&lt;/em&gt;) es una situación que se produce cuando la aplicación no devuelve al sistema operativo franjas de memoria que ya tampoco va a usar. Generalmente con el agravante de que siendo que los datos en esa memoria son ya residuales, de necesitar espacio para nuevos datos, la aplicación va a pedir más memoria al sistema operativo al no considerar que tiene total o parcialmente espacio para alojar esta información 
&lt;p&gt;Las pérdidas de memoria normalmente son procedurales. Es decir, la aplicación en la forma en que está programada, pierde memoria en forma sistemática de manera tal que nueva memoria solicitada al sistema operativo es también pasible de ser total o parcialmente perdida. De esta manera, dependiendo de la memoria original disponible, de la ocupada por procesos concurrentes, etc, siempre me alucino con la idea de que en algún momento el sistema operativo me saque una caja de diálogo como la siguiente 
&lt;p align=center&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=352 alt="Sin memoria" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1gT20JdgiHL-LcUK3LQPqv6HjUQpVn7TcPp6OdS9T3Xng6m_SuupgR18pSOfJXx1iM?PARTNER=WRITER" width=565 border=0&gt; 
&lt;p&gt;La caja de diálogo de recién es una broma, claro. En cambio, lo que sí los sistemas operativos suelen hacer es asignar &lt;em&gt;quantums&lt;/em&gt; de memoria a las diferentes aplicaciones, y aquellas que pasan cierto umbral de memoria requerida en un cierto tiempo son pasibles de ser penalizados por el sistema operativo, que puede comenzar por relegarlos a &lt;em&gt;swappear&lt;/em&gt; (&amp;quot;intercambiar&amp;quot;, del inglés &lt;em&gt;swapping&lt;/em&gt;) su memoria entre almacenamientos primario y secundario, siguiendo por bajarles la prioridad de ejecución -para no pagar el mismo sistema operativo la penalización por &lt;em&gt;swapping&lt;/em&gt;, ya que ese tiempo de intercambio se considera tiempo de ejecución del sistema operativo, no de la aplicación- hasta finalmente decirle a la aplicación su merecido &amp;quot;no va másssssss&amp;quot; como en la ruleta 
&lt;p&gt;Esto último, los que programaron en Java lo recibieron en la forma de un &lt;font face="Courier New"&gt;java.lang.OutOfMemoryError&lt;/font&gt;, parecido al &lt;font face="Courier New"&gt;System.OutOfMemoryException&lt;/font&gt; de .NET -quiero destacar la riqueza expresiva de Java, que reconoce a los errores (&lt;font face="Courier New"&gt;java.lang.Error&lt;/font&gt;) como una categoría separada de las excepciones (&lt;font face="Courier New"&gt;java.lang.Exception&lt;/font&gt;); una excepción es eventualmente atajable (&lt;font face="Courier New"&gt;catch&lt;/font&gt;) en cambio un error implica un fallo fatal y la ejecución finaliza allí. Tal distinción no tiene paralelo en .NET- 
&lt;p&gt;Ahora bien, las plataformas Java y .NET son entornos de ejecución administrados que cuentan con un &lt;strong&gt;recolector de basura&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;garbage collector&lt;/em&gt;&lt;/strong&gt;). La idea del mismo -las implementaciones difieren algo- es detectar direcciones de memoria inalcanzables (por ejemplo, una variable local que se creo dentro de un bucle cuya ejecución ya quedó atrás; la variable es local al bucle y por consiguiente ya no hay forma de alcanzarla, ni siquiera definiendo otra variable con el mismo nombre o, si acaso, volviendo a ejecutar el bucle). A &lt;em&gt;grosso modo&lt;/em&gt;, el recolector devolvería al sistema operativo esa memoria que venía siendo referenciada por variables que se quedaron fuera de &lt;em&gt;scope&lt;/em&gt; aunque, en la práctica, a quien se la devuelve es a su propio montículo (&lt;em&gt;heap&lt;/em&gt;) de memoria por si más adelante la fuera a necesitar. A su vez, sí, el montículo de la aplicación puede crecer o decrecer (pidiendo y liberando memoria al sistema operativo) pero en otros intervalos que los de la frecuencia del recolector 
&lt;p&gt;Con esto dicho, el programador entonces no se entera de cómo la memoria es adquirida o devuelta por lo que si la aplicación toma ese recurso y luego no lo devuelve, todas las miradas se dirigen al entorno administrado (&lt;em&gt;Java VIrtual Machine&lt;/em&gt; o JVM en la plataforma Java, &lt;em&gt;Common Language Runtime&lt;/em&gt; o CLR en el caso de .NET). Y sin embargo, no: rebobinemos un poco la cinta hacia el párrafo anterior. Allí decía &amp;quot;la idea del recolector de basura es &lt;strong&gt;detectar direcciones de memoria inalcanzables&lt;/strong&gt;&amp;quot; 
&lt;p&gt;Ahí está el &lt;em&gt;quid&lt;/em&gt; de la cuestión. En la medida en que instancias de objetos creadas sean alcanzables. Si los métodos que crearon estas instancias han devuelto referencias a las mismas, y a su vez dichas referencias fueron almacenadas como propiedades de otros objetos que son alcanzables, por transitividad las instancias creadas son también alcanzables. Ergo, si nuestras aplicaciones empiezan a dragar memoria en forma descontrolada, debo ser el portavoz de la mala noticia de que no vamos a poder irnos silbando bajito tan fácil Acá debo defender al gremio de los grandes distribuidores de plataforma: no es una falencia de la JVM o del CLR el no detectar que esta memoria de la que hablamos se debía haber liberado. Estos entornos de ejecución operan en una forma deterministica: es alcanzable, no se libera; no es alcanzable, se libera. Sin vueltas. El resto depende de nos, desarrolladores de software 
&lt;p&gt;Escribo esto y me viene a la memoria la típica reacción que he visto en desarrolladores cuando sienten que la aplicación no libera memoria en la proporción que esperarían: forzar la llamada al recolector de basura. Esto al menos en la plataforma .NET no va a sino empeorar las cosas, como voy a mostrar a continuación 
&lt;p&gt;  
&lt;p&gt;&lt;strong&gt;Cómo Trabaja el Recolector de Basura&lt;/strong&gt; 
&lt;p&gt;La memoria de una aplicación .NET está organizada en varios segmentos. Uno de ellos, particularmente, es el llamado &amp;quot;segmento de memoria administrada&amp;quot; que es aquella que es reservada y liberada directamente por el CLR (en contraposición a otros segmentos, como el de &amp;quot;memoria primitiva&amp;quot; o &amp;quot;no administrada&amp;quot; que es el segmento de la memoria que el mismo CLR reserva para sí -la que él necesita para ejecutar nuestra y otras aplicaciones- y también aquella memoria que nuestra aplicación reserva en forma directa, por ejemplo en C++ o C#, mediante llamadas explícitas al sistema operativo). Pero volvamos al que nos interesa, el segmento de memoria administrada: 
&lt;p&gt;En el mismo, a su vez, el montículo se organiza en &lt;em&gt;generaciones&lt;/em&gt;. Esto es, por diseño, el CLR asume que si un objeto sobrevivió un determinado período de tiempo, entonces es probable que sobreviva por algún tiempo más. De esta manera, cualquier nuevo objeto que es creado se dice que pertenece a la &lt;em&gt;generación 0&lt;/em&gt;, cuyo tiempo de vida se presume limitado. Entonces en un dado momento el CLR se va a encontrar con que el montículo no tiene memoria suficiente contigua para el siguiente comando &lt;font face="Courier New"&gt;new&lt;/font&gt;. Como consecuencia el hilo del recolector de basura se va a despertar y va a buscar en la generación 0 aquellos objetos que ya no sean alcanzables por la aplicación (variables fuera de &lt;em&gt;scope&lt;/em&gt;, etc, lo que te contaba antes). La memoria ocupada por esos objetos no alcanzables es desasignada y todo el segmento de esta generación es compactado. Pero los sobrevivientes son inmediatamente movidos al segmento de la &lt;em&gt;generación 1&lt;/em&gt;, por esto que te decía que el CLR presume que si zafaron es porque van a vivir un tiempo más. La generación 1 es también recolectada, pero sólo si tratar de liberar memoria en la generación 0 no produjo lo suficiente. Aún así, cuando haya recolección en la generación 1, la memoria de objetos no alcanzables será -nuevamente- desasignada y los que sobrevivan se asumirá que pueden llegar a durar un tiempo más por lo que serán movidos a la &lt;em&gt;generación 2&lt;/em&gt;. Podríamos decir &amp;quot;y así sucesivamente&amp;quot; pero no: no hay más generaciones que la 0, la 1 y la 2. La generación 2 tiene la frecuencia de recolección más baja (sólo si recolectar en las generaciones previas no consiguió lo suficiente) y para los objetos que zafan, en esta generación, su memoria es compactada 
&lt;p&gt;Si nuestra aplicación está perdiendo memoria como consecuencia de no soltar todas las referencias a objetos que ya no van a usarse, forzar la llamada al recolector no va a sino agudizar el problema: por un lado, no va a recuperar la memoria de objetos indebidamente alcanzables por lo que la falencia original persistirá; pero aparte va a acortar cambios generacionales innecesaria e improductivamente, con impacto -claro- en el rendmiento general. A esto se le ha dado el curioso nombre de &amp;quot;&lt;strong&gt;crisis de los 40&lt;/strong&gt;&amp;quot; (&lt;strong&gt;&lt;em&gt;midlife crisis&lt;/em&gt;&lt;/strong&gt;) o como la canción de Jethro Tull, &amp;quot;&lt;em&gt;demasiado viejo para el rock, demasiado joven para morir&lt;/em&gt;&amp;quot;. El tema es que la llamada prematura hace que objetos que en cualquier otra circunstancia no hubieran salido de la generación 0, acá terminan en la 1 o la 2 ya que la alta frecuencia de intervención del recolector los soprende todavía &amp;quot;alcanzables&amp;quot; (por ende, por lo que contaba antes, pasan a la generación siguiente). Mover objetos entre generaciones es caro: esos ciclos de CPU los podrían aprovechar hilos efectivos de la aplicación. No debemos olvidar acá que no es sólo cuestión de copiar bytes entre segmentos sino también compactar a los mismos. Todo eso es CPU sólo para una tarea administrativa 
&lt;p align=right&gt;
&lt;table cellspacing=0 cellpadding=5 width="90%" align=right border=1&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="100%"&gt;
&lt;p align=left&gt;&lt;em&gt;Llamar al recolector en forma explícita mediante &lt;/em&gt;&lt;font face="Courier New"&gt;&lt;strong&gt;GC.Collect()&lt;/strong&gt;&lt;/font&gt;&lt;em&gt; va a correr en el mismo hilo de ejecución en que se estaba ejecutando el método que contiene esta llamada. Por consiguiente, la instrucción siguiente al pedido de recolección no va a ser ejecutada hasta que la recolección finalice&lt;/em&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;  
&lt;p&gt;  
&lt;p&gt;Y hay algo aún peor que la &amp;quot;crisis de los 40&amp;quot;, en lo que a forzar recolección en escenarios de pérdida se trata: en la medida en que no haya mucho para recolectar, el recolector igual se tuvo que barrer todos los objetos para conocer cuántas referencias alcanzables por dominios de aplicación tenían 
&lt;p align=right&gt;
&lt;table cellspacing=0 cellpadding=5 width="90%" align=right border=1&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="100%"&gt;
&lt;p align=left&gt;&lt;em&gt;El algoritmo no es trivial: no es cuestión de tener una tabla con referencias porque puede pasar que tengamos una serie de objetos que se referencian circularmente, pero que ese circuito no sea alcanzable; sin embargo cada elemento del grafo tiene al menos alguna referencia. Detectar tales circuitos es parte del cuento (y todo es, nuevamente, CPU)&lt;/em&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p align=left&gt;  
&lt;p align=left&gt;  
&lt;p align=left&gt;Veamos todo esto en la práctica. Acá tengo la siguiente aplicación: por un lado tenemos una clase que vamos a invocar desde el resto de la aplicación (llamemosla, por ende, &lt;font face="Courier New"&gt;Invocado&lt;/font&gt;). &lt;font face="Courier New"&gt;Invocado&lt;/font&gt; se define como sigue 
&lt;p align=left&gt;
&lt;table cellspacing=0 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="100%" bgcolor="#ffff80"&gt;&lt;pre&gt;    &lt;span style="color:rgb(0,0,255)"&gt;class&lt;/span&gt; &lt;span style="color:rgb(43,145,175)"&gt;Invocado
&lt;/span&gt;    {&lt;br&gt;        &lt;span style="color:rgb(0,128,0)"&gt;// contador de invocaciones a lo largo de la vida de la instancia&lt;br&gt;&lt;/span&gt;        &lt;span style="color:rgb(0,0,255)"&gt;int&lt;/span&gt; cantLlamadas = 0;

        &lt;span style="color:rgb(0,0,255)"&gt;public&lt;/span&gt; &lt;span style="color:rgb(0,0,255)"&gt;string&lt;/span&gt;[] Invocar()
        { 
            &lt;span style="color:rgb(0,0,255)"&gt;string&lt;/span&gt;[] arregloARetornar = &lt;span style="color:rgb(0,0,255)"&gt;new&lt;/span&gt; &lt;span style="color:rgb(0,0,255)"&gt;string&lt;/span&gt;[1000];

            &lt;span style="color:rgb(0,128,0)"&gt;// se actualiza el contador de invocaciones
&lt;/span&gt;            ++cantLlamadas;

            &lt;span style="color:rgb(0,0,255)"&gt;for&lt;/span&gt; (&lt;span style="color:rgb(0,0,255)"&gt;int&lt;/span&gt; i = 0; i &amp;lt; arregloARetornar.Length; i++)
            {
                arregloARetornar[i] = &lt;span style="color:rgb(163,21,21)"&gt;&amp;quot;Iteración &amp;quot;&lt;/span&gt;+ cantLlamadas+ &lt;span style="color:rgb(163,21,21)"&gt;&amp;quot;; Elemento &amp;quot;&lt;/span&gt;+ i;
            }

            &lt;span style="color:rgb(0,0,255)"&gt;return&lt;/span&gt; arregloARetornar;
        }
    }&lt;/pre&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;Basicamente, tiene un método, &lt;font face="Courier New"&gt;Invocado.Invocar()&lt;/font&gt;, que crea un arreglo básico de mil cadenas de caracteres y las inicializa a todas con un texto unívoco (conteniendo la invocación general al método y el número de &lt;font face="Courier New"&gt;string&lt;/font&gt; creado). Este arreglo con todos sus elementos, es devuelto al llamador 
&lt;p&gt;Paremos la película acá: el arreglo creado, con todos sus elementos, es devuelto al llamador 
&lt;p&gt;Lo que el llamador recibe, en verdad, es una referencia al arreglo. Si el llamador, luego de recibirla y procesarla, se deshace de esa referencia, tenemos la plena seguridad de que ese arreglo con todos sus elementos va a quedar disponible para que el recolector de basura lo levante (y, como conté anteriormente, eso va a pasar en la medida en que el recolector pase por la generación en que este objeto ya no referenciado se encuentre: si liberó memoria suficiente en generaciones anteriores, este objeto amigo va a &lt;em&gt;sobrevivir&lt;/em&gt;) 
&lt;p&gt;  
&lt;p&gt;La clase que sigue es la que va a llamar a la que vimos recién. Por consiguiente la voy a llamar &lt;font face="Courier New"&gt;Invocador&lt;/font&gt;. La misma tiene un método, &lt;font face="Courier New"&gt;Invocador.Comenzar()&lt;/font&gt;, que va a gatillar la creación de una instancia de &lt;font face="Courier New"&gt;Invocado&lt;/font&gt;, cuyo método &lt;font face="Courier New"&gt;Invocado.Invocar()&lt;/font&gt; va a ser llamado cien veces 
&lt;p&gt;
&lt;table cellspacing=0 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="100%" bgcolor="#ffff80"&gt;&lt;pre&gt;    &lt;span style="color:rgb(0,0,255)"&gt;class&lt;/span&gt; &lt;span style="color:rgb(43,145,175)"&gt;Invocador
&lt;/span&gt;    { 
        &lt;span style="color:rgb(43,145,175)"&gt;List&lt;/span&gt;&amp;lt;&lt;span style="color:rgb(43,145,175)"&gt;String&lt;/span&gt;[]&amp;gt; listaResultados = &lt;span style="color:rgb(0,0,255)"&gt;new&lt;/span&gt; &lt;span style="color:rgb(43,145,175)"&gt;List&lt;/span&gt;&amp;lt;&lt;span style="color:rgb(0,0,255)"&gt;string&lt;/span&gt;[]&amp;gt;();
&lt;font color="#0000ff"&gt;&lt;/font&gt;
        &lt;span style="color:rgb(0,0,255)"&gt;public&lt;/span&gt; &lt;span style="color:rgb(0,0,255)"&gt;void&lt;/span&gt; Comenzar()
        { 
            &lt;span style="color:rgb(43,145,175)"&gt;Invocado&lt;/span&gt; invocado = &lt;span style="color:rgb(0,0,255)"&gt;new&lt;/span&gt; &lt;span style="color:rgb(43,145,175)"&gt;Invocado&lt;/span&gt;();&lt;br&gt;            &lt;span style="color:rgb(0,0,255)"&gt;string&lt;/span&gt;[] resultados;

            &lt;span style="color:rgb(0,0,255)"&gt;for&lt;/span&gt; (&lt;span style="color:rgb(0,0,255)"&gt;int&lt;/span&gt; i = 0; i &amp;lt; 100; i++)
            {
&lt;span style="color:rgb(0,0,255)"&gt;#if&lt;/span&gt; RECOLECTANDO
&lt;span style="color:rgb(128,128,128)"&gt;                GC.Collect();
&lt;/span&gt;&lt;span style="color:rgb(0,0,255)"&gt;#endif

&lt;/span&gt;                resultados = invocado.Invocar();

                &lt;span style="color:rgb(0,128,0)"&gt;// El arreglo de strings (con todas sus referencias), se enlista
&lt;/span&gt;                &lt;span style="color:rgb(0,128,0)"&gt;// (de modo que no serán elegibles para recolección)
&lt;/span&gt;                listaResultados.Add(resultados);
&lt;span style="color:rgb(0,0,255)"&gt;
&lt;/span&gt;                &lt;span style="color:rgb(0,128,0)"&gt;// Recorremos el arreglo resultante haciendo &amp;quot;algo&amp;quot; con sus
&lt;/span&gt;                &lt;span style="color:rgb(0,128,0)"&gt;// elementos (en este caso, mostrarlos por consola)
&lt;/span&gt;                &lt;span style="color:rgb(0,0,255)"&gt;for&lt;/span&gt; (&lt;span style="color:rgb(0,0,255)"&gt;int&lt;/span&gt; j = 0; j &amp;lt; resultados.Length; j++)
                {
                    &lt;span style="color:rgb(43,145,175)"&gt;Console&lt;/span&gt;.WriteLine(resultados[j]);
                }
            }
        }
    }&lt;/pre&gt;&lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;Lo que es interesante de apreciar en este ejercicio es que &lt;font face="Courier New"&gt;Invocador&lt;/font&gt; habilita compilación condicional según que queramos forzar recolección de basura. El símbolo condicional es &lt;font face="Courier New"&gt;RECOLECTANDO&lt;/font&gt; 
&lt;p&gt;Si te fijás en el código, más arriba, por un &amp;quot;presunto&amp;quot; error de diseño las llamadas a &lt;font face="Courier New"&gt;Invocado.Invocar()&lt;/font&gt; se van acumulando en &lt;font face="Courier New"&gt;listaResultados&lt;/font&gt;. Cada elemento de &lt;font face="Courier New"&gt;listaResultados&lt;/font&gt; es un vector de 1000 &lt;font face="Courier New"&gt;string&lt;/font&gt; por lo cual, mientras &lt;font face="Courier New"&gt;listaResultados&lt;/font&gt; sea accesible, sus 100 &lt;font face="Courier New"&gt;string[]&lt;/font&gt; son accesibles y, por cada uno de estos 100 &lt;font face="Courier New"&gt;string[]&lt;/font&gt;, sus 1000 &lt;font face="Courier New"&gt;string&lt;/font&gt; son accesibles. En otras palabras, como &lt;font face="Courier New"&gt;listaResultados&lt;/font&gt; va a ser alcanzable durante casi toda la ejecución, sumemos las referencias a 100 &lt;font face="Courier New"&gt;string[]&lt;/font&gt; (vamos 101 referencias) y 100.000 (cien mil) &lt;font face="Courier New"&gt;string&lt;/font&gt;. Total: 100.101 (cien mil ciento un) referencias visibles simultáneamente para cuando la aplicación termine 
&lt;p&gt;  
&lt;p&gt;Pues bien, en lo que sigue vamos a comparar dos corridas: ambas perdiendo memoria pero una de ellas dejando que la recolección se dé espontaneamente en tanto que la otra la va a forzar en cada iteración. Para ello me valí de una facilidad de Windows que es el tradicional &lt;strong&gt;Monitor de Rendimiento&lt;/strong&gt; (&lt;strong&gt;&lt;em&gt;Performance Monitor&lt;/em&gt;&lt;/strong&gt;). Si no estás familiarizado con el mismo, dejame contarte que es una herramienta súper útil para ver qué pasa con la salud de tu aplicación. Vale 0 (cero, o &lt;em&gt;huevo&lt;/em&gt; como dirían en Chile). Es parte del sistema operativo y no sólo tiene varios grupos de parámetros a monitorear sino que además te permite monitorear equipos remotos! Como si fuera poco, &lt;a href="http://msdn2.microsoft.com/en-us/architecture/aaaxk5bx.aspx" target="_blank"&gt;vos mismo podés definir tus propios paquetes de parámetros monitoreables&lt;/a&gt;. Pero veamos ahora qué pasó con nuestra aplicación, comparando recolección por defecto versus recolección forzada: 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jat0UIptKkrFuTfzAh-IC33hZsSSEOV2zsMMD_IotBmFLFZ1LW-tlK0dWuMshbaoE?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="# Bytes in all Heaps" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jx68q546sZPjxrfdAh6-Q_DcmTl-4YArgdF_tqTguKEx9Lf-1L3hFgvcJ09C6orK4?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1hwHis3BMnne8rclOqTSmNB_eU9ZhK8ylwlMBbFRtTaYkFVaPqOzDLVbMU1USylVgY?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="# Bytes in all Heaps" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1ja9Y3sy2CMSzG2zZOuBGFP6FY-y-lhmoaJhsNleUm5EMtA9k5DHIVIcBeAj8ijpts?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Tamaño del montículo de memoria administrada a lo largo de la ejecución (&lt;em&gt;# Bytes in all Heaps&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; 
&lt;p&gt;A la izquiera tenemos el perfil de ejecución que no fuerza la recolección. Curiosamente, y esto no es que pase siempre sino en este particular caso donde la aplicación pierde memoria, forzar la recolección no hace sino que la aplicación consuma más memoria. Re loco, no? Puede llegar a llevar a la errónea conclusión de que forzar la llamada al recolector hace que siempre una aplicación consuma más pero tampoco es que sea así: esta aplicación, lo sabemos, &lt;strong&gt;pierde memoria en la medida en que mantiene &amp;quot;vivas&amp;quot; referencias a objetos no utilizados&lt;/strong&gt;. Ergo, llamar al recolector para que se haga cargo de una situación en la que poco puede intervenir es como llamar al pintor para que nos pinte una pared que se arruinó por la humedad, sin hacer ningún tratamiento a este último problema 
&lt;p&gt;Llamar al recolector explícitamente no es gratis: si vos lo llamás, claro está, el tipo va a venir y su hilo va a competir por la CPU contra el resto de los hilos del proceso (y, a su vez, el proceso de esta aplicación respecto de sus pares). En el gráfico que viene vas a ver cómo esto se refleja 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1hMqfkRCV6Gi0FEb9efr_HiRtAcCSX9ztj9BA2F43FIcXuYRPFv2kWy7WBROWSseWI?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="% Time in GC" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1igzak1c45Zu4N4e_EXtzLft2w2oCZv8kJtZBgDsaQ2pM35NEwtuszwIJ_qCMO9p54?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jTuLUZAkyjmJt96SmrLlkhCQ0sxzx6Bo0FTmZul4s8po6AmuraYI1l5BUGo2cCEBM?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="% Time in GC" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jL98HJov7lno-bkZGEzRtemoBOlIeIj2DiuZ67oqu5omDF2Q07ErGwoNEghZa8uqI?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Porcentaje de uso de CPU que se lleva el recolector de basura por sobre el total del CLR (&lt;em&gt;% Time in GC&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; 
&lt;p&gt;Si te fijás en el gráfico de la derecha, es decir forzando recolección, vas a ver que el share que el recolector se come en la pizza es incrementalmente mayor (el eje horizontal es el tiempo). La explicación de esa participación incremental es que el pobre recolector se tiene que recorrer un número incremental de elementos (aquellos que hacia el final van a totalizar 100.101) sólo para darse cuenta que no hay nada que hacer con ellos porque son alcanzables 
&lt;p&gt;Si miramos, en cambio, qué pasa sin forzar recolección, la intervención del recolector se mantiene moderadamente baja, excepto un &lt;em&gt;peek&lt;/em&gt; que se produce casi al final. Y esto se puede ver mejor si contamos, para cada generación, cuántas recolecciones efectivas se llegaron a hacer en las mismas 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1i1m7iAZaEU27RB2lmNC_q1HxOsVIEiDCsKO5vdQmEkL-JOx4GzemHqrRMDKiNfhPc?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="# Gen x Collections" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1iEc8NkPig8UB0mHPTMGKCSRuqHnciX_KvwsTaK1MXu05r-gEHvSDrGBTE2jqmPxXE?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jtFKIgchvSggwLRBn_iVS4sVOHEEtR4ApkizVKjosxyPm2pXrl1hBEnltqieQDBto?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="# Gen x Collections" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1hrIYPjneyLrqVta3g1YwwRsckS5QhzrAid_VwgN9pmxeVwgi0z7YZXDDQWNC6H8oQ?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Cantidad acumulativa de recolecciones en las tres generaciones (&lt;em&gt;# Gen x Collections&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; 
&lt;p&gt;En la ejecución normal tenemos en total 22 recolecciones de la generación 0, 4 recolecciones de la generación 1 y 2 recolecciones de la generación 2. Forzando recolección de memoria, tenemos 100 recolecciones en las generaciones 0, 1 y 2. Acá está la famosa crisis de los 40 de la que te hablé anteriormente (producto de andar jorobando con recolecciones que hacen que cualquier sobreviviente pase a la generación siguiente, con el consecuente &lt;em&gt;overhead&lt;/em&gt; de cambio generacional). Para percibirlo en mejor detalle, te propongo que analicemos los tamaños de los segmentos a lo largo de la ejecución 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1iHF6DgQW-CvNwMuTDA3Ej4wdsHsu1XnybywBTi1RlFXXVOUPryNJthG2GJPCc9t4Y?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 0 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1gSBnMHB_QqE7Jc22umx_x32SiaDZzH00h_5dn9koH4TarKVet1IDCHtVgEGUS2wMw?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1gWWGu_Y6cvAl61UnsodndrNzSJr5dpzefPrDi516ELSgiTbKSJ4tS5ei3YmKj22UY?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 0 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1imTQF9pv98IS7mPa5G3m5IXymfAMhLxCCL9uMQJDYFLMWuSDnIttCUpAYLy1DTPK0?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Tamaño del montículo de la Generación 0 (&lt;em&gt;Gen 0 heap size&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; 
&lt;p&gt;En el caso de la izquierda, sin forzar recolección, tenemos alrededor de 5,5 megas en la generación 0. Esto te da cierta pauta de cuánto llega a medir el montículo de esa generación (un poco más de 6M en este caso). Cuando el montículo creció algo más allá, se quedó sin espacio y el recolector enderezó las cosas mandando sobrevivientes a la generación 1 (y eso, como te contaba antes, pasó 22 veces) 
&lt;p&gt;En cambio, forzando recolección, la generación 0 se mantuvo dentro del 1,5M lo cual -ahora que vimos que el montículo tenía espacio para seguir creciendo arriba de los 6M- nos da la pauta de que lo hemos estado saneando cuando apenas llevaba una cuarta parte de su capacidad ocupada 
&lt;p&gt;Veamos, para entender esto mejor, cómo anduvieron las otras generaciones 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1gxuN5p5Lw0N8HRqCXH2ck8trKviNQ8dMwd9m7xl2591ptRfeRG2HGd30Qlt0KwrH8?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 1 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1iw86PKGcrQJuykx7gBv4z9_m2ziGyyUhd89kjaEw5dH8fn-iiaVZaOrIWoBMKeeJw?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1h0cdWOXbSAE3trcc8tRV5D8mG4pmwoAzXmsjCC6MJJ2Mwj-bQot3_eqYndxQVdbyo?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 1 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jESCrN50nh-uYu1M0YPkj46PbbWM88UvNSdL2ZlDv3AB7UBfFjbkd4vBIL-3RkJTY?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Tamaño del montículo de la Generación 1 (&lt;em&gt;Gen 1 heap size&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; &lt;br&gt;
&lt;p&gt;He aquí, señoras y señores, la crisis de los 40 reflejada: en la ejecución normal, el tamaño de ese montículo tuvo un gran ascenso hasta que devino su abrupta caída (creció hasta los 4,5M aproximadamente). En esa caída es donde el recolector mandó a la generación 2 a los sobrevivientes. En cambio, en el caso de la recolección forzada, se puede notar que la generación 1 siempre se mantuvo dentro de los 211,5K!! En otras palabras, los objetos entran e inmediatamente se van. Todo ese &lt;em&gt;overhead&lt;/em&gt;, claro, se paga con CPU 
&lt;p&gt;  
&lt;table cellspacing=2 cellpadding=0 width="100%" border=0&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1jJMVYRnYIhkIH3Rvp7981EM5myu0fd_6Q3p92RPv2ZVAaM8jaW8XOEfuzV3m2tYV0?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 2 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1i8sxxxbX5J43nWNtBvYbyBjCBnfQbt17Na3-003NzwSBtbFhQG438_khFzWKXubZ0?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; 
&lt;td valign=top width="50%"&gt;&lt;a href="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1gs9U2W-m7ukOW4lZRnHsfpxduPHNnBXfWxQltQb8pMuSugAizj1Flbd2uWXVM74Ts?PARTNER=WRITER"&gt;&lt;img style="border-top-width:0px;border-left-width:0px;border-bottom-width:0px;border-right-width:0px" height=366 alt="Gen 2 heap size" src="http://tkfiles.storage.msn.com/y1pHldoPC-Ru1h_Vrtce1b1KaLfddyTb35ZxJ82tVCJNizk83mZUfppbGl6NQjxwvKt11E4WHEh1NE?PARTNER=WRITER" width=404 border=0&gt;&lt;/a&gt; &lt;/tbody&gt;&lt;/table&gt;
&lt;p&gt;&lt;strong&gt;Tamaño del montículo de la Generación 2 (&lt;em&gt;Gen 2 heap size&lt;/em&gt;)&lt;br&gt;A la izquierda, sin forzar recolección. A la derecha, forzando recolección (hacé click en las imágenes para verlas mejor)&lt;/strong&gt; 
&lt;p&gt;Acá aparece la madre del borrego: la generación 2, en la ejecución normal, viene piola dentro del 1,37M en la medida en que la generación 0 va creciendo, hasta que los sobrantes van pasando a la 1. No te olvides que mientras no se fuerce recolección, el recolector barre una generación primero y, de no haber conseguido memoria suficiente, pasa entonces a la generación siguiente (y así sucesivamente). Por ello la generación 2 pega un gran salto ya en la segunda mitad de la ejecución, cuando es evidente el arrastre de memoria perdida que viene sobreviviendo de las agotadas generaciones anteriores 
&lt;p&gt;En el caso forzado, este segmento viene creciendo lozanamente mientras los otros dos se mantienen por debajo de sus valores de ocupación plena. Al forzar la intervención del recolector de basura no hacemos más que mover bytes entre segmentos, para una ejecución que finalmente terminó consumiendo más. Qué tul? 
&lt;p&gt;  
&lt;p&gt;En fin. Hay otros contadores más de memoria que no utilicé en este caso. Para una descripción total de los mismos te recomiendo que visites el documento &amp;quot;&lt;a href="http://msdn2.microsoft.com/en-us/architecture/x2tyfybc.aspx" target="_blank"&gt;&lt;em&gt;Contadores de Rendimiento de Memoria&lt;/em&gt;&lt;/a&gt;&amp;quot; en MSDN 
&lt;p&gt;Configurar el Monitor de Rendimiento es realmente fácil. En la figura de abajo te muestro un detalle al elegir para mi propia compu (&lt;em&gt;&amp;lt;Local computer&amp;gt;&lt;/em&gt;, porque también podía haber elegido alguna de la red), algunos parámetros medibles de la categoría &lt;em&gt;.NET CLR Memory&lt;/em&gt;, filtrando por la instancia del proyecto que tenía abierto en Visual Studio (&lt;em&gt;MemoryLeakProducer.vshost&lt;/em&gt;) 
&lt;p align=center&gt;&lt;img st