<?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: Scaling out 37 Signal-style applications is convenient</title>
	<atom:link href="http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient/feed" rel="self" type="application/rss+xml" />
	<link>http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient</link>
	<description>blogging about life, the universe, and everything tech</description>
	<lastBuildDate>Sat, 08 Sep 2012 07:06:53 -0700</lastBuildDate>
	<generator>http://wordpress.org/?v=2.8.4</generator>
	<sy:updatePeriod>hourly</sy:updatePeriod>
	<sy:updateFrequency>1</sy:updateFrequency>
		<item>
		<title>By: Danyel Lawson</title>
		<link>http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient/comment-page-1#comment-32156</link>
		<dc:creator>Danyel Lawson</dc:creator>
		<pubDate>Sun, 21 May 2006 13:55:58 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/scaling-out-37-signal-style-applications-is-convenient#comment-32156</guid>
		<description>If you really want to scale and deal with concurrency issues you have to give up on the notion that read and write locks are anything but a hack.  When you work out the read write logic in your code and run your code through some scenario testing.  You will find that most of you locks are unneccessary.  What is needed is transaction begin and commit statements around writes to the database to avoid partially stale data being read.  If your writes to multiple tables are atomic your data can be distributed across multiple servers easily without preventing reads.  Stale reads are only considered stale until the new data is written.  There is never a need to lock a row and definitely not a whole table.  Any real database is designed to serve read requests concurrently with writes.  Work though the logic and you may be surprised by how most of your reads have almost nothing to do with your writes.  The dependent database reads are already synchronized in you current code by their order of occurence after the datbase writes.
</description>
		<content:encoded><![CDATA[<p>If you really want to scale and deal with concurrency issues you have to give up on the notion that read and write locks are anything but a hack.  When you work out the read write logic in your code and run your code through some scenario testing.  You will find that most of you locks are unneccessary.  What is needed is transaction begin and commit statements around writes to the database to avoid partially stale data being read.  If your writes to multiple tables are atomic your data can be distributed across multiple servers easily without preventing reads.  Stale reads are only considered stale until the new data is written.  There is never a need to lock a row and definitely not a whole table.  Any real database is designed to serve read requests concurrently with writes.  Work though the logic and you may be surprised by how most of your reads have almost nothing to do with your writes.  The dependent database reads are already synchronized in you current code by their order of occurence after the datbase writes.</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: analogueboy</title>
		<link>http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient/comment-page-1#comment-32155</link>
		<dc:creator>analogueboy</dc:creator>
		<pubDate>Tue, 09 May 2006 21:22:01 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/scaling-out-37-signal-style-applications-is-convenient#comment-32155</guid>
		<description>s/out/our/g
</description>
		<content:encoded><![CDATA[<p>s/out/our/g</p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Todd Huss</title>
		<link>http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient/comment-page-1#comment-32154</link>
		<dc:creator>Todd Huss</dc:creator>
		<pubDate>Tue, 09 May 2006 06:50:12 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/scaling-out-37-signal-style-applications-is-convenient#comment-32154</guid>
		<description>We have this very problem at our company! The scalability of our application is currently limited by our read-write MySQL master. We do caching and have 2 dedicated read-write slaves. Still, on a couple of very high traffic occasions we&#039;ve had the write operations go high enough that our 10 web/application servers started waiting on the read-write database, then the db connections started backing up waiting for the lock to free, we hit max connections, and down we went.

We&#039;re still using MyISAM (which does table level locking) and I&#039;m hopeful that when we make the switch to InnoDB that load testing will show that InnoDB&#039;s row level locking is much more performant for write operations while still being nearly as performant for reads.

As an aside, on the Java front we discovered that the MySQL JDBC driver offers a nice solution to easily load balance read operations across the slaves using their com.mysql.jdbc.ReplicationDriver: http://gabrito.com/post/load-balancing-across-mysql-servers-using-jdbc
</description>
		<content:encoded><![CDATA[<p>We have this very problem at our company! The scalability of our application is currently limited by our read-write MySQL master. We do caching and have 2 dedicated read-write slaves. Still, on a couple of very high traffic occasions we&#8217;ve had the write operations go high enough that our 10 web/application servers started waiting on the read-write database, then the db connections started backing up waiting for the lock to free, we hit max connections, and down we went.</p>
<p>We&#8217;re still using MyISAM (which does table level locking) and I&#8217;m hopeful that when we make the switch to InnoDB that load testing will show that InnoDB&#8217;s row level locking is much more performant for write operations while still being nearly as performant for reads.</p>
<p>As an aside, on the Java front we discovered that the MySQL JDBC driver offers a nice solution to easily load balance read operations across the slaves using their com.mysql.jdbc.ReplicationDriver: <a href="http://gabrito.com/post/load-balancing-across-mysql-servers-using-jdbc" rel="nofollow">http://gabrito.com/post/load-balancing-across-mysql-servers-using-jdbc</a></p>
]]></content:encoded>
	</item>
	<item>
		<title>By: Patrick Lightbody</title>
		<link>http://almaer.com/blog/scaling-out-37-signal-style-applications-is-convenient/comment-page-1#comment-32153</link>
		<dc:creator>Patrick Lightbody</dc:creator>
		<pubDate>Tue, 09 May 2006 02:04:02 +0000</pubDate>
		<guid isPermaLink="false">http://almaer.com/blog2/scaling-out-37-signal-style-applications-is-convenient#comment-32153</guid>
		<description>Thank god someone finally pointed this out. &quot;[Language] does/does not scale&quot; is the dumbest comment ever. Applications do or do not scale, not the languages.

We are doing the exact approach you mentioned with HostedQA (http://www.hostedqa.com). Because our customers get a sub-domain, scaling is cake!
</description>
		<content:encoded><![CDATA[<p>Thank god someone finally pointed this out. &#8220;[Language] does/does not scale&#8221; is the dumbest comment ever. Applications do or do not scale, not the languages.</p>
<p>We are doing the exact approach you mentioned with HostedQA (<a href="http://www.hostedqa.com)" rel="nofollow">http://www.hostedqa.com)</a>. Because our customers get a sub-domain, scaling is cake!</p>
]]></content:encoded>
	</item>
</channel>
</rss>
