<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
		>
<channel>
	<title>Comments on: El difícil compromiso entre KISS y OO</title>
	<atom:link href="http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/feed/" rel="self" type="application/rss+xml" />
	<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/</link>
	<description>Programación e informática en general</description>
	<lastBuildDate>Sun, 29 Jan 2012 15:49:02 +0000</lastBuildDate>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.3.1</generator>
	<item>
		<title>By: Jose Selesan</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1918</link>
		<dc:creator>Jose Selesan</dc:creator>
		<pubDate>Fri, 19 Jun 2009 15:18:51 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1918</guid>
		<description>Excelente post!. Yo creo que el secreto radica en la refactorización, junto con los unit test. Los metodologistas ágiles (si existe esa definición) siempre hablan o bien de KISS o bien de YAGNI (You Aren&#039;t Gonna Need It), es decir, hacer que ande lo que tiene que andar, sin inventar nada raro ni nada que el usuario no haya pedido, y cuando el software empieza a crecer, se lo va refactorizando, llevando el diseño inicial a un diseño más OO, siempre apoyándose en los unit test para asegurarse de no haber roto nada.

Eso sí, para todo eso se necesitan programadores con experiencia y buena voluntad. Experiencia para detectar qué cambios conviene hacer (y hacerlos bien) y buena voluntad para hacerlos. Lamentablemente me ha tocado ver aplicaciones que empezaron con KISS porque eran chiquitas y luego se convirtieron en mounstros pero no sufrieron ningún tipo de rediseño, y todos sabemos que eso puede llevar al caos de mantenimiento.</description>
		<content:encoded><![CDATA[<p>Excelente post!. Yo creo que el secreto radica en la refactorización, junto con los unit test. Los metodologistas ágiles (si existe esa definición) siempre hablan o bien de KISS o bien de YAGNI (You Aren&#8217;t Gonna Need It), es decir, hacer que ande lo que tiene que andar, sin inventar nada raro ni nada que el usuario no haya pedido, y cuando el software empieza a crecer, se lo va refactorizando, llevando el diseño inicial a un diseño más OO, siempre apoyándose en los unit test para asegurarse de no haber roto nada.</p>
<p>Eso sí, para todo eso se necesitan programadores con experiencia y buena voluntad. Experiencia para detectar qué cambios conviene hacer (y hacerlos bien) y buena voluntad para hacerlos. Lamentablemente me ha tocado ver aplicaciones que empezaron con KISS porque eran chiquitas y luego se convirtieron en mounstros pero no sufrieron ningún tipo de rediseño, y todos sabemos que eso puede llevar al caos de mantenimiento.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Julio Quiberre</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1917</link>
		<dc:creator>Julio Quiberre</dc:creator>
		<pubDate>Thu, 18 Jun 2009 13:38:07 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1917</guid>
		<description>Tal vez necesiten leer un poco de:

Rules are for Fools, Patterns are for Cool Fools. Journal of Object-Oriented Programming, 10, October 1999.</description>
		<content:encoded><![CDATA[<p>Tal vez necesiten leer un poco de:</p>
<p>Rules are for Fools, Patterns are for Cool Fools. Journal of Object-Oriented Programming, 10, October 1999.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: atreyu</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1915</link>
		<dc:creator>atreyu</dc:creator>
		<pubDate>Thu, 18 Jun 2009 06:02:44 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1915</guid>
		<description>Bueno hay muchas siglas y principios y como programar no deja de tener alguna pincelada de artesania o incluso arte (o eso me gusta pensar) muchas veces entramos en terrenos de la estetica mas que en el puro blanco y negro de la ciencia o la ingenieria.

Por mi parte el principio que casi sigo a rajatabla es el DRY (dont repeat yourself), me chirria tanto ver un codigo repetido mas de dos veces que me supera y tengo que montarme algo para evitar una tercera repeticion (y eliminar las dos anteriores de paso). La abstraccion permite eliminar la repeticion de codigo y reusarlo, aunque la oop no es la unica manera de abstraer...en cualquier lisp (en clojure por ejemplo) por ejemplo el tener closures y poder modificar el codigo en tiempo de evaluacion con macros te permite abstraer muchas veces de forma mas rapida, sencilla y expresiva que con la oop y sus a veces rebuscados patrones.

El problema es cuando antes siquiera de que se repita una vez ya piensas en que tal vez se repita, que tal vez cambie el requirimiento, que tal vez el usuario no sepa lo que quiere, que tal vez...y como cuando haces la maleta la llenas de &quot;por sies&quot; y acabas con el triple de lo que luego usas realmente. Por eso prefiero refactorizar a partir de la segunda repeticion que pensar en las interfaces desde el principio a no ser que este muy muy clara su utilidad.</description>
		<content:encoded><![CDATA[<p>Bueno hay muchas siglas y principios y como programar no deja de tener alguna pincelada de artesania o incluso arte (o eso me gusta pensar) muchas veces entramos en terrenos de la estetica mas que en el puro blanco y negro de la ciencia o la ingenieria.</p>
<p>Por mi parte el principio que casi sigo a rajatabla es el DRY (dont repeat yourself), me chirria tanto ver un codigo repetido mas de dos veces que me supera y tengo que montarme algo para evitar una tercera repeticion (y eliminar las dos anteriores de paso). La abstraccion permite eliminar la repeticion de codigo y reusarlo, aunque la oop no es la unica manera de abstraer&#8230;en cualquier lisp (en clojure por ejemplo) por ejemplo el tener closures y poder modificar el codigo en tiempo de evaluacion con macros te permite abstraer muchas veces de forma mas rapida, sencilla y expresiva que con la oop y sus a veces rebuscados patrones.</p>
<p>El problema es cuando antes siquiera de que se repita una vez ya piensas en que tal vez se repita, que tal vez cambie el requirimiento, que tal vez el usuario no sepa lo que quiere, que tal vez&#8230;y como cuando haces la maleta la llenas de &#8220;por sies&#8221; y acabas con el triple de lo que luego usas realmente. Por eso prefiero refactorizar a partir de la segunda repeticion que pensar en las interfaces desde el principio a no ser que este muy muy clara su utilidad.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Chuidiang</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1912</link>
		<dc:creator>Chuidiang</dc:creator>
		<pubDate>Wed, 17 Jun 2009 20:01:11 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1912</guid>
		<description>@Gimenete. Entiendo por KISS el hacer el código lo más sencillo posible (entendible y diseño simple) para que cumpla el objetivo previsto (que haga algo concreto o que sea extensible o que sea fácilmente xxx). La OO puede ser o no KISS dependiendo de quién lo haga y cómo lo haga, independiemente del objetivo, no es KISS por sí misma. Evidentemente, si el objetivo del código es ser fácilmente ampliable y modificable, un diseño simple debe ser OO y no algo como un main(). Pero si el objetivo es que se haga algo concreto y no está previsto ser ampliado, quizás la OO es excesiva.

@blaxter.
ps: Lo del main() con todo junto es posible en este ejemplo porque es muy tonto. En un problema más grande habría más clases y más separación entre cosas. Pero de la misma forma, si para este ejemplo tonto exagerando la OO hay tres o cuatro clases y dos interfaces, para un problema complejo habría tres miles de clases y dos miles de interfaces. Como comenta Gimente, hay que determinar cual es el objetivo de nuestro código y ser consecuente con él. La OO se ha inventado para hacer código fácilmente reutilizable y ampliable. Si nuestro objetivo no es ese, nos sobra la OO y deberíamos usar lo menos posible.
ps2:Doy por sobreentendido que para reutilizar clases estas deben estar compiladas y separadas en una librería fuera del proyecto. Si quiero que mi clase EcuacionSegundoGrado sea retulizable, tendré que hacer mi librería matematica.jar y meter ahí esa clase ya compilada.

Sed buenos.</description>
		<content:encoded><![CDATA[<p>@Gimenete. Entiendo por KISS el hacer el código lo más sencillo posible (entendible y diseño simple) para que cumpla el objetivo previsto (que haga algo concreto o que sea extensible o que sea fácilmente xxx). La OO puede ser o no KISS dependiendo de quién lo haga y cómo lo haga, independiemente del objetivo, no es KISS por sí misma. Evidentemente, si el objetivo del código es ser fácilmente ampliable y modificable, un diseño simple debe ser OO y no algo como un main(). Pero si el objetivo es que se haga algo concreto y no está previsto ser ampliado, quizás la OO es excesiva.</p>
<p>@blaxter.<br />
ps: Lo del main() con todo junto es posible en este ejemplo porque es muy tonto. En un problema más grande habría más clases y más separación entre cosas. Pero de la misma forma, si para este ejemplo tonto exagerando la OO hay tres o cuatro clases y dos interfaces, para un problema complejo habría tres miles de clases y dos miles de interfaces. Como comenta Gimente, hay que determinar cual es el objetivo de nuestro código y ser consecuente con él. La OO se ha inventado para hacer código fácilmente reutilizable y ampliable. Si nuestro objetivo no es ese, nos sobra la OO y deberíamos usar lo menos posible.<br />
ps2:Doy por sobreentendido que para reutilizar clases estas deben estar compiladas y separadas en una librería fuera del proyecto. Si quiero que mi clase EcuacionSegundoGrado sea retulizable, tendré que hacer mi librería matematica.jar y meter ahí esa clase ya compilada.</p>
<p>Sed buenos.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Shd</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1911</link>
		<dc:creator>Shd</dc:creator>
		<pubDate>Wed, 17 Jun 2009 19:41:53 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1911</guid>
		<description>Un artículo interesante, pero discrepo contigo en algunos aspectos. Has orientado las diferencias entre lo que podríamos denominar &quot;KISS&quot; y &quot;POO&quot; a un ejemplo demasiado sencillo, y creo que eso puede inducir a algunos errores. 
En cualquier proyecto real, la complejidad aumenta de forma muy rápida, pese a ello siempre es posible dividir el trabajo en pequeñas funciones, que realicen un trabajo determinado (qué sería de nostros sino). En tal caso, el método &quot;KISS&quot; coincide plenamente con el que tú has indicado como mas complejo: separar las funciones de toma de datos, muestra, calculos internos.. en definitiva el conocido modelo vista-controlador. 
Y esto se puede ver claramente en que cuando tu te enfrentas a un proyecto ya existente pero desconocido para ti, ver clases en las que se mezcla por un lado la toma de datos, por otro su modificación, etc. es un caos. En cambio, si encontramos cada &quot;trabajo&quot; separado, según su aplicación, será mucho mas sencillo entender qué está ocurriendo en cada momento. 

Un saludo y enhorabuena por el blog, que sigo desde hace bastante tiempo y cada vez está mejor.</description>
		<content:encoded><![CDATA[<p>Un artículo interesante, pero discrepo contigo en algunos aspectos. Has orientado las diferencias entre lo que podríamos denominar &#8220;KISS&#8221; y &#8220;POO&#8221; a un ejemplo demasiado sencillo, y creo que eso puede inducir a algunos errores.<br />
En cualquier proyecto real, la complejidad aumenta de forma muy rápida, pese a ello siempre es posible dividir el trabajo en pequeñas funciones, que realicen un trabajo determinado (qué sería de nostros sino). En tal caso, el método &#8220;KISS&#8221; coincide plenamente con el que tú has indicado como mas complejo: separar las funciones de toma de datos, muestra, calculos internos.. en definitiva el conocido modelo vista-controlador.<br />
Y esto se puede ver claramente en que cuando tu te enfrentas a un proyecto ya existente pero desconocido para ti, ver clases en las que se mezcla por un lado la toma de datos, por otro su modificación, etc. es un caos. En cambio, si encontramos cada &#8220;trabajo&#8221; separado, según su aplicación, será mucho mas sencillo entender qué está ocurriendo en cada momento. </p>
<p>Un saludo y enhorabuena por el blog, que sigo desde hace bastante tiempo y cada vez está mejor.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: blaxter</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1910</link>
		<dc:creator>blaxter</dc:creator>
		<pubDate>Wed, 17 Jun 2009 19:36:19 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1910</guid>
		<description>Los patrones de diseño ayudan a mantener las cosas simples, lo que no ayuda es usarlos cuando no se necesitan.

ps: Una única clase con un método main y unión de lógica del programa con la GUI eso no es KISS, eso es lo más jodidamente retorcido que se puede imaginar.

ps2: la reutilización de clases es un mito de OO (reutilizar librerías, sí, ¿pero clases individuales? riau, riau).</description>
		<content:encoded><![CDATA[<p>Los patrones de diseño ayudan a mantener las cosas simples, lo que no ayuda es usarlos cuando no se necesitan.</p>
<p>ps: Una única clase con un método main y unión de lógica del programa con la GUI eso no es KISS, eso es lo más jodidamente retorcido que se puede imaginar.</p>
<p>ps2: la reutilización de clases es un mito de OO (reutilizar librerías, sí, ¿pero clases individuales? riau, riau).</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: gimenete</title>
		<link>http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/comment-page-1/#comment-1909</link>
		<dc:creator>gimenete</dc:creator>
		<pubDate>Wed, 17 Jun 2009 18:59:18 +0000</pubDate>
		<guid isPermaLink="false">http://blog.chuidiang.com/2009/06/17/el-dificil-compromiso-entre-kiss-y-oo/#comment-1909</guid>
		<description>Creo que el problema es &quot;qué entiendes por simple&quot;? Simple en diseño o simple de extender o simple de mantener o...

Hacer una clase con un main() es elegir un &quot;diseño simple&quot;, pero no es &quot;simple de extender&quot;. Por lo tanto, qué quiere decir KISS? &quot;Mantenlo simple en diseño&quot; o &quot;Mantenlo simple de extender&quot; o incluso &quot;Mantenlo simple de usar&quot;. Y con esto último (&quot;simple de usar&quot;) no me refiero a la usabilidad, sino al código: por ejemplo un API simple en su interfaz externa puede ser muy compleja en su implentación.

KISS es algo muy genérico. Puedes mantener simple el diseño o la implementación o... o hacer un equilibrio según las necesidades en cada momento. La OO te permitirá hacer un diseño más simple de extender y de mantener, por lo tanto OO también es KISS :P

saludos!</description>
		<content:encoded><![CDATA[<p>Creo que el problema es &#8220;qué entiendes por simple&#8221;? Simple en diseño o simple de extender o simple de mantener o&#8230;</p>
<p>Hacer una clase con un main() es elegir un &#8220;diseño simple&#8221;, pero no es &#8220;simple de extender&#8221;. Por lo tanto, qué quiere decir KISS? &#8220;Mantenlo simple en diseño&#8221; o &#8220;Mantenlo simple de extender&#8221; o incluso &#8220;Mantenlo simple de usar&#8221;. Y con esto último (&#8220;simple de usar&#8221;) no me refiero a la usabilidad, sino al código: por ejemplo un API simple en su interfaz externa puede ser muy compleja en su implentación.</p>
<p>KISS es algo muy genérico. Puedes mantener simple el diseño o la implementación o&#8230; o hacer un equilibrio según las necesidades en cada momento. La OO te permitirá hacer un diseño más simple de extender y de mantener, por lo tanto OO también es KISS <img src='http://blog.chuidiang.com/wp-includes/images/smilies/icon_razz.gif' alt=':P' class='wp-smiley' /> </p>
<p>saludos!</p>
]]></content:encoded>
	</item>
</channel>
</rss>

