<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	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/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Wizards of Smart &#187; YAGNI</title>
	<atom:link href="http://wizardsofsmart.net/tag/yagni/feed/" rel="self" type="application/rss+xml" />
	<link>http://wizardsofsmart.net</link>
	<description>.NET Design Patterns</description>
	<lastBuildDate>Thu, 29 Jul 2010 16:40:34 +0000</lastBuildDate>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
	<generator>http://wordpress.org/?v=3.0-beta2-14896</generator>
		<item>
		<title>YAGNI&#8211;Whose Definition of Simple?</title>
		<link>http://wizardsofsmart.net/patterns/yagni-whose-definition-of-simple/</link>
		<comments>http://wizardsofsmart.net/patterns/yagni-whose-definition-of-simple/#comments</comments>
		<pubDate>Tue, 12 May 2009 13:00:52 +0000</pubDate>
		<dc:creator>panesofglass</dc:creator>
				<category><![CDATA[Patterns]]></category>
		<category><![CDATA[Projects]]></category>
		<category><![CDATA[Tips]]></category>
		<category><![CDATA[Agile]]></category>
		<category><![CDATA[Design Patterns]]></category>
		<category><![CDATA[SOLID]]></category>
		<category><![CDATA[TDD]]></category>
		<category><![CDATA[YAGNI]]></category>

		<guid isPermaLink="false">http://wizardsofsmart.net/patterns/yagni-whose-definition-of-simple</guid>
		<description><![CDATA[I have read a lot about YAGNI lately, especially regarding TDD. The thing that keeps bugging me is the definition of &#8220;simple.&#8221; Who defines simple? For instance, wouldn&#8217;t static methods be simpler than building objects? You could then write more functionally. Or is that not simpler to you? If you follow command-query separation, wouldn&#8217;t building [...]]]></description>
			<content:encoded><![CDATA[<p>I have read a lot about <a class="zem_slink" title="You Ain't Gonna Need It" rel="wikipedia" href="http://en.wikipedia.org/wiki/You_Ain%27t_Gonna_Need_It" onclick="urchinTracker('/outgoing/en.wikipedia.org/wiki/You_Ain_27t_Gonna_Need_It?referer=');">YAGNI</a> lately, especially regarding <a class="zem_slink" title="Test-driven development" rel="wikipedia" href="http://en.wikipedia.org/wiki/Test-driven_development" onclick="urchinTracker('/outgoing/en.wikipedia.org/wiki/Test-driven_development?referer=');">TDD</a>. The thing that keeps bugging me is the definition of &#8220;simple.&#8221; Who defines simple? For instance, wouldn&#8217;t static methods be simpler than building objects? You could then write more functionally. Or is that not simpler to you? If you follow <a class="zem_slink" title="Command-query separation" rel="wikipedia" href="http://en.wikipedia.org/wiki/Command-query_separation" onclick="urchinTracker('/outgoing/en.wikipedia.org/wiki/Command-query_separation?referer=');">command-query separation</a>, wouldn&#8217;t building everything as either pure functions or commands be simplest? JB and I have found this set of patterns immensely easy to create and test of late, especially in comparison to the ever-increasing-in-complexity procedural/OO code in place before.</p>
<p>So I guess my question is this: Is it really so bad to start with some basic patterns that will let you <a class="zem_slink" title="Code refactoring" rel="wikipedia" href="http://en.wikipedia.org/wiki/Code_refactoring" onclick="urchinTracker('/outgoing/en.wikipedia.org/wiki/Code_refactoring?referer=');">refactor</a> more easily? I think the desire to make things as simple as possible&#8211;especially when you know you will need it&#8211;can be a waste of time and a good way of getting bad code into your source.</p>
<p>I know I will hear it from the Agile community that I just don&#8217;t get it, but I think I do. I really like starting simple and keeping things in nice, bite-sized testable chunks. And yes, I&#8217;m still learning. However, without a consistent and meaningful definition of &#8220;simple,&#8221; we&#8217;re likely to end up with a follow-up movement of making things complex for the sake of extensibility again.</p>
<p>So what do you think: is CQS too complex a starting point, or is it a nice, &#8220;simple,&#8221; and testable approach for YAGNI?</p>
<div class="zemanta-pixie" style="margin-top: 10px; height: 15px;"><img class="zemanta-pixie-img" style="border: medium none; float: right;" src="http://img.zemanta.com/pixy.gif?x-id=933e7d8e-8c97-4679-ad3a-421e33908d4a" alt="" /><span class="zem-script more-related pretty-attribution"><script src="http://static.zemanta.com/readside/loader.js" type="text/javascript"></script></span></div>
]]></content:encoded>
			<wfw:commentRss>http://wizardsofsmart.net/patterns/yagni-whose-definition-of-simple/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>
