Jason Rudolph

By Jason Rudolph

Contributing to open source is great for your career. In a few short hours, you can learn, teach, promote your skills, and improve the quality of the community. In this session, we will show you how, by doing it.

We'll take an existing open source project, and show you how to:

• download the source code
• build and run tests
• use Cobertura and code review to find problem areas
• refactor some code
• create and submit a patch

You can check out the contributions that resulted from past Refactotums at http://blog.thinkrelevance.com/twir

By Jason Rudolph

With an expressive language such as Ruby and with modern test practices, 100% C0 test coverage is readily achievable. But 100% coverage is meaningless without other supporting habits and practices. Over the last few years, we have taken dozens of projects to 100% coverage, and there are still plenty of things that can go wrong.

We will look at examples of each of these problems (and others as well), and show how to prevent them from infecting your project.

• Fragile Mocking
• Incidental Coverage
• The Ugly Mirror
• Overspecification
• Slow Tests
• Underspecification
• Shallow Tests
• Invisible Code

By Jason Rudolph

By now you've probably heard about Git - the version control system used by the Linux Kernel, Ruby on Rails, Google’s Android platform, and many other projects. Perhaps you've heard something along these lines: "Git is a version control system, and it is more powerful than Subversion in every way. You don't even have to be online to commit" This is true, but it vastly undersells Git.

Git is not the next step in the evolution of centralized source control, following in the footsteps of CVS, SVN, etc. These tools provide centralized history of deltas, where Git provides distributed history of trees of content. In this talk, you will see the advantages of the Git approach:

• Incredible speed.
• Local, disconnected operation.
• Source control workflow customized to your team. Centralized, distributed, or layered, you can build it with Git.
• Cheap and easy branching, tagging, and merging.
• Editing and refactoring your commits.

The Git community prefers power to ease-of-use, and so Git’s user interface and documentation can be intimidating. You will learn the straight and narrow path for common, day-to-day Git operations. You will also learn Git’s underlying data model, and get a quick introduction to more advanced concepts including submodules, cherry-picking, and bisection.

As a final bonus, you will see how to use Git on an existing SVN project. You can use Git as your SVN client, and the rest of the team can stay on SVN and not even care.

By Jason Rudolph

The rise of Ajax and Rich Web Applications, plus the success of dynamic languages, has caused people to revisit the JavaScript language. Now that we take JavaScript seriously as a language, it is time to get serious about the quality of JavaScript code, through refactoring. In this talk, we will approach refactoring JavaScript in three phases: 1) Test first, then refactor. 2) Refactoring 101. 3) Overcoming common problems.

• Test first, then refactor. Bring JavaScript code under test, so that you can refactor with confidence.
• Refactoring 101. Explore some important refactorings: composed method, extract method, introduce named parameter, and extract object.
• Overcoming common problems. Work through three problems endemic to legacy JavaScript code: making JavaScript unobtrusive, refactoring to prototype-based inheritance, and refactoring to functional style.