This week on Herding Code, Cory Foy and Will Green join the guys to discuss general differences between .NET and Ruby development approaches. Is the grass always greener on the other side? Listen in on this week’s talk about how languages, frameworks, tools and cultures shape the way we implement .NET and Ruby solutions and judge for yourself! 

  • Kevin kicks off the conversation noting differences between design patterns and best practices in the .NET and Ruby worlds. Kevin opens up a discussion by calling out the .NET developer obsession with persistence ignorance versus the use of the ActiveRecord pattern found in Ruby on Rails. 
  • Cory talks about basic CRUD applications vs complex domains and how applications tends to model themselves after organizational structure.  Often times you will find .NET code tends to be more complex whereas simpler domains are often represented in Ruby code.
  • Kevin asks about domain-driven design. Cory talks about the expressiveness of Ruby code and how the introduction of the dynamic keyword makes expressiveness a little easier in .NET.  Will talks about Ruby mixins facilitating a different development approach.  Will also comments on the ceremony of creating .NET vs Ruby classes and how easily you can express the business concerns in Ruby.
  • Scott K talks about his general impressions of Rails – focus on the presentation layer first rather than a DDD approach which would focus on the model first.
  • K Scott talks about manifest typing and states that there is an importance placed on types rather than behaviors in .NET coding.  Will calls out the fact that in .NET coding we often are most interested in what an object is whereas in Ruby we primarily care about what an object can do.  This ties back to static typing vs duck typing.
  • Cory speaks to outside-in development in Ruby, exposure to TDD and learning Rails with Cucumber from the beginning. 
  • Jon acknowledges the language and framework differences and asks how cultural differences between the two development camps might drive development practices.  K Scott talks about .NET developer dependence on the compiler rather than working with customers.
  • Kevin talks about the “need” for viewmodels in .NET MVC whereas models are being passes around throughout a Rails application. Cory talks about the power of meta-programming in Ruby and the shift between classes being parsed in .NET vs classes being executed in Ruby.  He also speaks to how fundamental constructs will shape a development strategy.
  • Cory talks more about meta-programming and convention over configuration.
  • Kevin talks about the “No Magic String” rule, static analysis, and Resharper-driven development.  Will states you don’t really need refactoring tools or even an IDE when coding Ruby. Cory talks about the emphasis on writing tests for Ruby code and how this acts as a replacement for the static code analysis testing you might get from the compiler. Scott K speculates that there’s so much more code in C# so there’s a larger need for refactoring tools. 
  • Cory ask why we are still not testing in the .NET world? Why aren’t we doing migrations?  Why are we so focused merely on what is available in the Visual Studio IDE?  Scott K feels .NET developers are still unsure of what they should test.  Scott K also thinks it is hard to mock stuff and .NET developers aren’t used to writing decoupled code. Will speaks to the fact that Ruby all classes are open all the time and nothing is sealed.
  • For better or worse, Jon notes that it’s easy to think of the compiler as the first .NET test and, though it could be considered a crutch, the IDE provides one with a lot valuable coding help with intellisence. Cory talks about craftsmanship and how the primary audience for IDE support and refactoring tools is not the TDD developer.
  • Kevin speaks to the fact there’s no need for an IoC container in Ruby and Cory shares the dangers of becoming married to any framework in .NET development.
  • Jon asks if Ruby development can become unwieldy because it’s so easy to get started. 
  • Scott K asks about new language features (for examples, lambdas, dynamic keyword, optional parameters) and how this adds to the complexity of .NET development. Will talks about complexity vs power and Cory adds that new features allows developers to approach problems differently.
  • Kevin asks about techniques which can be used with the dynamic keyword.  Scott K talks about the addition of Eval() in C# 5.  Jon jokes about the “Compiler as a Disservice.”  Cory talks about fundamental challenges with Dynamic and Eval() in a statically typed language.
  • The guys talk about dependency injection.
  • Cory talks more about craftsmanship and code quality. Will talks about values and taking a stance when promoting a frameworks and points some blame at Microsoft for giving .NET development dozens of ways to complete a single task.
  • Kevin asks about the focus around Behavior-Driven, integration testing in Ruby rather opposed to the fine-grained unit testing approach often found in .NET development.  Will speaks to the outside-in testing approach but also the importance of unit testing in Ruby.
  • Scott K asks if IronRuby makes .NET development easier.
  • The show wraps with Will and Cory pimping their up-coming presentations in Florida and Norway.

Show Links:

Show notes compiled by Ben Griswold. Thanks!

Download / Listen:

Herding Code 82: Cory Foy and Will Green Compare .NET and Ruby Development

Audio clip: Adobe Flash Player (version 9 or above) is required to play this audio clip. Download the latest version here. You also need to have JavaScript enabled in your browser.

Bookmark and Share