1. Your Program is a Special and Unique Snowflake

  2. My issues with Let

  3. Refactor Until You Feel Almost Comfortable

  4. Splitting an open source project in two with Git submodules

  5. Keeping the Front-End Modular with BEM

  6. Lazy Refactoring

  7. Collaboration is Other People

  8. Back to Basics: Anonymous Functions and Closures

  9. How to Stop Voodoo Programming

  10. Prefer Objects as Method Parameters, Not Class Names

  11. Back to Basics: SOLID

  12. Meditations on a Class Method

  13. Let Your Code Speak For Itself

  14. Refactoring with an Apprentice

  15. Introducing Hound

  16. Removing Sass Duplication Using Sass Maps

  17. Clearer Conditionals using De Morgan's Laws

  18. Ruby Science: Extracting and Using Classes

  19. Ruby Science: How to Eliminate Feature Envy and Comments

  20. Refactor in a branch

  21. Better serialization, less as_json

  22. Code that says why it does

  23. Let's Not

  24. Don’t Repeat Your Ruby Constants in Javascript

  25. Refactoring: Replace Conditional with Polymorphism

  26. Expressing the problem

  27. Name It

  28. Tell, Don't Ask

  29. How Much Should I Refactor?

  30. Types of Coupling

  31. Beware Homonyms

  32. Read between the lines

  33. Humans Present: Refactoring

  34. Come Correct with Inject and Collect

  35. How to Extract an Intention-Revealing Name Using Vim

  36. What is good code?

  37. Decorators Compared To Strategies, Composites, and Presenters

  38. Rails Refactoring Example: Introduce Null Object

  39. Watch for Turbulence

  40. Derive #inject for a better understanding

  41. Inject that Rails Configuration Dependency!

  42. Evaluating Alternative Decorator Implementations In Ruby

  43. Tidy Views and Beyond with Decorators

  44. The One-Method Silent Killer in Your Cucumber Suite

  45. Design Patterns in the Wild: Null Object

  46. Separate your filters

  47. Getting Sequential: A look into a Factory Girl Anti-pattern

  48. Unobtrusive Ruby

  49. A Paperclip Refactoring Tale: Part One: Dependency Injection

  50. ActiveRecord, Caching, and the Single Responsibility Principle