Hacker News new | past | comments | ask | show | jobs | submit login
Ruby and .Net Developers solve two different kinds of problems (nitriq.com)
11 points by viggity on July 14, 2010 | hide | past | favorite | 37 comments

Interesting having a sales pitch in the last paragraph.

I think it's a good idea to promote your product with interesting/educational content... though there is nothing to differentiate the pitch from the content here (it's heading towards "advertorial"); and 37signals do this all the time without needing to mix the two.

But it also makes me question the whole post - did it exist purely for the purpose of carrying a sales pitch? And on reflection, I do find the content a bit lacking: "perhaps the language is too verbose" was interesting; and it seems very true that Ruby is used for small projects, and .Net are used for enterprise-size projects; but his conclusion, that "the resulting code is going to be verbose" doesn't connect to the question, which was about the language being too verbose.

A way to connect them is that huge projects have more names, and so you need longer variable/method/class names to distinguish them (I'm including namespaces in name length here); and in huge projects, you need names that are more self-descriptive (because it is so important than someone else will be able to understand it, someone who might not ever get to meet you to ask you) - and self-descriptive names are long. You'd like to reuse this full information without the typing. Hence, intellisense.

Yeah, I was a little unsure whether or not to include the last paragraph, but I did up with the idea for the post not thinking about how I could use it to pimp my stuff.

glad to hear it!

btw: keep the paragraph - pimp your stuff by all means - and (eg) a simple bar <hr> would separate it; that's how 37signals and Joel do it (of course, maybe it's just me who was distracted by it). While it is very effective advertising to integrate it into the story (a kind of product placement), it's harder to do both well than focus 100% on the content.

FTA: "But even after borrowing as much as we can from Ruby, it isn’t going to make the gigantic complicated sales management system for a Fortune 500 company be not gigantic and complicated. Hopefully it will be a slightly smaller and more simple, but that application is never going to be so simple that you don’t need an IDE or intellisense. "

This is just nonsense. I used to be a .NET developer before I jumped to Ruby. The Rails application I develop on now has well over 1000 class files, plus all the associated views, etc. It's at least as complex as this mythical, undefined "enterprise application" ( a meaningless distinction) the author speaks of, and our team of 4 manages just fine using text editors.

The only reason Intellisense is needed in .NET is because it's such a verbose language. If you want to open a file in .NET, you've got to create a FileStream object, and then a StreamReader object, and blah blah blah and before you know it you've got a dozen lines of code. In Ruby, you type "File.open(filename)". Done!

Ruby just gets out of your way, whereas .NET is often an obstacle in the way of what you want to accomplish.

What about System.IO.File.ReadAllText(path); ?

That said, even if the language required more than one line to read a file, that wouldn't be a good example of a language being verbose. That would be an example of a missing shortcut in the standard library, which is an important distinction (the latter is much easier to fix than the former.)

> Ruby just gets out of your way, whereas .NET is often an obstacle in the way of what you want to accomplish.

To .NET's defense, Microsoft seems to be very aware of this. New features in .NET and C# are specifically designed to get out of your way. The language's verbosity is definitely on the decline. It's nowhere near Ruby's level, but for a mainstream, "Fortune 500" platform, it really isn't half bad.

File.Open - http://msdn.microsoft.com/en-us/library/b9skfh7s.aspx

There's a subtlety to API design -- and naming in particular -- that's separate from writing the code and getting it to work. You can get by in .NET development with classes like ObjectFactoryManagerBase, and rely on Intellisense (or, worse, copy & paste); or you can put some up-front thought into designing a usable set of components and giving them clear names.

My theory: As a dynamic language, Ruby doesn't scale, but not in terms of performance--it doesn't scale in terms of developers. Projects written in dynamic languages have a development edge at smaller scales--more functionality can be produced faster by fewer developers.

If a project expands to a large number of number of developers, eventually the power to do virtually anything becomes a liability when a lone bad developer can wreak havoc on a project-wide scale by redefining standard functions, or relying on scary monkey patches.

In practice, this doesn't happen nearly as often as you might like to believe. Where I work, we monkey patch occasionally, but never the standard functions. It's usually a 3rd party library that we're editing that we need to bend to suit our use case.

Is your shop 20+ developers? Monkey patching isn't dangerous in and of itself, to my mind, but the prospect of code-surprises is ever present. When I read code, I may not realize it has been overwritten elsewhere. I'm not sure at what number of hires that guy makes his way into the group, but debugging becomes an increasing part of development costs.

Huge applications have been built in dynamic languages. It just requires good architecture and code discipline. But that's true of development in any language.

I'm not saying that there haven't been gigantic applications written in dynamic languages. But the number of gigantic apps built on Ruby pales in comparison to .Net or Java.

Having static typing helps prevent these massive apps from becoming an even larger cluster.

I've heard a lot of hand waving arguments on both sides of this issue and at this point I'm not going to be persuaded by anything other than hard numbers. We need some way of quantifying the size and complexity of an application and then we need a statistically significant sampling of apps in both static and dynamic languages. At this point anything less than that is just conjecture.

We can do the "ruby doesn't scale" dance back and forth all day but we're not really learning anything.

I don't think he did a very convincing job of explaining Intellisense. Frankly, one of the reasons I avoid Python and Ruby for my projects is that there's simply not a good IDE for either of them. The Eclipse plugins make me want to cry as I pound CTRL+space in vain trying to get autocompletion to work for a class I defined the same file I'm typing in.

In VS.NET, intellesense doesn't just reduce the amount of typing you do. I mean sure, it does and all. It reduces it to pretty much zero. You can put the cursor on an empty line and hit CTRL+space and it will suggest "for". It knows everything about the language, and everything about the class library it's dealing with, and everything about every class in your project, and everything about stuff you haven't even referenced. It knows context too, so it'll figure out what you actually want to see.

But that's not why you need it. It knows your codebase so you don't have to. It knows all the class libraries so you don't need to memorize any of them. It compiles your stuff as it goes so that you can navigate around it like everything was hyperlinked. And it doesn't find things by matching strings, so you can refactor to your heart's content without breaking anything.

All of that is stuff you want to do in Ruby. It's an awesome language and all that, but it still needs to open files and I don't want to keep file opening in my head, so I need a tool that lets me type "File." and pops up a little menu telling me properties of the File class.

So no, it's not that we're doing different things. We're doing the same thing. I just feel like I have a lot more space in my brain to keep domain stuff because it's not filled with the entire content of my codebase.

If IDE is your primary hang up -- go with IronPython, which has integration into VS.Net : http://www.ironpython.net/tools/ (including intellisense).

I wonder if Twitter, Scribd, Hulu, Friends for Sale would agree.

I agree that .Net projects do tend to differ from Ruby projects. But I'm not willing to be as definitive as the author by saying "Ruby and .Net Developers Solve Two Different Kinds of Problems". That's too black and white for me.

Also, the fact that there are IDE's for Ruby (RubyMine and Netbeans) shows that there is becoming more of a desire / need for an IDE in the Ruby world. Even the good old standard of using TextMate mixed with a zillion plugins / macros shows a need.

Getting back to the point of the tweep's original question though; If a person doesn't understand the value of intellesense, they're not doing it right.

If a person doesn't understand the value of intellesense, they're not doing it right

I think the argument against a full-blown IDE which optimizes code-writing is, if it's possible for an IDE to make your code easier to read or write, why isn't it possible to simply improve the programming language itself to make the code easier to read or write? Some sort of automated code translation/compression/generation is improving the coding experience for you, the developer. So why can't that improvement be baked into your compiler/parser/libraries, so the program's code reflects that improvement regardless of the tool you use to view it?

I was once at a lunch with one of the Franz Allegro lisp dudes and he said that he'd had an epiphany about the nature of Java and IDEs. He said Java does have macros in a sense, it's just that they're one way and built into the IDE.

I don't buy this argument that "enterprise" software requires enterprise languages and tools either. There are plenty of counterexamples of large, complex systems built in dynamic languages.

Regardless of how simple a ruby API is, I can't keep them all in my head. That's why there are tools like ri and the various ruby doc sites. Having that integrated could be useful. When I do a lot of coding, I usually have a lot of browser and textmate windows open for reference.

This is what I'm referring to. An IDE should make what I already know easier to get from brain to fingers to keyboard to screen.

Intellesense does this by letting me type a couple chars of a known method, then pressing tab.

It should also make what I kinda know easier to find.

A good IDE does this by letting me find a method in intellesense and showing me the method description.

I think you misunderstand what intellisense does. For example, if I start typing a method name then it will give me the possible completions from which to choose and if I call a method it will remind me of the parameters required. These are not things that can be "baked into the compiler/parser/libraries".

If your thesis were correct, (which I don't think it is) then you could just as easily argue that Ruby is verbose because Rails auto-generates code.

I work at a large "enterprise" company (35,000+) and .NET is the primary tech for in-house custom application development. Much of the development is built around SOA, so there are very few "standalone" apps that is considered "enterprise" in size/scope (i have limited industry exposure, but i highly doubt many org's build anything truly resembling "enterprise" software -- they buy it).

Being familiar with .NET and Ruby/Rails, you would be hard-pressed to find .NET development in my org that couldn't be done as well as or better in Ruby/Rails.

The reality is .NET is a "safe" choice for large businesses. The people making these technology decisions do not understand (or care about) the technical aspect of the technology, but rather look for the status quo/known quantity (few large firms want to use 'unproven' technology), support contracts (if something breaks we can at least get the vendor to fix it), available/sustainable (and ultimately off-shoreable) labor, and a "unified platform" (Exchange email leads to active directory leads to MS product A leads to MS product B, etc.).

It comes down to the high-level IT governance, and what IT steering committees are comfortable with staking their reputation/jobs on.

"No one ever got fired for buying IBM (or MS)"

The only reason why .NET and Ruby/Rails developers solve different kinds of problems is because management are large companies are too scared/lazy to try out new solutions, thus Ruby (and many other lang devs) aren't even allowed to solve ".NET problems".

Anyhow - the article was just a nice little PR move anyhow.

I think the larger misconception he has is that Ruby developers solve the same kinds of problems as .Net developers. They don’t. Not even kinda.... In general, Ruby developers create small to medium size websites ... On the other hand, .Net developers create a lot of large scale enterprise applications.

OK, so what are some of the .NET enterprise applications that are too complex to be built in Ruby - or at least are better built in .NET?

I'm not saying that you can't build large complex applications in Ruby. You can. You could also write them in Brainfuck. Having static typing helps tremendously when you have a team of 50 developers and 15 BAs. There are so many moving parts and edge cases that having an IDE and autocompletion is a must have. A team of 50 ruby devs are going to have a heck of a time keeping track of all of that business functionality without an IDE.

We're on our first steps towards building a new insurance underwriting and policy administration system, with built in rules engine and all that (for an U$ 150 million dollar company).

Why would you think that would be better done in Ruby? (not flamebait, just honest question - never programmed in Ruby)

> “It just seems to me that if intellisense really drastically reduces typing, perhaps the language is too verbose”.

@viggity ... your friend is right ;)

But it's not the language (C# is decent) ... it's the company behind it, the community, the culture, which ultimately contribute to God-awful libraries.

Also, please don't hide behind the "scalable enterprise applications" argument.

Show me any CRM, and I can make with you a bet that the stuff 37signals does is way harder ... even if their products are simpler in functionality, a small company that sells products straight to consumers has drastic budget and time limitations, not to mention the burden of meeting consumer expectations (which with enterprise apps doesn't happen, because enterprise apps are awful by definition).

Also you want to talk about applications ... but I still haven't found a good CMS written for .NET (commercial or open-source), even though a CMS is nothing new and even though for PHP you can find a dime and a dozen.

Again, it's not the language, it's the culture ... go have a look at http://playframework.org , a gem among piles of shit that are forming the Java ecosystem.

I really dislike articles like this. They are fluffy and one sided. The author clearly has little experience with Ruby. I've never used Ruby in a mission critical project, and clearly neither has the author.

As primarily a .NET developer would love to see the day where I could comfortably ditch VS and use Vim instead. Instead I settle for VsVim. But is that really something MS is striving for? Of course not.

Perhaps my article was a little fluffy, but I guess I wanted to take a second to stick up for .Net. It takes a lot of bashing (some of it deservingly), but a lot of the criticism too is one sided - .Net has to support a lot more types of applications than Ruby does and that is going to lead to verbosity - and the people bashing it don't take that into account.

I don't think .NET has to support different "types" of applications. I think just about anything you can build in .NET you could do in Ruby. Ruby has a bit of a reputation for being on the slow side, and sometimes that can be an issue, but other than that, it's a general purpose language with a vibrant community, so in the end rather capable.

I think the difference lies more in the cultures. .NET was born out of the largest software company in the world with billions at stake. That alone ensures it will be on the conservative side. Whereas Ruby was born more in the open source and start up community, it has more freedom to just go for it. Look at Rails 3, massive changes and a general attitude of "this new way of doing it is better, so buck up." Which is fine, perfectly fine, for Ruby. Microsoft would never get away with that (take ASP.NET 4 for example, they went to exhaustive lengths to make sure it can be ran in "legacy" mode). The jump from .NET 1.1 to 2.0 was a painful one, and so was 3.5 to 4, and Microsoft knows that. Yet they still maintain admirable backwards compatibility despite all of that. They took serious effort to make sure from 4 on, .NET releases can live side by side. I don't think your average Ruby framework/library/whatever would care so much.

I work professionally with Ruby and .NET. The current project I'm working in is written in Ruby; the project before that was written in C# 3.5.

I use Intellisense a lot in C#, but oddly I don't miss it when I'm programming in Ruby. And when I'm programming in Clojure, I do have "Intellisense" via SLIME, but I don't actually use it a lot.

I'm not entirely sure why this is the case, but I'd speculate that it's because the REPL takes the place of Intellisense.

In C#, I use Intellisense to remind me how a library works, and to explore the API. In a language like Ruby or Clojure, I have a REPL permanently open, and I use that for exploring the API, or reminding me how something works. It takes a couple more key presses to get to than the Ctrl-Space of Intellisense, but the REPL is more powerful. Also, modern REPLs usually support tab completion, so you can use it like Intellisense.

Come to think of it, I use the SLIME REPL so often I should probably add an explicit keybinding for it.

As someone who does consulting on both Ruby and .Net regularly (and appreciate both), I'd love to believe I solve 2 totally different problems (heck, that could mean I'm twice as good :-).

But no, really: I believe that apart from desktop UI-heavy applications (and I do work on this), Ruby and .Net can be used for exactly the same topics.

It feels a bit like if the headline is intended at reassuring people: you're not doing Ruby ? That's not that bad, it's ok.

My personal belief is a developer that doesn't have a grasp at both static (java/c#) and dynamic (be python or ruby or...) is really losing something there.

I must have missed something...how did we jump from questioning Visual Studio to the conclusion that Ruby and .Net developers are solving problems in different domain spaces? There are IDE's for Ruby, good ones. What does that matter though?

My own personal summary:

- it's ok if you're suffering everyday with over-engineered codebases

- we provide a tool to ease the pain - go buy it!

Admittedly, this is part flamebait, but I think I make some pretty reasonable assertions.

It certainly made me reevaluate my thinking on the two languages and problem domains. The only small bit I'd disagree with is that Ruby is only used for websites, but I'll hardly create a fuss over that.

If people are looking to poke at you, they'll do it, but otherwise, I'd say, yeah, it's a reasonable observation/opinion.

Do we even want big, complicated ruby apps? I thought the current thinking was that monolithic apps == bad, and smaller miniapps == good. It's definitely much easier to get up and running with a small Rails app that just grows and grows. But at some point, you should step back and figure out how to extract services out into isolated miniapps. We're going through this now at GitHub.

Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact