<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
<title>Phlip Plumlee on O&apos;Reilly Broadcast</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/" />
<link rel="self" type="application/atom+xml" href="http://broadcast.oreilly.com/atom.xml" />
<id>tag:broadcast.oreilly.com,2008-08-07://53</id>
<updated>2010-05-30T04:47:36Z</updated>

<generator uri="http://www.sixapart.com/movabletype/">Movable Type Pro 4.21-en</generator>

<entry>
<title>TDD Myths</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/05/tdd-myths.html" />
<id>tag:broadcast.oreilly.com,2010://53.39978</id>

<published>2010-05-30T04:47:36Z</published>
<updated>2010-05-30T04:47:36Z</updated>

<summary>While Extreme Programming remains a valuable template for project success, the decade of its adoption also saw the rise of many dilutions and derivatives. This post debunks some common myths about TDD.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="tddtheory" label="TDD theory" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
While Extreme Programming remains a valuable template for project success, the decade of its adoption also saw the rise of many dilutions and derivatives. This post debunks some common myths about TDD.
</content>
</entry>

<entry>
<title>Abstract Tests</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/05/abstract-tests.html" />
<id>tag:broadcast.oreilly.com,2010://53.39798</id>

<published>2010-05-04T04:46:00Z</published>
<updated>2010-05-04T04:46:00Z</updated>

<summary>My last post showed how to mock a webservice. When you have more than one webservice, all their common code, tests, and mocks should remain DRY. This post demonstrates a ruthlessly effective test pattern that forces many different interfaces to behave as similarly as possible, using the minimum possible test code.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="programmingtests" label="programming tests" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="refactoringtdd" label="refactoring tdd" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="ruby" label="ruby" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="xml" label="xml" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="xmlpatterns" label="xml patterns" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
My last post showed how to mock a webservice. When you have more than one webservice, all their common code, tests, and mocks should remain DRY. This post demonstrates a ruthlessly effective test pattern that forces many different interfaces to behave as similarly as possible, using the minimum possible test code.
</content>
</entry>

<entry>
<title>Mock the Web Service</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2010/05/mock-the-web-service.html" />
<id>tag:broadcast.oreilly.com,2010://53.39797</id>

<published>2010-05-04T03:02:39Z</published>
<updated>2010-05-04T03:02:39Z</updated>

<summary>This post shows how to write a web service using Test-Driven Development. Our source code example is the exemplary active_merchant contribution to Ruby on Rails. It reveals how developer tests can correctly attack remote web services. Programmers writing clients (or servers) for any kind of web service should use these techniques. My next post will extend this one into the Abstract Test Pattern.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="python" label="python" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="ruby" label="ruby" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="tddprogrammingtests" label="tdd programming tests" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="webservices" label="webservices" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="xml" label="xml" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
This post shows how to write a web service using Test-Driven Development. Our source code example is the exemplary active_merchant contribution to Ruby on Rails. It reveals how developer tests can correctly attack remote web services. Programmers writing clients (or servers) for any kind of web service should use these techniques. My next post will extend this one into the Abstract Test Pattern.
</content>
</entry>

<entry>
<title>Contractive Delegation</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2009/04/contractive-delegation.html" />
<id>tag:broadcast.oreilly.com,2009://53.35911</id>

<published>2009-04-20T19:31:27Z</published>
<updated>2009-04-20T19:31:27Z</updated>

<summary>Well-factored code often has many small functions. If each adds value, and doesn&apos;t just pass the buck, then what do they all do? Typically, they contract their input by making it more specific. Then they delegate these specific data to a delegatee.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="designopinion" label="design opinion" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
Well-factored code often has many small functions. If each adds value, and doesn&apos;t just pass the buck, then what do they all do? Typically, they contract their input by making it more specific. Then they delegate these specific data to a delegatee.
</content>
</entry>

<entry>
<title>How to upgrade to the latest version of Rails</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2009/03/upgrading-rails.html" />
<id>tag:broadcast.oreilly.com,2009://53.35728</id>

<published>2009-03-29T02:40:14Z</published>
<updated>2009-03-29T02:40:14Z</updated>

<summary>I have upgraded several Rails 1.2.x programs to 2.x. This can be quite a leap, and some of the steps are counterintuitive, so this post attempts to put everything together, like a recipe. I&apos;d also like to hear more stories about upgrading platforms; such stories may indeed emend my suggested hacks and tweaks. Yet the point of unit tests, and TDD, is to make the smallest changes possible, and relentlessly test each change. Upgrading a major version tick is a big change, so you must force the upgrade to work incrementally, as a series of small changes.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="rails" label="rails" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="ruby" label="ruby" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="tdd" label="tdd" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
I have upgraded several Rails 1.2.x programs to 2.x. This can be quite a leap, and some of the steps are counterintuitive, so this post attempts to put everything together, like a recipe. I&apos;d also like to hear more stories about upgrading platforms; such stories may indeed emend my suggested hacks and tweaks. Yet the point of unit tests, and TDD, is to make the smallest changes possible, and relentlessly test each change. Upgrading a major version tick is a big change, so you must force the upgrade to work incrementally, as a series of small changes.
</content>
</entry>

<entry>
<title>Merb Mind Maps</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2009/02/merb-mind-maps.html" />
<id>tag:broadcast.oreilly.com,2009://53.35328</id>

<published>2009-02-15T23:33:08Z</published>
<updated>2009-02-15T23:33:08Z</updated>

<summary>All blogs correlate their posts with tags. This blog post shows how to use these tags to display a mind map, hooking the current post into a tree of related posts.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="merbrailsrubybddtddassertgraphvizdot" label="merb rails ruby bdd tdd assert graphviz dot" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
All blogs correlate their posts with tags. This blog post shows how to use these tags to display a mind map, hooking the current post into a tree of related posts.
</content>
</entry>

<entry>
<title>Testing Rails Partials</title>
<link rel="alternate" type="text/html" href="http://broadcast.oreilly.com/2008/10/testing-rails-partials.html" />
<id>tag:broadcast.oreilly.com,2008://53.33725</id>

<published>2008-10-09T14:06:20Z</published>
<updated>2008-10-09T14:06:20Z</updated>

<summary>Test Driven Development works best when each test case targets one aspect of a class&apos;s interface. So this post will demonstrate a simple and direct way to test a partial without testing the Views, layouts, and Controller actions surrounding it. On very complex projects, this technique keeps your partials decoupled.</summary>
<author>
<name>Phlip Plumlee</name>
<uri>http://www.oreilly.com/catalog/9780596510657/</uri>
</author>

<category term="rails" label="rails" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="ruby" label="ruby" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="tdd" label="tdd" scheme="http://www.sixapart.com/ns/types#tag" />
<category term="xpath" label="xpath" scheme="http://www.sixapart.com/ns/types#tag" />

<content type="html" xml:lang="en" xml:base="http://broadcast.oreilly.com/">
Test Driven Development works best when each test case targets one aspect of a class&apos;s interface. So this post will demonstrate a simple and direct way to test a partial without testing the Views, layouts, and Controller actions surrounding it. On very complex projects, this technique keeps your partials decoupled.
</content>
</entry>

</feed> 
