Rails in the Large: How Agility Allows Us to Build One Of the World’s Biggest Rails Apps

Published May 12th, 2010 Under Coding | Leave a Comment

Neal Ford shows what ThoughtWorks learned from scaling Rails development: infrastructure, testing, messaging, optimization, performance.

http://www.infoq.com/presentations/ford-large-rails

Removing Duplication by Refactoring

Published May 5th, 2010 Under Coding | Leave a Comment

This video removes the duplication in the add and subtract classes by introducing an abstract base class. The end result is a use of the template method pattern.

Video Producer: Brett L. Schuchert

Learning how to use the Extract Interface Technique

Published February 22nd, 2010 Under Coding | Leave a Comment

In this episode we are going to take a look at another refactoring technique, the Extract Interface technique. This technique allows you to extract an interface from a class in order to break your concrete dependencies. By doing this you can provide yourself with better testing support as well as a better layer of abstractions.

http://www.dimecasts.net/Content/WatchEpisode/163

The Pair Programming Show

Published January 20th, 2010 Under Coding | Leave a Comment

Did you try pair programming but it didn’t work? Are you wondering if it’s worth it? In this live play you’ll follow a team as they go through stages and struggles of learning pair programming. You’ll see anti-patterns in practice so you can recognize them, and you’ll learn the small subtle things that is the difference between wasting time and a high productivity. Get the popcorn ready and open your mind. Pair programming can be a big boost – if it’s done right

Watch this video on Oredev.org

How Do I Refactor my Code in Visual Studio?

Published January 14th, 2010 Under Coding | Leave a Comment

These two videos show how to use the refactoring tools in Visual Studio.

Video Part 1

Video Part 2

Edgecase Dialog: Ruby Code Review

Published January 14th, 2010 Under Coding, Software Testing | Leave a Comment

Sit in like a fly on the wall, while Jim Weirich and Joe O’Brien walk through a code review. The team has uncovered some very typical issues that can arise in Ruby projects. The code review is presented in three acts. Act I is a review of a typical rails application. Having added some testing and followed the typical restful conventions, this application seems pretty solid on the foundation. As Jim and Joe demonstrate, however, the application has some areas of concern. Act II is a code review for an open source gem. The team demonstrates some critical mistakes that library writers usually make and show ways in which the code could be written in order to play nicer in the open source ecosystem. Act III is all about strategy. Now that we have identified the areas that need to be worked on, how do we go about getting there. It’s unrealistic to stop all development and rewrite the two projects. The team helps the client figure out a game plan that allows them to continue moving forward.

http://scotland-on-rails.s3.amazonaws.com/2A08_JoeOBrianJimWeirich-SOR.mp4

Pairing 101

Published November 16th, 2009 Under Coding | Leave a Comment

Pairing 101 aims to introduce what kind of activities are good for pairing and which aren’t. It will also try to explain how you can develop your skills and also explain how to be an absolutely atrocious pair.

http://skillsmatter.com/podcast/java-jee/pairing-101

Introduction to NDepend: Adding NDepend to your Nant Script

Published November 11th, 2009 Under Coding, Software Testing | Leave a Comment

This episode we are we are going to take a look at the NDepend static analysis tool. When taking a look at NDepend we are going first to do a simple fly-by of how to setup and run NDepend. Once we have our simple project up and running we are going to turn our focus at takig a look at how to run NDepend from our NAnt scripts. Running NDepend as part of our builds will allow us to have a clear picture of the state of our code with each build.

http://www.dimecasts.net/Content/WatchEpisode/149

Test-Driven Development With Refactoring

Published September 24th, 2009 Under Coding, Software Testing, TDD | Leave a Comment

Success on an Agile project relies heavily on the people in the trenches. Developers, testers, and product managers focused together, can deliver astonishing accomplishments in a short amount of time. Extraordinary results require discipline, motivation and alignment. Test Driven Development (TDD) and Refactoring creates the momentum to help developers organically adapt to an endlessly changing world. In this hands-on tutorial, you will see and try simple TDD and Refactoring exercises. The session is split in two videos.

The Synergy of Code Contracts and Pex

Published August 26th, 2009 Under Coding, Software Testing | Leave a Comment

Manuel Fähndrich and Peli de Halleux sit down for a quick coding session that shows how to use Code Contracts and Pex together. Code Contracts can be used to specify what your code should do, they get turned into runtime checks which Pex can analyze and try to find counter-examples for. This was a fun session with Manuel and really shows the synergy of the two tools/approaches.


Get Microsoft Silverlight

« go back — keep looking »