Build an App
4. Eliminating Duplication
By Corey Haines, 50m

"Duplication is the root of all evil!" is a phrase we certainly hear a lot in software development. This is a bit harsh and over-the-top, of course, but it definitely is something we want to keep watch on. Eliminating duplication when we find it, early on in our lifecycle, is a good technique to master. It makes our software more accepting to change in the future, especially change we aren't able to anticipate.

Through our previous episodes, we allowed a bit of duplication to spread regarding the states that a coderetreat can be in. If we let this go on for much longer, it will become much more difficult later to change them. It is time to put our foot down and remove this duplication. When working on a new system, timing is the key and we won't wait any long to address this cleanup task.

In this episode, we'll take a break from adding new features and focus our attention at the concept of duplication, specifically the duplication of knowledge around the statuses of the coderetreats. We'll discuss the different types, and then investigate two different methods for eliminating it by isolating the knowledge it represents: an outside-in, wishful-thinking approach; and, an inside-out, pull-down approach. By the end of the episode, we'll have a central location in our system that contains this information.

And, of course, there is a lot of coding. The results of this episode's coding is in the git repo up on github.

Once you purchase the episode, send an email to Corey and get an invite to the "Discuss BAWCH" mailing list.

If you've missed any of the first 3 episodes, check them out here:

3. 2nd Feature
By Corey Haines, 1h 1m

Purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.


Now that we've finished our first feature, where do we go from here? In episode 3 of "Build an App with Corey Haines" we'll not only talk about how our Feature Support Diagram can help us choose the next feature, but we'll dive right in and start it. This episode is all about the code, so we won't be satisfied with just starting it, we'll take it to the finish!

While building this new feature, "Updating the status of a coderetreat", we'll use a strict outside-in approach to our coding. Starting at the view layer and moving inward with a hearty dose of programming by wishful thinking, we'll see more and more of our design coalesce around our domain concepts. Our last episode introduced the concept of a presenter, distancing our business domain away from the Rails framework. In this episode, we'll benefit again from this philosophy, except on the updating side, creating a simple coordinator object.

In Episode 1 and Episode 2, we noticed some awkwardness around some names we chose. At the time, we postponed fixing them until we had more knowledge about our domain. In this episode, we'll see awkward names again, but this time we won't stand for it! After implementing the feature, we'll take time to clean up our design by extracting a new resource. We'll discuss the strategy of making structural changes incrementally, keeping our system working at each step. This is a coding series, so we won't just discuss it, we'll put hands to keyboard and make the changes!

And, of course, there is plenty of ongoing discussion about outside-in development, programming by wishful thinking and how our tests can influence our design. Check it out!

After you purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.

Missed an episode? Get them here. - Episode 1 - where do we start? - Episode 2 - our first feature

2. Finishing Our First Feature
By Corey Haines, 56m

Purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.


In our last episode (check it out here), we got the basic skeleton of our first feature done with some dummy data. In this episode, we'll finish our feature "Viewing Running Coderetreats" by pushing our dummy data down into our stack. In the end, our dummy data will disappear, and we'll be left with a complete full-stack implementation, from browser to database. As we finish, we'll see how the use of "Programming by wishful thinking" in the last episode set us up nicely to see exactly what our next steps are.

Along the way, we'll begin our conversation about testing. Of course, testing techniques and strategies will be a point of discussion through the whole series, and this episode begins our dive into a better of understanding of the topic. We'll discuss a definition of the difference between test-first and test-driven development, and how these differences affect our strategy.

Fast tests are a big point of discussion these days, so we'll look at a couple initial ways to achieve them in Rails. Just as importantly, we'll spend time talking about the WHY behind fast tests and try to clear up some common misconceptions about the goals.

After you purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.

Missed the first episode? Get it here: - Episode 1 - where do we start?

1. Where Do We Start?
By Corey Haines, 43m

Purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.


So, you've figured out what features you NEED to build. But now you have the problem of deciding which one to do first. And once you've decided, how do you go about building it? You could, of course, start with an easy one, like user management. But what value would that add? Or, perhaps you'll start with one that suits your mood. But does that add value? Maybe start building a data model diagram? Aaargh! How to decide?

In our first episode of "Build An App With Corey Haines" (lovingly referred to as BAWCH), we'll discuss just this question: where do we start. We'll talk about the fuzzy idea of "business value" and introduce a technique called Feature Support Diagrams. When finished, FSD diagrams literally have arrows pointing to the feature where you should start. And once we've chosen, we'll begin building. We'll look at creating our first two scenarios using Cucumber, then making them pass using a "Programming by Wishful Thinking" outside-in style of development.

Along the way, we'll discuss a lot of the little decisions around starting, all the while moving forward towards our first usable feature.

After you purchase this episode, send your purchase code to Corey and get an invite to the exclusive "Discussing BAWCH" mailing list.