<?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>Java Application Architecture &#187; Dependency Pattern</title>
	<atom:link href="http://www.kirkk.com/modularity/category/dependency-pattern/feed/" rel="self" type="application/rss+xml" />
	<link>http://www.kirkk.com/modularity</link>
	<description>Modularity Patterns with Examples Using OSGi</description>
	<lastBuildDate>Wed, 28 Dec 2011 17:29:17 +0000</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.6</generator>
	<language>en</language>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
			<item>
		<title>Colocate Exceptions</title>
		<link>http://www.kirkk.com/modularity/2009/12/colocate-exceptions/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/colocate-exceptions/#comments</comments>
		<pubDate>Mon, 28 Dec 2009 19:51:32 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Extensibility Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=367</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Exceptions should be close to the class or interface that throw them.
Description
Sadly, dealing with exceptions in enterprise software systems is often an afterthought. But allocation of exceptions to modules has significant implications on the modularity, and more specifically the [...]]]></description>
			<content:encoded><![CDATA[<p><em>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</em></p>
<h2>Statement</h2>
<p>Exceptions should be close to the class or interface that throw them.</p>
<h2>Description</h2>
<p>Sadly, dealing with exceptions in enterprise software systems is often an afterthought. But allocation of exceptions to modules has significant implications on the modularity, and more specifically the dependencies between modules, within our software system. Placing the exception close to a class that catches it will often cause a cyclic dependency between the module containing the class that throws the exception and the module containing the class that catches the exception. Exceptions should always be placed in a module closer to the class that throws the exception than a module closer to the class that catches the exception.</p>
<p style="text-align: center;"><img class="size-full wp-image-773 aligncenter" style="border: 0pt none;" title="ColocateExceptions" src="http://www.kirkk.com/modularity/wp-content/uploads/2009/12/ColocateExceptions.jpg" alt="ColocateExceptions" width="585" height="365" /></p>
<p style="text-align: center;">
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/colocate-exceptions/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Container Independence</title>
		<link>http://www.kirkk.com/modularity/2009/12/container-independence/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/container-independence/#comments</comments>
		<pubDate>Mon, 28 Dec 2009 19:28:50 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=355</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Modules should be independent of the runtime container.
Description
Modules with excessive runtime container dependencies are heavyweight modules that cannot execute outside the confines of the runtime container. Lightweight modules with no container dependencies have significant advantages.

]]></description>
			<content:encoded><![CDATA[<p><em>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</em></p>
<h2>Statement</h2>
<p>Modules should be independent of the runtime container.</p>
<h2>Description</h2>
<p>Modules with excessive runtime container dependencies are heavyweight modules that cannot execute outside the confines of the runtime container. Lightweight modules with no container dependencies have significant advantages.</p>
<p style="text-align: center;"><img class="aligncenter size-full wp-image-383" style="border: 0pt none;" title="ContainerIndependence" src="http://www.kirkk.com/modularity/wp-content/uploads/2009/12/ContainerIndependence.jpg" alt="ContainerIndependence" width="557" height="225" /></p>
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/container-independence/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Levelize Modules</title>
		<link>http://www.kirkk.com/modularity/2009/12/levelize-modules/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/levelize-modules/#comments</comments>
		<pubDate>Sun, 27 Dec 2009 18:10:25 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=218</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Module relationships should be levelized.
Description
Levelized modules demand that module relationships be acyclic. Any cycles in module relationships therefore prevents levelization. To levelize modules relationships, there are several steps.

]]></description>
			<content:encoded><![CDATA[<p><em>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</em></p>
<h2>Statement</h2>
<p>Module relationships should be levelized.</p>
<h2>Description</h2>
<p>Levelized modules demand that module relationships be acyclic. Any cycles in module relationships therefore prevents levelization. To levelize modules relationships, there are several steps.</p>
<p style="text-align: center;"><img class="aligncenter size-full wp-image-343" style="border: 0pt none;" title="LevelizedModules" src="http://www.kirkk.com/modularity/wp-content/uploads/2009/12/LevelizedModules.jpg" alt="LevelizedModules" width="468" height="468" /></p>
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/levelize-modules/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Independent Deployment</title>
		<link>http://www.kirkk.com/modularity/2009/12/independent-deployment/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/independent-deployment/#comments</comments>
		<pubDate>Tue, 22 Dec 2009 16:18:55 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=222</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Modules should be as independently deployable as possible.
Description
For a module to be independently deployable, it cannot have any outgoing dependencies on any other module.
]]></description>
			<content:encoded><![CDATA[<p><i>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</i></p>
<h2>Statement</h2>
<p>Modules should be as independently deployable as possible.</p>
<h2>Description</h2>
<p>For a module to be independently deployable, it cannot have any outgoing dependencies on any other module.</p>
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/independent-deployment/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Physical Layers</title>
		<link>http://www.kirkk.com/modularity/2009/12/physical-layers/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/physical-layers/#comments</comments>
		<pubDate>Tue, 22 Dec 2009 16:04:07 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=214</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Module relationships must not violate logical layer relationships.
Description
It&#8217;s common knowledge that when designing systems of any degree of complexity, the presentation, business logic, and data access should be separated into distinct layers.  There are several important considerations when [...]]]></description>
			<content:encoded><![CDATA[<p><em>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</em></p>
<h2>Statement</h2>
<p>Module relationships must not violate logical layer relationships.</p>
<h2>Description</h2>
<p>It&#8217;s common knowledge that when designing systems of any degree of complexity, the presentation, business logic, and data access should be separated into distinct layers.  There are several important considerations when separating the layers.</p>
<p style="text-align: center;"><img class="aligncenter size-full wp-image-215" style="border: 0pt none;" title="LayeringRelationship" src="http://www.kirkk.com/modularity/wp-content/uploads/2009/12/LayeringRelationship.jpg" alt="LayeringRelationship" width="322" height="331" /></p>
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/physical-layers/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
		<item>
		<title>Acyclic Relationships</title>
		<link>http://www.kirkk.com/modularity/2009/12/acyclic-relationships/</link>
		<comments>http://www.kirkk.com/modularity/2009/12/acyclic-relationships/#comments</comments>
		<pubDate>Tue, 22 Dec 2009 02:18:22 +0000</pubDate>
		<dc:creator>kirk knoernschild</dc:creator>
				<category><![CDATA[Dependency Pattern]]></category>
		<category><![CDATA[Part 2]]></category>

		<guid isPermaLink="false">http://www.kirkk.com/modularity/?p=149</guid>
		<description><![CDATA[For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.
Statement
Module relationships should be uni-directional.
Description
When you define a relationship between two system modules, their coupling is increased. Some degree of  coupling is necessary simply because modules need to work together to accomplish some task. But certain types of coupling [...]]]></description>
			<content:encoded><![CDATA[<p><em>For the full description, implementation variations, consequences, and detailed sample, see Page 150 in Java Application Architecture.</em></p>
<h2>Statement</h2>
<p>Module relationships should be uni-directional.</p>
<h2>Description</h2>
<p>When you define a relationship between two system modules, their coupling is increased. Some degree of  coupling is necessary simply because modules need to work together to accomplish some task. But certain types of coupling should be avoided. There are rules that will help you identify bi-directional relationships between modules.</p>
<p style="text-align: center;"><img class="aligncenter size-full wp-image-195" style="border: 0pt none;" title="AcyclicVsCyclic" src="http://www.kirkk.com/modularity/wp-content/uploads/2009/12/AcyclicVsCyclic.jpg" alt="AcyclicVsCyclic" width="580" height="469" /></p>
]]></content:encoded>
			<wfw:commentRss>http://www.kirkk.com/modularity/2009/12/acyclic-relationships/feed/</wfw:commentRss>
		<slash:comments>0</slash:comments>
		</item>
	</channel>
</rss>

