Hacker News new | past | comments | ask | show | jobs | submit login
Poll: What's Your Favorite Programming Language?
2423 points by GreekOphion on March 23, 2012 | hide | past | favorite | 570 comments
What's your favortie programming langauge?

Below are the most popular languages. If your favorite isn't below select other and comment what it is below.

Note: By voting for a language you are not up voting this poll. Please up vote this poll to keep it alive.

Python
3240 points
Ruby
1805 points
JavaScript
1492 points
C
1032 points
C#
886 points
PHP
711 points
Java
590 points
C++
570 points
Haskell
567 points
Clojure
476 points
CoffeeScript
375 points
Lisp
341 points
Objective C
335 points
Perl
335 points
Scala
253 points
Scheme
199 points
Other
193 points
Erlang
169 points
Lua
150 points
Smalltalk
128 points
Assembly
110 points
SQL
110 points
Actionscript
106 points
OCaml
88 points
Groovy (Added Two Hours Late Due To Requests)
80 points
D
78 points
Shell
75 points
ColdFusion
50 points
Visual Basic
46 points
Delphi
45 points
Forth
41 points
Tcl
34 points
Ada
28 points
Pascal
28 points
Fortran
25 points
Rexx
13 points
Cobol
11 points



C# really feels like the most mature language that I've ever dealt with. Writing it feels clear, if something is wrong the debugger is very clear. The number of features that are there is incredible (especially post C# 2.0 when they added generics). Properties are delightful.

How do you convert to a string? Convert.ToString(). How about an integer? Knowing only that one, it's what you'd expect!

I also picked JavaScript because I am in a love affair with this weird little language. I also think it is one of the easiest languages to teach basic programming with (videos forthcoming).

The amount of time it takes to whip up a five-cent program with javascript without even leaving my browser, heck without even leaving this tab is just astounding to me even after all these years.

One thing I noticed though while writing this comment is that more than the language itself, the tools that I use while building things in the language are what really make them a pleasure to use. If I wasn't using Google Chrome's web developer tools I'd probably consider JavaScript to be a nightmarish corpse of a language that punishes the slightest of typos with a silent malicious grin, as code execution carries on as if A.blah = 5 and A.blsh = 5 were both equally worthy of existing to the JS compiler/interpreter. Only by the grace of tools is JS tame at all.


I've spent most of my time in the open source world, and I would have to agree that C# on .NET feels like the most mature high-level software development tool I've ever used. C#'s biggest strength isn't the language. While the language is nice, there isn't a lot you can do with it in terms of productive development that you can't at least approximate in Java, especially with a good IDE to generate your boiler plate for you.

Where C# and .NET really shines is in its native integration and low level facilities. How many other tools in the world let you debug a mixed application containing both native and managed code, all in the same IDE and in the same session, with the ability to set breakpoints in either area, view values, do memory watch points, and so on?

It also feels so incredibly easy to call native code in C#. There's even a whole web site dedicated to making it easier, pinvoke.net!

Lastly, C# itself contains several performance-sensitive features that have no JVM equivalent, including value types, unsigned integrals, and unsafe code with raw pointers. The .NET platform even has an implementation of tail recursion , now, though the C# compile will not generate IL that uses it, which makes it inaccessible for most people.

When it comes to language design, C# is a little sloppy but it more than gets the job done. In terms of tools and low-level facilities for building a real-world application, C# on the Windows .NET platform feels absolutely world-class.

For my favorite language, I of course, voted for Scala!


> While the language is nice, there isn't a lot you can do with it in terms of productive development that you can't at least approximate in Java

There is no substitute for lambdas :)


Luckily C# supports them:

http://msdn.microsoft.com/en-us/library/bb397687.aspx


your parent is suggesting that java does not have a substitute for lambdas.


Which isn't true anyway, since anonymous inner classes are just very verbose and awkward lambdas. (I'm a Java hater but I'm also a horrible pedant)


True. Then again, what's the practical point of lambdas that aren't concisely expressed?


There are plenty of practical uses: http://code.google.com/p/guava-libraries/wiki/FunctionalExpl...

Note that the Guava lib specifically points out how ugly this is.

I prefer Clojure.


What's the decision procedure for whether a certain expression is "concise?"


Horrible as in "no good" pedant?

Because, no "anonymous inner classes" are no lambdas. They are, well, classes kludgily used to mimic a lambda proper.


What it is to be 'a lambda' isn't particularly well-defined. If we define it to mean an anonymous closure then Java certainly has them — so long as its free variables are final (it closes over references). On the other hand, if we define it as the operator which creates anonymous closures, then Java doesn't, because you have to actually build the closure by hand.

Since the former have a proper name (closures) and the latter doesn't, I'd be inclined to call only the operator a 'lambda'. But since you can at least 'approximate' closures in Java (with anonymous inner classes), I think it's fair to say that they are "very verbose and awkward lambdas", to some definition of lambda.


lordlicorice (the ggp of my post) suggested that there is "no substitute for lambdas" and I was intending to correct that. Anonymous inner classes are definitely a substitute.


> It also feels so incredibly easy to call native code in C#. There's even a whole web site dedicated to making it easier, pinvoke.net!

I'm with you that C# is really nice to use, but interfacing with native code is a nightmare. The reason why a whole bunch of websites exist on pinvoke is because of its poor documentation and incoherent behavior.

As far as low level goes, I'm happy with C++ (if I were an embedded engineer I would say C but it is very nice to be allowed to use the C++ niceties). I think that everyone needs to have a language that can generate native code. On higher levels, python is fine for me. I simply do not have the use for an intermediate language like C# or Java, however nice they are.


> The .NET platform even has an implementation of tail recursion , now, though the C# compile will not generate IL that uses it, which makes it inaccessible for most people.

Sort of. It just so happens that the tail call optimization does get used on x64 platforms because of an implementation detail of the 64-bit JIT.

Source: http://blogs.msdn.com/b/davbr/archive/2007/06/20/tail-call-j...


How is this C#+.NET integration on mono? Are the relevant low-level facilities translated well into linux or osx?


I like Mono, and I respect the work that they've accomplished. It is incredibly difficult to build a runtime like .NET, especially as it was never designed to be cross-platform.

That said, the Mono experience on Linux is inferior to that on Windows. MonoDevelop is nowhere near Visual Studio, so that I just develop on Windows and deploy on Linux. Unfortunately, that doesn't help the fact that both the soft and hard debuggers for Linux are nowhere near Microsoft's debuggers. It also doesn't help the fact that the runtime itself is less stable (i.e., more prone to crash) and there are APIs that only work well on Windows. I would also imagine that the Microsoft runtime exhibits much better overall performance.

My understanding is that Mono mainly excels at MonoTouch, and that is where Xamarin is making most of its money, but I am not knowledgeable in that area.


It is incredibly difficult to build a runtime like .NET, especially as it was never designed to be cross-platform.

Just a historical note: The Shared Source Common Language Infrastructure [1] aka "Rotor" is an alternative version of the .net 2.0 platform developed by Microsoft for research/education use. It can be compiled for FreeBSD and Mac OS X 10. Its rather out of date, but maybe shows that MS did make some kind of effort to make it cross-platform.

[1] http://en.wikipedia.org/wiki/Shared_Source_Common_Language_I...


I remember working on Rotor when I was at Corel.

I'm glad to see someone still uses it:)


Even outside of .NET, it's got a tool built-in to make L"strings" 16-bit on all platforms, which is cool for portability (and an implementation of nmake for unix, which can also come in handy)


Do you know how it relates to Silverlight for Mac?


The FFI is still far better than most of the other FFIs for other Linux-targeting languages. Yeah, and MonoDevelop is not equal to Visual Studio, but it's a damn sight better than almost any other OSS IDE.


How does it compare to QtCreator, do you know?


In my opinion, I'd say Visual Studio > Qt Creator > MonoDevelop. Qt Creator isn't bad, but the debugging is not nearly as great as Visual Studio. For instance, adding a variable to a watch doesn't always work (as in, variables aren't always evaluated when you'd like them to be) and I can't just type a variable name or expression into the watch window, I can't always view the memory at an object's address, and sometimes I get incorrect values (which could be something with my configuration).


Don't know, but QTCreator is a C++ IDE (I think?) which makes it a non-starter for me.


You also can develop just in QML, which is really nice.


I use MonoDevelop every day with Unity. I sometimes hear other devs complaining about it, and saying how Visual Studio is so much better. I think back to the days I used to spend struggling with multi-project solutions in Visual Studio with all its warts and crashes and weird compilation bugs, and thank heavens I'm working with a light-weight IDE.

C# is my new favourite language, and MonoDevelop is a pretty decent IDE for what it is :)


In my experience, these are the problems with developing in MonoDevelop for Unity:

- The debugger is flaky. Sometimes it will miss a breakpoint completely. Sometimes trying to inspect local variables will crash MonoDevelop. Sometimes it will refuse to continue no matter how many times you tell it to.

- If your problem starts in Unity's native code, forget about trying to debug it. The messages are cryptic and the debugger is useless. This happens for some things you can diagnose (like running out of memory, either on the machine or the card)--although good luck figuring out what your memory hog was--and for other things that leave you completely stumped (shotgun debugging becomes your only recourse).

- Don't even attempt to use text search over multiple files (other searches, like reference searches, work fine). MonoDevelop will get stuck in an unproductive loop that never displays any results and never completes.

- Forget about profiling. Unity technically has a profiler, but it's per-frame, not cumulative. It also omits a lot of detail, especially about memory usage.

- There are also a number of minor issues, too, but they aren't deal breakers so much as annoyances.

That having been said, our particular project is rather good about pushing Unity to (and beyond) its limits, and you may never encounter any of these limitations. Still, it's worth knowing that they exist.

Footnote: These comments may be limited to the version of MonoDevelop that ships with Unity 3.3 (there are non-technical reasons why it's not worth our time to go through the effort to upgrade).


Most of those issues are with Unity not MonoDevelop, aren't they?

I hear you though - debugging Unity projects is a real toolchain weakness. I'm lucky if I can even get the debugger to connect.

Text search works fine for me though! I've never had a problem with it.

My worst problem with it actually is just stability, but I've never lost work with it and it restarts pretty quickly.

What are you working on, out of interest? (If you're allowed to say!) :)


  > Most of those issues are with Unity not MonoDevelop, aren't they?
True, but I consider them as one platform (Unity and its customized MonoDevelop, specifically).

  > Text search works fine for me though! I've never had a problem with it.
It's a weird bug that was probably unique to the 3.3 version.

  > My worst problem with it actually is just stability, but I've never
  > lost work with it and it restarts pretty quickly.
I get a lot of freezes and crashes too, but to its credit MonoDevelop definitely has a very robust autosave.

  > What are you working on, out of interest? (If you're allowed to say!) :)
3-d mapping (à la Google Earth, but with different goals).


The biggest improvements that VS2008 and VS2010 made over the previous versions is that it became much more light-weight, they did a lot of work to remove cruft. If you haven't looked at VS in a long while you might be surprised.


I think the last one I used was 2008. I'll have to have a look at 2010 sometime. Very happy to hear they've spent some time reducing the cruft :)


And no self-respecting developer would ever use Mono on nix anyway because the nix tools run circles around anything .NET/Mono.


mono works fine on nix systems (little bit of tweaking with grsec), a friend has developed a few programs that he has deployed to nix systems without any issues. Initially I was quite anti it, but what the heck, if it works it works.


I knew this would be downvoted by the predominantly Windows users here but, if they knew anything about *nix, they wouldn't do that.


You were downvoted because you made an argument without supporting it, and you were downvoted again because you complained about being downvoted and still didn't provide support for your argument.

From what I gather, HN isn't so much about being part of an "in-crowd" where you "just know" the way things are. You need to be willing to explain your arguments, otherwise you're just a snob.


I once worked on a virtual usb device project on linux with Mono, at least ioctl and pointers work well for me. Use Java for this? No...

Moreover, for maximum performance, mono provides facilities for users to embed native code into the runtime, much faster than Pinvoke.


Unity3d ships with Mono/C# and MonoDevelop as one of the programming language options for its game engine. I haven't used it as much, since I prefer the Javascript version, but most (if not all) high-end game developers opt for scripting in C#.


I'd be curious to hear, why.

I will be working on a Unity3D project and the team wants me to use C# with VS. As a Mac user and Open Source fan, I didn't jump at the idea. Glad to hear, that a lot of people think C# is a good choice. I'm excited to learn it!

Any suggestions for a good book or website? I've been programming in C and C++ quite a bit, but its been a few years. I've only been doing functional programming since then and would probably need a refresher on object oriented programming.

Can someone comment on the best development environment for Unity/C# when using a 2011 Mac Air with 4GB Ram? Should I install bootcamp, use Parallels Desktop or Unity+Mono under Mac OS?


The thing to realize is that the Javascript isn't Javascript. It just looks like it. Writing good Unityscript/Javascript is going to be only syntactically different from writing C# anyway. Unityscript/Javascript is well made, but there's a few edge cases that you'll only encounter once you've already written most of the project. And mixing the two languages is messy and limited.

For C# dev, it depends how hardcore you're going to be getting. Ultimately, you normally going to be scripting, not programming. getting familiar with the Unity3D API is of more use than learning high level features of C#. For instance, while C# is object oriented, >90% of the things you write will inherit from MonoBehaviour, and most of the rest are just fancy structs.

And I code on an iMac -- I use Unity natively, and the version of MonoDevelop it ships with. It works nicely!


I know nothing about developing Unity/C#, however, I know VS runs quite well under VMWare Fusion on a MacBook Air (with 4GB of ram).


Definitely agree with you on C#. It feels like this is what a standard, mature, widespread language should be. There are other languages that are better for specific tasks, but for the general programming language, C# really hits the sweet spot in terms of features, expressability, readability, and environment. This is the language that Java should have been--could have been.

Also, I dread getting asked on my next interview "whats the one thing you don't like about your favorite language". I honestly can't think of anything off the top of my head. Granted, I've come across things that were frustrating at various times, but they never stick in my mind. I think that's a testament to how well the language has evolved.


whats the one thing you don't like about your favorite language

That's easy. So many hacker types dismiss you as some sort of weirdo for favoring anything that came from Microsoft.


Or, less glibly, it's a mostly single-platform language with support for other operating systems offered only through third-party tools.


I don't dismiss C# developers, I'm just glad I'm not one anymore.


Do you mind if I ask why? Not being defensive, just curious.


Well, I'm not the gp, but I am a former C# guy who's happy to be out of that world.

1) I dislike C#'s types; they're neither as strong and intelligent as a ML/Haskell language nor as convenient as a Python/Ruby family language.

2) I much prefer the sense of design displayed by Python and Ruby open source projects over C#. (Not that there aren't issues there!)

3) I hate Visual Studio. Nice debugger, crappy interface for writing code. Horrific user interface design for the most part. (At least back when I was writing C# back in 2009!)

4) I hate Windows. Linux and Mac are far more developer friendly. I hated dealing with Cygwin to get some sort of reasonable (crappy but tolerable) command line environment.

5) I love git. Until fairly recently, git was not available and stable on Windows. For it and for many other bits of software, windows is a second class citizen.

Shall I go on? Because I could. But I'll leave it at 5 for now.


As someone who's more than happy with C#, I'm wondering if there's a world out there I'm missing but I can't really connect with what you're saying.

1. "Strong and intelligent"? "Convenient"?

2. "Sense of design"? My current side project includes a web scraper which uses the following open source projects: AutoMapper, CsvHelper, HtmlAgilityPack, Twitter Bootstrap, jQuery, Modernizer, Moq, NLog, MongoDB C# driver, PetaPoco database driver, Rx extensions, knockoutjs and structuremap. 8 of those are .NET specific. Because of their excellent design, I have probably no more than about 30 lines of code hooking up to them (where I use interfaces) and maybe no more than 100 lines of code total utilizing them directly. Yet they conceal YEARS worth of work I would have to do myself.

3. Have you ever used Resharper? I've never heard of anything equivalent on any platform for any IDE (except for IntelliJ, developed by the same company, Jetbrains).

4. I'm fine with Windows. I find both Linux and Mac less developer friendly. I'm fine hosting my services on Linux and interfacing with them from C#, though, because it's a great server operating system. I've been using computers for 20 years and I'm happy to be away from the command line 99% of the time. What do you like about it?

5. Git Extensions + Git Source Control Provider are a completely integrated and free Git experience on Windows.


1. In Haskell and ML, I don't feel like I spend my life Listing<List<T>, X<T>>, and I have type classes. In Python and Ruby, I don't have to specify types. This lets me do all kinds of convenient things.

I don't think it's far out to suggest these sorts of advantages, and I am 100% not interested in rehashing a flame war that's been had a thousand times over. Please allow that these are my judgements, and I hope you don't need to share them to see that many people feel that way.

2. That's nice? I found C# projects to have a poor sense of design. I'm not sure how you expect me to defend an aesthetic decision.

3. I'm glad you like Resharper? I didn't. I'm a vim guy.

4. I'm glad you like Windows? I don't. I see what you mean, as long as you stay in the MS womb, it's a cozy development environment. I tend to like open source software, and it lags behind very seriously in that department.

5. As I said, I last developed C# in 2009, and I thankfully haven't had to touch Windows since. I'm sure git is nice now, but I suspect that Windows is still a second class citizen for many software projects. Git is just the one that annoyed me most back then.

It seems to me that we simply have different aesthetic criteria.


as long as you stay in the MS womb

You don't need to debase an otherwise great conversation with incendiary language like that.


I certainly didn't write it to be incendiary, and I don't read it that way?

I'm not going to go back and edit it, but I'll ask you to give me the benefit of the doubt that I meant it to be as as far from incendiary as possible.


The perhaps unfortunate metaphor the womb implies is that developing in MS tools is like being a defenseless premature baby who needs to be protected from the big bad world until they come to full term and leave the MS environment behind.


To me, this metaphor could be extended to [whatever environment you first really liked]


I am delighted to give you the benefit of the doubt. Thanks for the explanation.


We do and that was my original impression. Yet you listed a number of items even though they all boiled down to the same thing as far as I could tell. Nothing wrong with having different tastes, I just wanted to see if I was missing something deeper in each point.


I stopped at the part where you compared ReSharper to VIM

I'm guessing you like to debug using print and the command prompt as well?

For most the world keeps on spinning, for some it stops in their youth. Sad.


Hell yeah vim rocks!

So too does the command line! high five


> 1. "Strong and intelligent"? "Convenient"?

Not a C# user, but few languages of the strength and intelligence of types in ML. Covariant arrays (which C# presumably adopted for the sake of Java programmers) moves an easy, and obvious, compile time type check to runtime. The type inferencing in C# is very weak relative to ML/Haskell. The type syntax is generally more lighweight in ML/Haskell as well. For example a function that takes a list of some type ('a) and returns the head of the list if it exists or None if it doesn't looks like:

val hd : 'a list -> 'a option

Of course, all if this works in unison with other type functionality that is far more lightweight in ML than C#. The function above is only really so succinct because I have powerful variant types and pattern matching on them. I think they go hand in hand because using an option-type is somewhat useless if I don't have something like pattern matching to access its state.


C# includes the static LINQ method "FirstOrDefault()" for any types implementing IEnumerable, e.g.:

    var firstNumber = numbers.FirstOrDefault();
(This isn't strictly the same as what you described if "None" is different from "null".) Once such a method exists, does it matter how many lines of code it is written in? I posit that every language feature in a reasonably intelligently designed language serves a valuable purpose, and that everybody has different needs, and the verbosity in C# serves certain needs.

Here's an implementation in C# that is a function on types T implementing the IList interface (rather than IEnumerable like LINQ does):

    public static T Head<T>(this IList<T> list) {
      return (list == null || list.Count == 0) ? null : list[0];
    }
It is used in the same way as the FirstOrDefault() example above. Much more verbose, I'll agree! But the real question for this thread is is it less convenient, and if so why? All the verbosity stems from just a few logical places:

1. the 'option' function you have in your example. In reality, your 'option' is doing all the work I did above, which means that comparing the verbosity of your sample code to the C# equivalent of FirstOrDefault() is perfectly valid in my opinion :)

2. the explicit return type. This serves a valuable purpose in my opinion.

With your code, it's easy to break the hd function by changing the implementation to return a different type. You might not even notice the bug if the different type's implementation is close enough to the right one. I once had a bug like this in VB6 years ago: I changed a method to use an integer instead of a string, and VB's automatic type casting happily allowed the rest of my code to function... until in the middle of a demo I ran a function I hadn't tested and default value of 0 broke something expecting an empty string! My lesson: type inference can be dangerous.

It also makes refactoring a large project much more difficult in my opinion because there is no way to distinguish between specification and implementation. Consequently, changing your implementation runs the risk of breaking your specification without being informed.

There is a school of thought that says your unit tests should cover this aspect of the specification... but then all I'm doing is implementing explicit types in a roundabout way - let the compiler do that I say! That being said I don't know if ML/Haskell have 'interface specification' types to ward against this, where you need it (and everywhere else you get to save on verbosity)? That would be a nice improvement to C#: private methods can use extended type inference, anything public (including implementing an interface) need to be more explicit.

3. syntax: visibility (public), static modifier and return statement. This is a matter of personal preference. With Resharper in Visual Studio each of these words costs me 2 or 3 keystrokes, and if I like I can use templated code snippets to reduce that for any situation, so I'm not too bothered :)


I think you're underestimating how much work the type system is doing here: `option` isn't a function. It's part of the return type definition. The whole point of having a type system as strict as ML's or Haskell's is to avoid the sort of problem you had in VB6. Automatic typecasting is a very, very different beast to type inference: in Haskell, your problematic code likely wouldn't have got past the compiler. You're precisely wrong when you say that it's easy to break the hd function by changing the implementation to return a different type. If you do that, your program won't build.


ML's and C# have their strengths and weaknesses, but from a type theory perspective, ML's type system is simply much more powerful when it comes to ensuring correct code than C#'s. Take, for example, your implementation of Head, what if you messed up and wrote:

> return (list.Count == 0) ? null : list[0];

Would the C# compiler catch it or would you not find out until runtime? An ML compiler would tell you that function is wrong.

What about using Head? If you have a list of integers, will the compiler let you do:

> Head(integer_list) + 2

An ML compiler won't, because it's not safe.

> This isn't strictly the same as what you described if "None" is different from "null".

It is, but the important thing to note is I had to specify that the function, 'hd', can return 'null', by wrapping it in the option type. 'null' is only a valid value for option types. If I write:

> val hd : 'a list -> 'a

I could not return 'null'/None, it simply isn't valid. And the compiler wouldn't let me.

> the 'option' function you have in your example

'option' is a type, not a function (I suppose you can make some high level argument that all types are functions over values or something, but not relevant here). And 'option' itself isn't really even a type, it requires a type variable, so "'a option" is a type where "'a" is replaced by a concrete type at some point. It's not doing the work you described above, it's actually defining a contract between me and users of hd and the compiler.

> With your code, it's easy to break the hd function by changing the implementation to return a different type. You might not even notice the bug if the different type's implementation is close enough to the right one.

No, it isn't actually. If I change the return type the compiler will not compile my code.

> I changed a method to use an integer instead of a string

This cannot happen in ML, the compiler won't compile it because an integer isn't a string. What you described is not type inference, it's dynamic typing. The only danger of type inferencing in ML is annoying type errors during compilation. I'm not sure you actually grok what type inferencing is.

> It also makes refactoring a large project much more difficult in my opinion because there is no way to distinguish between specification and implementation. Consequently, changing your implementation runs the risk of breaking your specification without being informed.

Actually, refactoring code in ML tends to be pretty easy. If you change the type of something the compiler won't compile your code, so you know instantly where you messed up and can fix it. You can construct code to make this not work, but in general that isn't the case. See https://ocaml.janestreet.com/?q=node/101

> let the compiler do that I say!

Exactly, and an ML compiler definitely does more of this than the C# compiler. At a cost, of course.

Your post has several statements which suggest you are ignorant of ML and type theory. If you're interested in learning more, check out Benjamin Pierce's book "Types and Programming Languages". Or just spend a weekend with Ocaml or Haskell and prepare for the compiler to frustrate you with it's strictness :)


As far as #4 is concerned, windows is not configurable and the "command line" is an absolute joke, which renders the idea that it has a better developer experience absolute rubbish :) The command line is super powerful and highly convenient in a developers hands.


The lack of configurability is a bug or a feature, depending on your purpose and your disposition. I personally can't stand configuration nightmares. I want things to just work as much as possible, and in my experience linux has a real problem with that. I'm a programmer, not a configuration engineer. I expect the systems I use to understand that.


PowerShell is no joke. Even if you never intend to use Windows again, it's worth taking a look at, there are some interesting ideas in there.

(Overall though, I agree that Linux and Mac give a better developer experience.)


Seeing as how I've been developing for the last 15 years on Windows and haven't found the lack of a *nixy command line to be an issue I'd love to know what you're doing that I'm not :)


Well, the command line basically means you have the power of a full programmming language at your fingertips for administrating your system, your projects, your build system, etc.

Also, the homogeneity of the unix interface (pipes and utilities that uses them) means that you also have very powerful primitives to work with.

Proving the utility of the command line could benefit from a few full featured examples, but this would need a longer post that i'm in the mood of writing right now :)

With that said, you have a powerful administration programming language on windows called powershell. It's much better than bash by a lot of metrics. The way it's integrated into the system is not very good though. For example, the terminal client sucks, and the security system is way too complicated for casual use.


I Spend a lot time in the command line on Windows. Powershell, GnuUtils, and the Windows server resource kit make it much less of a joke than it used to be.


The only way to know if there is a world out there that you're missing is to go explore it. The biggest problem with the .NET world is that the vast majority of .NET developers have spent the vast majority of their time in it.


Same boat, but still wrestling with windows at work. I've got a workable configuration with Cygwin, and mingw32. Hey Visual Studio's IDE (2008) may be full of cruft but the debugger isn't too bad. Vs2010 feels broken, I gave up creating projects in VS, and now use a simple combination of ruby and cmake for creating solutions/projects.

http://www.victusspiritus.com/2011/10/30/an-elegant-ruby-scr...


Thanks for the thoughtful reply. I've absolutely felt your pain. Some of those things have maybe improved (I use git every day, I love my PowerShell, and Visual Studio + ReSharper is glorious once you tell some of the cruft to stay out of your way) but it's still a long way from perfect.


It's amazing how many people either dismiss PowerShell out of hand because it's different, or don't even think about it when talking about Windows commandline support. Getting .NET objects returned, rather than piping text around is awesome. So is having an IDE specifically for writing PowerShell scripts. I'm still learning PowerShell, and love bash, but as powerful as bash is, in some ways it feels very primitive in comparison. If PowerShell 15 years old when bash was released, would anyone consider it better than PowerShell?


Powershell did not exist when I was a C# programmer. Not saying it would have made a difference either way, just that I couldn't have mentioned it.

Anyway, I don't think bash/zsh is so great, rather the tools that have grown around them for the last 20 years make them the best available option. Powershell may be nice, but it's got a long road to hoe.


True.

It has a steep learning curve, as one needs to learn a new set of commands, but once you start getting it, it is great.

I just have two complaints with it: - the stupid ps1 extension; - commands are verbose when comparing with other shells


Agreed that PowerShell really does make command line work on Windows much more pleasant than the old DOS prompt. I just discovered a PowerShell module for working with Git (https://github.com/dahlbyk/posh-git). It shows status info right in your prompt line and does tab completion of git commands and branches.


Crazy. I could have (honestly) written this exact same post, timeline and all.


4) Powershell! Sweet mother of Scripting Gods, Powershell! As a language it's what Bash should have been. Bash is better in some usability senses like tab completion, but Powershell operates with pipelines of .NET objects instead of pipelines of text.


C# programmer for a couple years, and I think C# is OK (it's definitely way ahead of Java or C++) but I've definitely got a big list of things I don't like about it. The top of it reads:

- Events and properties aren't first-class, which is lame. I can't even easily get the "get" or "set" method of a property without either using reflection or making a wrapper lambda.

- No syntax sugar for tuples.

- No syntax sugar for destructuring anything. Come on now.

- The type system has big holes. For example, I still can't specify class Something<T> where T : new(T) (i.e. where a copy constructor exists on T.) And I can't specify class Something<T> where T : /* is a numeric type */.

- It would be nice if there were type inference on more things, like property and field types.

- All reference types are nullable which sucks.


This is a good list. The lack of decent sugar for tuples makes them very annoying to work with and situations demanding two or more dependent return values are the one place where my code looks nasty and is difficult to follow (unless I create a class specifically for the return type, which I usually end up doing).

By numeric type do you mean a type implementing numeric operations? I agree, it's weird they haven't just whacked an interface on that.

And when are we getting an "unless"? It's way more readable than "if (!(some complex condition))".

Oh and null coalescing with member support. "y = x != null ? x.prop : value" is way too verbose.


> The lack of decent sugar for tuples makes them very annoying to work with and situations demanding two or more dependent return values are the one place where my code looks nasty and is difficult to follow (unless I create a class specifically for the return type, which I usually end up doing).

At least you have the option of out params. I have to use Java every day and the only real option is return classes.


I don't know if I misunderstanding you, but you can indeed specify class Something<T> where T : new Check this out: http://msdn.microsoft.com/en-us/library/d5x73970.aspx

And about numerical types, I agree that would be great to have a base class "Number" for double, int, etc. But meanwhile you can use this trick: http://stackoverflow.com/questions/3329576/generic-constrain...


Right now you can only specify that a type must have a paramerterless public constructor. He or she wants to be a le to specify (presumably) arbitrary constructors (or at least a copy constructor).


Most of your issues are addressed by the Base Class Library (BCL), which is provided by the runtime itself. You cannot use C# without the BCL, so why evaluate it without the BCL? How do the following sit with you?

- Events, i.e. the observer pattern, are indeed supported first class by way of the `event` keyword and BCL `Delegate` type. And the whole point of properties is to be syntactic sugar to hide implementation details by surfacing state accessors with field-like mechanics. If you need a quick and easy way to reference a "getter method", you're breaking the abstraction and shouldn't use properties. That's the trade off.

- The BCL provides multiple generic, high-performance `Tuple` types.

- Destructing. Memory management is handled by the GC, so what would destructing even mean? The `using` keyword along with BCL type `IDisposable` provides a very usable mechanism for releasing non-memory/unmanaged/OS resources.

- This is mostly valid. That said, `ICloneable` can get you most of the way w.r.t. the copy ctor. As far as the numeric generic, one is required to make do with type-specificity and method overrides, since the numeric types were written without generics in mind. Or you can implement your own numeric type system. Do that once and you can write numeric generics to your heart's desire.

- How could this work with auto-properties?

- Trivial to implement a `NonNull<T> where T : class`. But because of other language constructs (`??` operator) idiomatically `null` references are not considered the end of the world. Design by contract support in the BCL `Contract` type alleviates this as well.

edit: expanded property method explanation.


He said destructuring, not destructing. Like so:

   int a, b;
   (a, b) = function_returning_array();


Regarding events: It's a common pattern to pass a function into a method as a callback to do an inversion-of-control kind of thing, like "on error, call this." It would be natural to pass an event with the semantics "on error, fire this event." But there is no way to pass an event. You can imagine similar situations with properties.


Your list basically boils down to "C# isn't <insert favorite language>". Which is fair of course, but most of your list wouldn't really make sense in C#.


That's just not true.

All the suggestions on the list make sense, and many like them have been added over teh past few years. To me it seems that all of them except the 'reference types that are not nullable' one could be easily added without breaking backward compatibility.

In fact, I wouldn't be amazed if a C# 6 has sugar for tuples and destructuring assignments and the likes. It matches the language well (already got a type-inferencing compiler, already on the road to incorporating increasingly many functional programming ideas).

And, well, in code you can already say

    var george = new Person();
But in property and field definitions, you still have to say

    Person george = new Person();
How is allowing "var" there a turning "C# into a different language"? Nearly the entire list the GP mentions are fixes on this level of complexity.

The only reason I see for not doing things like this is to avoid becoming the next C++, in which there's just too many features and things to understand.


What you suggest could work, but I'm not sure how useful that would be in the end when you still have to declare the type for fields initialized in the constructor. The var keyword inside methods covers most cases of using variables. A "var" keyword on the field level would cover less than half of the cases. Plus, you'd have to add a new keyword to do it as "variable" doesn't quite fit the meaning. Just not sure how useful that is.

sugared tuples and destructuring doesn't really fit. You'd have to make special case syntax for it and it would just feel bolted on to the language. Plus, tuples lose their usefulness if you have to declare its type to pass it between methods.

Though his first point about getters and setters does make sense, I didn't quite comprehend it the first time around.


You'd have to make special case syntax for it and it would just feel bolted on to the language. Plus, tuples lose their usefulness if you have to declare its type to pass it between methods.

I think it could be OK even without return type inference on methods. Imagine you could type this:

  (int, bool) TryParse(string str) {
     // do stuff
     return (num, success);
  }
That would be clean enough.


I think you might be right about that one. That does look rather elegant. I was initially skeptical about creating a totally new language construct to create inline tuples, as (num, success) looks like it needs a new in front of it, which ruins the pattern of assignment for destructuring.

But once you get over that mental hump of seeing a new in front, it really starts to make a lot of sense. A tuple could be considered a value type and treated similarly to int or string literals. Very cool.


How would you access the return value object? Given obj is (int, bool), obj.Key and obj.Value? Or obj[0] and obj[1]?


Why would sugared destructuring not make sense in C#? Or first class events and delegates?


Destructuring just doesn't fit with the current language syntax. There are no copy constructors in C#, so something like [a, [b, c]] = [1, [2, 3]] makes no sense syntactically. In languages where declaring objects don't require a new, this syntax follows naturally.

For the simple case of say, destructuring a tuple, that could work well: a, b = ReturnsATuple(). But anything more general would just seem tacked onto the language.

But then again, tuples don't really fit well in C# either! Tuples are only useful if you don't have to declare their types, ever. Without full type inference, nothing is saved by using tuples over, say, an inline object.

I don't understand the significance of first class events, so I can't really comment on that. And as far as I know, delegates are first class now with the inclusion of lambdas.


A good list, which can be extended. Just recently, for example, I came across the unpleasant fact that interfaces in C# cannot be nested (in fact, a C# interface is not allowed to define any nested types). Inconvenient, breaks encapsulation, and does not seem to have a good technical reason for it.

And yet, working with C# is joyful.


Did you have a look at Scala?

- There are only properties, no fields or other stuff. This means you can replace a method with a constant easily, or add your own setter to a mutable property later without breaking source or binary compatibility.

- Tuples: (1, "Foo", 42.0)

- val (a,b) = (1,2). Also works with regexes, case classes, ... basically everything which has an `unapply` method.

- class Something[T : Numeric]

- Type inference everywhere, with the exception of method parameters (and recursive methods).

It also has one of the most powerful type systems, traits, everything-is-an-object, higher-order functions, higher-kinded types.

Caveat: Runs on the JVM. The .Net port hasn't been officially released, but is planned for the next release.

There is an introduction for C# developers, if you are interested: http://docs.scala-lang.org/tutorials/scala-for-csharp-progra...


That is easy -- non nullable objects. What I mean by that is that you can already specify that some numbers may be nullable. I would love to be able to specify that some objects cannot be null and have the type-checker verify it.

Even better I would have an option type so that you never need to use null, ever.


They don't really work at the type system level, but Code Contracts (http://msdn.microsoft.com/en-us/devlabs/dd491992), though quite verbose, may be used to achieve that to a certain degree. The integration with Visual Studio is decent and the documentation is great, but they are designed to provide a whole design-by-contract framework which may be an overkill.


That's a good one, I'll keep that in mind. (I'm not just cribbing, I ran into a real world situation that just screamed non-nullable objects).


I remember Anders saying that that was one of his regrets for not implementing this from the beginning. According to him adding this now would break quite a few things, but he hasn't yet given up on the idea.


I agree in large, but there are some rough edges.

-It's wordy. The var keyword was a step in the right direction, but there's still a lot of redundant type information, even compared to other statically typed languages like Go or F#.

-Legacy code. A lot of things that are concise and easy in C# 3.5+ were possible but hideous in older versions. Sadly, that code must still be maintained.

-Null handling. Like another commenter, I wish the language would help more with null values. I'd love an operator to do monadic null coalescing: var foo = thing1.thing2.thing3.bar; Sometimes I want foo to be null if any of the chained objects are null.

It's a pretty good language, though. I'm looking forward to the Roslyn API to the compiler: http://msdn.microsoft.com/en-us/hh500769


Legacy code is a problem in every language. Whether the language evolves, or just the common insights of how to use it best.

In fact, C# deals excellently with legacy code. While, unlike the JVM, .NET is not binary backward compatible (allowing some excellent language improvements that Java still has not managed to pull off), it is nearly (but not entirely) source code backward compatible. Sure, this allows to old code using old constructs to stay alive, but it works. That alone is pretty unique, especially if you see that nearly any other language either does not manage to move its community to the next version with breaking changes (Python 3, PHP 6) or has tons of compatibility issues every time something changes (Ruby, Scala), or simply is at a standstill (Java).

Having to deal with a DictionaryBase child class which was made before generics were added is way less of a deal than not being able to upgrade your software to the newest version of the language at all. Which is what would've happened if this was done like Scala. Or, if it was done like Java, we'd still be hacking DictionaryBase child classes.

I'd maintain that no language/platform deals with legacy code better than C#.


Good point. Having to deal with portions of old code is better than not being able to use new features at all. I've revised my opinion.


FYI, Python has an automated script for migrating code from Python 2.x to Python 3.x


You should tell Django guys they should be thrilled to hear it.


Django already has a branch with support for Python 3.x. The only reason why they're holding off on deprecating older versions is so that users get enough time to upgrade their systems.

A lot of hosting environments like Google AppEngine still do not support Python 3. The "there's going to be no 2.8" PEP might help that, though. We can only hope.


I found it half funny that Python 3.3 reintroduced the unicode string literal for Django. The only way support will come is if user push their providers to get up to speed. It is such a pain that Python has become forked for all practical purposes.


Here's an interesting blog from the Django developers about their plans for python 3: https://www.djangoproject.com/weblog/2012/mar/13/py3k/ The short of it is that they are planning to move for sure and with each release of Django they drop support for one of the 2.x releases of python. Django 1.5 (the next major version) will experimentally support python 3.


I was being facetious - my point is 2to3 has been around since py3 was released and Django was python 2.x only for years, along with many other libraries, implying that porting is a bit more involved than applying a script :)


I don't understand the points about Scala here. Scala has pretty much the same strategy as C#.

In fact, the "big breakage" in Scala everyone loves to cite was the addition of better collections. Just like C# did in 2.0 and now finally drops the old non-generic ones with WinRT/Metro.

The reason it gets so much flack is that Java developers want _binary compatibility_, because that's what they are accustomed to and Scala gets often used by Java developers. Java developers would target the same criticism towards C# if it would run on the JVM.


Hm, hm. I guess you're right. Or, at least, I can't find any proof that you're not, so you get my benefit of the doubt :-)

I take the part on Scala back.


No problem. :-) If you have any questions, just ask.


Null handling

You can do a fair amount of relatively frictionless null handling with extension methods. If that helps.


var foo = thing1 ?? thing2 ?? thing3 ?? bar;

This will work.


"thing1 ?? thing2 ?? thing3 ?? bar" will return the value of the first non-null variable in the list. zmj wants something like Ruby's andand [1] instead.

andand negates the need for an explicit null check on each property in a property lookup chain, which would normally be required to avoid a potential NoMethodError or NullReferenceException.

You can create something similar [2] to andand in C# if you are willing to do property lookups using lambda expressions.

[1] http://andand.rubyforge.org/

[2] http://stackoverflow.com/a/4958550


Yep. To me C# feels like the standout all-round language. It's not super-elegant, but it's modern and brings together a lot of useful features without messing up much. I especially like the stuff that was added in v3.0.

On design alone, I would probably vote Clojure. The features and their rationale are very compelling.


<i>I honestly can't think of anything off the top of my head.</i>

Limited support in the open source ecosystem? Open source projects are reluctant to build on something that might infringe on an MS patent. That's what keeps me away from the language. To be fair, this is more an indictment of the patent system than C# itself.


I was thinking more along the lines of the language itself. Complaints about the (lack of) open source ecosystem are more than valid. That's something I dearly miss in the .Net world.


If I wasn't using Google Chrome's web developer tools I'd probably consider JavaScript to be a nightmarish corpse of a language that punishes the slightest of typos with a silent malicious grin... Only by the grace of tools is JS tame at all

+100000. We can thank the Webkit Tools team (including folks from both Apple and Google) for making the web platform environment as pleasant as it is. Kudos!


> We can thank the Webkit Tools team (including folks from both Apple and Google)

webkit originally comes from the KDE project and was known as KHTML (with its KJS companion).. they basically showed the world that a decent HTML renderer can be written in nice-API-C++-code (Qt-style-nice-API) and with limited resources.

how long did Mozilla take to make Netscapes ancient codebase usable? it took forever!

and chrome+safari+android+iOS >= 40% of the browser market. wow.

anyway, lets also thank the KDE project that booted it. :)


Have you worked with Firebug before? Webkit tools is a carbon copy. It is smoother of course, in the same way Chrome is more polished han Firefox.


You're talking to Yehuda Katz here. Yes, he has worked with Firebug.


How these two compare to Dragonfly[1] (Opera). I never worked in depth with any of them so they look pretty same to me. Only difference I know is probably remote debugging which Opera had for years but there was no need for it in firebug/chrome dev so I wouldn't count it as an extra feature.

1. http://www.opera.com/dragonfly/features/ / https://bitbucket.org/scope/dragonfly-stp-1


Writing C# code in Visual Studio feels almost like telepathy. Intellisense is so good that, it nearly writes 30-40% of total code.


I couldn't agree more. In fact, that is my single biggest problem with being a C# developer. Sounds counter-intuitive, right?

Each time I dive into another language, I feel handcuffed because I don't have the features and options that I get from Visual Studio. Once the "new language smell" has worn off, I find myself wishing for faster ways to develop sections of code. I miss instant code compilation and validation. The ability to hop around sections of code, immediately find all references, or catch compile errors at a glance are all things I take for granted until they aren't there. And don't even get me started on ReSharper. Those guys at JetBrains are glorified drug dealers and I am one very hooked addict.

All that said, it makes it very difficult for other languages to gain traction with me. At times, the software adventurer in me gets frustrated about this, but the pragmatic side of my personality (the one that likes food and a house) prevents me from giving up all those benefits.


Amen, I almost totally jumped ship when MVC was a 'new' thing, if they hadn't brought out ASP.Net MVC when they did I would have left.

The only thing I hate about C# is the 'magic' they keep trying introducing to the frameworks. ASP.Net was bloody awful but if you haven't checked out MVC 4, this is truly WTF were you thinking MS:

http://www.asp.net/web-api/overview/getting-started-with-asp...

GetAllProducts magically maps to api/products/

GetProductById magically maps to api/products/{id].

Fucking retards, just give me the tools, not the magic. It's so focused on incompetent idiots. It's even worse than the stupid and almost but not quite utterly useless user membership crap they infect your code and database with. That's what's pushing me away from C# more than anything else, the random magic that will suddenly kill your application.


I'm guessing you're being downvoted because you're calling people retards because of what you perceive to be a poor design, when in reality they've done exactly what you've said, you just don't realise it. Which makes your "incompetent idiots" remark rather ironic and gave me a good chuckle. For the competent, or consciously incompetent:

1. ASP.NET MVC implements customizable routing, like pretty much every other modern web MVC framework these days. The routing library can actually be used in old school ASP.NET Web Forms applications or your own raw ASP.NET application, if you like; it is not ASP.NET MVC specific.

2. The default route in the code generated as part of the "ASP.NET MVC Web Application" template project in Visual Studio maps routes as follows: /{controller}/{action method}/{id parameter}. There's nothing stopping you from (a) changing this in the generated source code (Global.asax.cs) or (b) generating an EMPTY default web application without the code at all and zero routes pre-defined.


I found the magic just got in my way when I first got into ASP.NET MVC. I needed to use Firebird with Entity Framework but I didn't want to use that horrible feature which connects to the database and maps it automatically for you using a GUI. Mapping my model to the database is just something I'd rather do manually, and eventually I figured out how to do it and it's awesome.

I don't use membership so it doesn't infect my db.


YES. THANK YOU.


Sorry, wait - how is this different than the RoR magic. Where you can do stuff like MyObject.findByArbitraryProperty and it just works? That's PFM if you ask me. Django, RoR, and Node all have lots of magic bits. You don't have to use any of the magic, which also goes for MVC.

(I do agree with you though - just because other frameworks have magic bits doesn't mean I like it in MVC. I would also prefer it not be there. I just don't think you can really pick on MS in this case.)


It doesn't fit the language and the environment.

ASP.NET MVC is way too much of a RoR clone than is good for them. C# programmers aren't used to magic: they're used to compilers telling them about typos. Convention over configuration is nice, but it's essentially the concept of dynamic typing translated to frameworks. It fits badly in a statically typed language.

I'd have much preferred ASP.NET MVC to have less magic and, for instance, decent, controllable, IDE-supported and compiler-guarded routing.

Example: in an action method, parameter names are mapped to URL parameters. This is horrible, I should be able to change the parameter name in any method without calling code being affected. Or, when this is not the case (e.g. when C# 4's named arguments feature is used in calling code), I want a compiler error saying that calling code can't find the parameter anymore.

In ASP.NET MVC, I get neither of those things. I might have as well gone Ruby all the way, then.

In short, it's brittle.

Compiled languages have pros and cons, but if you're compiling anyway, please use all the pros to the max. APS.NET MVC doesn't, and that's a shame.

It's still a nice enough framework, but it screams "missed opportunity", much like all those Java libraries that were ported over to C# back when .NET was new.


Binding between a request and a controller method is entirely customisable. The framework uses a completely customisable number of parameter sources (query string parameters, POST parameters, session variables, you can customise this to e.g. query LDAP if you want) and binds those to the parameters of your method in a completely customisable way. See, for example http://odetocode.com/blogs/scott/archive/2009/04/27/6-tips-f... .

That being said there is definitely a deficiency in strong typing in ASP.NET MVC as-is. That's why I use T4MVC (http://mvccontrib.codeplex.com/wikipage?title=T4MVC_doc&...). I'm not too sure how the MVC team have done things much differently, though, without overcomplicating the framework... you'll note the T4MVC approach is based on code generation that inspects your source tree.


Wow, cool stuff!

I think code generation from inspecting source trees really is the future for compiled languages.

I used to think that the only reason to generate code (instead of using reflection or interpreting some DSL) was speed. I missed how code generation gives you excellent additional features, such as more compile-time safety and, most importantly, excellent IDE support. Once my code is generated, I can talk to it from other code like it was a hand-written library including all the IDE goodness (API discovery through autocompletion, etc) that it comes with.

I really hope they'll keep making T4 even more awesome than it already is. Combined with Roslyn, I think we'll get some pretty cool tools ahead that we can't even fathom now.


.NET magic is generally limiting things down so that happy path works and edge cases are expensive. Other platforms do a much better job of this because they start on an edge and make that run through happy path by convention. I can't speak to it being language limitations or just the way Microsoft works, but they almost always seem to get this part wrong.

See ASP.NET MVC Routing as a example (kinda related to the above).


If code can be written by auto completion, it's by definition redundant and IMHO shouldn't be necessary in the first place.


No, it's more like the IDE is augmenting your brain and fingers. The code comes out readable, but you only have to type a fraction of the characters. It's a code-writing assistant robot.

Also, it makes APIs incredibly discoverable. Not sure what a `IQueryable` provides?

    IQueryable iq = null; iq.
and scroll through the popup. Instant one-line descriptions are available in the tooltips, and you can get full documentation with F1. you've ever experienced this, it's REALLY hard to go back to Emacs. It's incredibly well done.

(edit: formatting)


Agree on the discovery part, this is the biggest reason why I stay away from vim.


http://www.vim.org/scripts/script.php?script_id=1520


That doesn't sound all that good to me. My steps to finding what IQueryable provides:

* Cmd+Tab to Chrome

* Cmd+L for location focus

* \IQueryable searches DuckDuckGo for IQueryable and takes me to first result

I get to use the editor I want (hint, not visual studio), and I know a lot more about IQueryable anyway and can continue poking around in the docs to learn more about the 'nearby' bits of the API.

I don't really want my editor to write code for me after only a fraction of the characters. I like writing code. I agree with Inufu, I feel like completion of more than, say, IQu[tab] is starting to show redundancy I'd prefer not to have in the first place.


"Here's how to instantly find documentation on something."

"That doesn't sound all that good to me. Here's how I do it in multiple steps, in a different window!"

Do you see the problem here?


Yea, I really don't. What's wrong with different windows? I prefer to read documentation in a tool that is good for reading documentation (don't understand the IQueryable crap? Just jump over to StackOverflow in a couple keystrokes).

The description I was replying to had you hovering over little thingies for tooltips. The whole time you're writing code little popups and widgets are flying all over the place. That is distracting. Give me an environment that edits text please.


Stockholm syndrome.

Try Visual Studio for a month. At first you'll be like "get out of my way stupid intellisense popup" and then you'll be like "holy crap that just saved me 60 seconds... for the 60th time today." And then you go home early and use that free time to have sex with your wife.

Point being, it'll change your life for the better.


I was forced to use Visual Studio in school, I hated it throughout and took every chance I could get to use Python or Ruby or something else with a unix-y stack.

Trying it again now would be pretty far out of my way just to reaffirm what I already know, since of course I've long since left Windows entirely.


Visual studio has changed a lot since 2008. VS2010 is actually surprisingly good. Personally I prefer it over any other IDE I've ever used, such as eclipse.

As you said, since you don't use windows, there's no point in you using it. But let me just say that it certainly sucked at one point, but it is now one of Microsoft's best products, IMO. They've definitely done a LOT of work to improve it.


Most of the time you don't even need the documentation, as methods are named well enough that they describe their behavior. This is simply much faster than opening another window and doing a google search. The times you do need the docs, a hotkey will open a full window for it.

I'm with you on the crap flying around on every other keypress though. Feels like I'm programming with an extreme case of ADD.


No, I don't. He's using different tools for different jobs, which is the way it should be. Not an integrated mess of a thousand and one things that should be stand-alone programs with intercommunication ability.

Those who don't understand UNIX are forever doomed to re-implement it - poorly. Which is the story of every IDE ever.


As if the goal or intention were to approach UNIX's philosophy. UNIX is practically by definition decoupled. Integrated Development Environments are by definition integrated.

I spent years hating Java and embracing vim, but as I tried to shape my environment more, I grew increasingly frustrated. Finally, I was forced by necessity to use Eclipse and Maven with Java, and the lightbulb turned on for me.

Any language that takes 30-40% less code to do something for you is taking away some freedom. They're making convention easy but can make escaping it to be hard, or may slow down because of more dynamic-ness, or some other tradeoff. And there are many good tradeoffs to be had when creating programming languages, of course.

The deal with Java is that it is the pedant of languages. Half-answers and hand-waving to how objects interact (i.e. duck-typing) aren't good enough for it. This makes libraries or APIs very, very easy to reason about, because if it doesn't access to that information then that means that the library or API is broken or intentionally hiding those details from you. But on the other hand, it enforces a kind of light, but still present, agreement between classes on their relationships to each other.

The point at which your thoughts on IDE come into this is that because Java has a very rigid structure, it can make sweeping code changes at massive scale. This is something that, with shallower insight into the language, or without insight into the flow of code through a method (i.e. checking for dead code or invalid assignments), and so on, would take a massive number of man-hours to duplicate, or make use of the exact same code the IDEs themselves have written for the purpose (i.e. emacs and vim are capable of delegating certain functions to eclipse). Decoupling it in the UNIX way doesn't really make a whole lot of sense when everything is very interrelated in nature.

As well as generate, but given that some people think that if code can be generated, it should be done at runtime by the language instead, I don't want to argue this too hard in this reply. They're not wrong but they sure aren't right.


That is not true. Autocompletion is a decision with user override enabled. It is, at the very least, a visible decision. That does not imply that it is totally automatable.


What about sensible defaults? If the libraries you use are designed with reasonable defaults that have already anticipated your needs there should not be any need for anything but the most basic syntactic autocomplete functionality (closing brackets for example) because any code at that point is customization for your specific project which is not easily generalized (otherwise it would be a default in the library).


Just hide the default behaviour and make the overrides optional.


If you haven't already, you owe it to yourself to try ReSharper. The automated refactoring and static analysis tools are best described as "pair programming with a genius robot".


I felt like I was more of a configuration engineer than software developer when I was working in VS. If I got stuck I would just start typing and then hit ctrl+space and scroll through intellisense to get the options that seemed to fit.


I get that feeling with all modern software engineering. Intellisense and similar environments at least try to make it bearable.

How I long for the day of starting your project with only a blank document.


I guess that's why I gravitate towards JavaScript, still kinda the Wild West where we can still write things from scratch.


if your IDE writes 30-40% of code for you it just means your language needs at least 30-40% more code than it should to cleanly describe the algorihtm. (not dissing C# here, just all IDE-aised languages)


If my IDE writes 40% of my code it means i can call my functions ConnectToDatabaseCheckUserNameAndCountPosts() instead of ConDBusrCnt() just to save a few taps on the keyboard.


Though arguably that should be three different functions:

  ConnectToDatabase()
  CheckUserName()
  CountPosts()


Obviously that's not taken from any real code but just the most obscure function name that still makes sense that i could make up in my head while writing the reply.

...But even after splitting it into three functions you would still save 60% of your keystrokes by using auto completion ;)

  Con()ENTERChec()ENTERCou()ENTER


Which doesn't mean that you can get GetCellLocatuonById into Get CellLocation ById


Sorry for the formatting, the reply box on Android is malfunctioning.


Vim doesn't write any code for me yet I can still have long function names because of the cutting edge magic of auto-completion.


Autocompletion is writing code for you. That's what we're talking about here, in large part.


Touche.


ConnectToDatabaseCheckUserNameAndCountPosts() should be 3 functions, not one.


not entirely true. some languages are very-IDE-aidable but verbose (java and c# come to mind), some are not very IDE-aidable but less verbose (ruby and python come to mind, various LISP variants also fit here I guess).

but that is not hard rule as, for instance, haskell is potentially-very-IDE-aidable AND less verbose.

now only the haskell IDEs need to mature :) but this is a mater of time.


Yes, but with Ruby or Python 60% of that code wouldn't even need to be written.


I almost never log into HN (read it daily), but I felt compelled to put up a vote for C# because it makes me feel like I have super powers. As a solo developer, I get a lot of firepower from the MS stack, and C# is like the icing on the cake. There, I said it.


I hate to hijack this comment, but this topic really highlights an issue with the HN comments. It is now virtually impossible to have any broader discussion since this thread filled the page. A topic that is massively more broad than discussion about C#.


I've only been here a few years, but how and why is this new?

If you're implying that it has to do with the lack of visible scores, I'd point out that I think that the comments are still ordered by score, even if they aren't necessarily displayed.

If it's just because of the sheer number of comments attached to the C# specific parent, I can't remember a time when a really popular comment didn't take up a larger share of space as more comments logically take up more space.

I mean, there was the pre-pagination era, where you could just keep scrolling down, but that was also the era of HN crashing all too frequently.


With "now", polshaw is referring to "this moment in the life of this thread", not "this moment in the life of HN" - so it's not about how HN has gotten worse, just that big threads like the C# one can push other meaningful parts of the discussion way down. It's not because it's always been that way that it's ideal.


Fair point, I suppose. I guess I was just thinking to myself, as I read that, that this is easily the least of HN's problems.

I suppose it IS a fair point though, especially considering that C# is (by my quick once over) only the fourth most popular language, and easily represents the most popular discussion on the topic.

Also, looking through the additional pages, it seems as though there aren't many other comments that even have children, much less anywhere close to the same discussion space.


Eh, C# is good for the environment it lives in, but it's not without it's cruft.

C#'s answer for all of its missing features seems to be a generic class. Don't have tuples? We'll give you Tuple<T>. Don't have inline functions? We'll give you Func<T>. It feels very tacked on (especially Func).


Func<T> is just the type signature they use for lambdas. The syntax allows fully inline functions now:

() => { DoSomething(); }

No return value needed (compiles down to an Action<T> I think)


> No return value needed (compiles down to an Action<T> I think)

Which is an other crufty thing in C#: because Void/() is not a type (inherited from Java), it needs to have both `Func<Tn..., T>` and `Action<Tn...>` in order to handle functions-with-a-return-value and functions-without-a-return-value.


This is true, but its mostly transparent unless you're doing something particularly ugly.


Like trying to take one of these as parameter or return it?


This is a statically typed language mind you. If you're passing something around as values, you're gonna need to declare what its type is (of course there's type inference, but that just turns it into a totally different language)


> If you're passing something around as values, you're gonna need to declare what its type is

I fail to see the relation this has with my issue.


You should need to know whether you require the lambda you're accepting to return some value or not, and its type.


You completely missed the point I was making. Try reading these comments again.


Can't recursively call a lambda function, no thanks.


There are two ways of recursively calling lambda functions, neither perfect, but both usable.

  Func<int,int> fib = null;
  fib = n => n > 1 ? fib(n - 1) + fib(n - 2) : n;
Or write yourself a Y fixed-point combinator, described in http://blogs.msdn.com/b/wesdyer/archive/2007/02/02/anonymous...

  delegate Func<A,R> Recursive<A,R>(Recursive<A,R> r);
  static Func<A, R> Y<A, R>(Func<Func<A, R>, Func<A, R>> f) {
    Recursive<A, R> rec = r => a => f(r(r))(a);
    return rec(rec);
  }
used like this:

  Func<int,int> fib = Y<int,int>(f => n => n > 1 ? f(n - 1) + f(n - 2) : n);
(I'm not advocating writing a fib function this way, but it's a useful example!)


https://blogs.msdn.com/b/wesdyer/archive/2007/02/02/anonymou...


I also feel like "Funcs" are a work around. What I like the most about C# is the fact that it keeps evolving and incorporating new paradigms (closures, lambdas, LINQ, etc)


Try F# then, tuples, records, pattern matching, etc. It's essentially OCaml.net


Have used F# quite a bit. It's nice, the nicest ML I've used, but it has some cruft as well. It feels like 2 languages, really, the nice functional ML language, and then the C#-with-F#-syntax object oriented side. I wish they wouldn't have bothered with the latter.


Actually the OO side is quite similar to OO in OCaml, so I miss your C# remark there.

For a language to be first class in .NET it needs to be able to do OO with the same semantics that the CLR has, otherwise you will have leaky abstractions all over the place.


Yeah, C# tuples are a pretty glaring hack in an otherwise great, evolving language.


Like other C# features and behaviors, I expect that, down the line, the language will pick up syntactic sugar to make the creation and usage of those tuples more straightforward (see delegates -> anonymous functions -> lambdas).


Yeah and F# is the breeding ground for C# features


Func<T> are part of expression trees.

They are intended to manipulate the abstract syntax tree of lambda expressions. A bit like macros.

You should only need to know about them if doing AST manipulations.


I have to agree with this. If only ruby or python had such a powerful development environment (sigh). There's simply nothing in the open source community that rivals the beautiful, simple power of that IDE and language combination. Tools matter when you're trying to ship code.


The beauty of Ruby and Python is that you aren't restricted to an IDE in order to use them; I wouldn't enjoy using them if I was. I like to choose my own tools. This isn't quite so easy when using an all-encompassing (and platform specific) IDE like Visual Studio.

I use tmux (with tmuxinator), with windows for my editor, shell, debugger, source control, logs. I'm able to, effortlessly, change any part of it.


I'm not sure what this means. Are you saying it is impossible to write C# code without the IDE? If so, my .vimrc would like to have a few words with you.


You can write code in vim, yes. Do you debug it there too? Didn't think so. You use a separate debugging tool (or clewn, if you're a masochist). And a separate source control client (possibly wrapped in a vim plugin like fugitive). And a shell.

Effectively you (like me) have probably put together your own set of tools that perform the functions of a IDE.


I used the Vim/Ruby combo for a long time but RubyMine pushed me from Vim to an IDE again (they aren't always bad).


To be fair, having just had a good look at RubyMine, it looks very good.


Pycharm is as powerful as Visual Studio IMHO. I love both of these IDE's.


Agreed, a good IDE goes a long way to make up for the sins of the language.


The new await/async in C# 5 is beautiful. Just try/catch around an await and suddenly async is easy to read and handle errors.


Closure compiler is also very useful for making JS a bit more safe and fast

https://developers.google.com/closure/compiler/


Is it still a good choice if you don't intend to deploy to Windows?


Probably not, eventhough there is Mono.


> How do you convert to a string? Convert.ToString().

Actually, I think this is a bad example because oop is inadequate in this particular case. Converting something to something else perfectly fit the functional paradigm (take an argument, returns something, don't store anything). Why do you need a Convert object? How would you explain this to someone not familiar with C#.

I think Console.WriteLine("hello"); is a better example.


This makes me so happy to read. Honestly i love writing in c#. I spend a lot of my life now using php, but honestly the times when i followed best practices the best (unit tests all over the place, often test first approach) was when i was coding in c#. I think the language just lends itself, and the IDE...to doing things right.


I just wish Microsoft would improve AOT compilation with NGen, or even better, provide native compilation as they do in Singularity with Bartok.


I don't think anyone will be pulling out C# marketing videos from their archives any time soon. Like AT&T archives' the unix operating system http://news.ycombinator.com/item?id=3749496

It will be interesting to see what happens with C# if Microsoft succeeds with Windows 8 on the desktop, tablet, and phone.


If only C# has Maven (that supports both Mono and .NET) and a solid cross-platform libraries, I'd leave everything behind.


What about Npanday(1)? Don't use it myself but the devs at work use it.

1. http://incubator.apache.org/npanday/


NuGet seems to help a bit, but granted it is not Maven.


It's funny. Every time I use a new language, or go back to an old favourite, it becomes my favorite language for a time. Static typing? Wonderful error messages! Dynamic typing? It does what I want! Functional programming? This is the future of programming! Object-oriented programming? I can describe the world! Low level? My code is fast. High level? My code is *expressive.

Is this normal or is it just me? Don't you come to like, or love, a new language? Every time I do something different I realize how good things could be. But this is just a case of "the grass is greener on the other side" I guess.

I ended up voting for Perl as it feels the most fun language. But ask me again in a month and you might get a different answer.


I feel likewise (except for the Perl part. I have the most fun working with PLT-Racket tools).

I believe this happens because language design involves a lot of trade-offs, so every language incorporates these trade-offs.

When one is comfortable in many kinds of languages, one is in a special position to see the trade-offs in the design of the language one is currently programming it.

The way I see it is slightly different then the way you describe. Say I'm programming in Prolog, for instance. In the beginning, I'll be like "Wow, such expressiveness". But inevitably I'll do something that is outside the scope of Prolog and it will be as slow as hell. That's when I think to myself: "if I could just fix this little part... I miss C". So when I'm back programming in C I'll think "now my code is fast", but then inevitably: "if I could just find a way to do this without so much repetition".

In the end, it comes down as a "right tool for the job" thing. One possible ideal would be do the things Prolog is good at in Prolog, the things C is good at in C (and also throw in some Python, Erlang, Lisp, etc). Except most of the time this is infeasible. Working with FFIs suck. Sometimes there are no FFIs, sometimes there are many incompatible ones, and the dream of calling any language from any language is just further and further apart. And don't get me started on the pain that it is to have multiple runtimes with slightly different semantics...

Even if it were possible, a developer would have to learn all these little languages enough to be working on them comfortably, and we all know this is not going to happen. So hardly anybody does this, as hiring someone for a polyglot project is a complete nightmare.


Tradeoffs are a sign of a false dilemma; rather than choosing one solution or another, use them all where they work best. This is where Unix got it right all those years ago; Unix isn't just a slightly more stable platform for running today's bloated and monolithic software, rather, it's an elegant system for connecting maintainably-small utilities. The shell glues said utilities together into programs. Such an approach combines the best of high and low level programming, reuse and specificity, tradition and novelty, etc.

I know shell isn't going to with this popularity contest, but a return to it is what's badly needed in CS today. Instead of attempting to recreate the shell in C# or Java's supplied libraries and subsequently becoming frustrated when interaction with the "outside world" is clumsily accomplished through an FFI pinhole, just use the shell as it was intended: as a lingua franca between utilities.

Write what requires prolog in prolog, what requires c in c, what requires awk in awk, etc. Use flat file databases such as starbase or /rdb and avoid data prisons such as MSSQL, Oracle, MySQL, etc. Make all of these utilities return sane return values and spit out JSON formatted output. Finally, tie it all together with shell. If you need a UI, code it as a thin layer in TCL/TK, python/pytk, ansi c/gtk, or, consider pdcurses, etc. Profile your program and find any weak links in the chain. Recode in a lower level language only when needed.

Programming doesn't have to be hard. As in speech, the more one says, the less one means.


In some ways, I think REST interfaces exchanging JSON are the modern equivalent. Doesn't matter what the underlying programming languages are, everything can talk to everything else through a simple (well, not as simple as pipes), broadly understood, and widely implemented interface.

The Web, of course, has been recognized as the cause of the recent proliferation of and resurgence of programming languages. As long as you speak HTTP, it doesn't matter that you're a dog.


You make a very good point.

And I think it is no coincidence that the creator of Unix is one of the designers of Go, a language that shares Unix's conceptual and implementation simplicity, makes very conscious tradeoffs and where channels work somewhat akin to pipes.

Of course interfacing with the rest of the world has become much harder thanks to XML, SOAP, XMPP and every other such monster, but as somebody else pointed out, the modern equivalent seems to be REST+JSON, I would have preferred something like 9P, but oh well, one has to pick their battles.


That's the right attitude. Each popular language has its strengths and shortcomings. As long as you enjoy it and get the job done, it's a good language. What I can't stand are people dissing other languages to make their language look good. It's like they have to justify their insecure choice of their language by bringing down the others.

As for Perl, I used to hate Perl for its many arcane ways of doing the same thing, but I then forced myself to do some Perl scripts at a job and it's not too bad. It got the jobs done. Since then I've used Perl for many quick scripts.


It's exactly the same that happens with me, and i guess with most of the people. Besides, whenever i am programming in a new language, it happens that I gradually come to know more tricks, hacks and lower level details about the language which makes me like it even more. And, then it becomes my favorite language. And, then I can argue with someone over it. And then one day, I start writing hello_world in a new language, or one of the languages which i had not touched for many years and it becomes my favorite language. And then, i think how foolish it was of me! Btw, i voted for C because nothing is more beautiful than it IMHO; you can do whatever you want so elegantly that it mesmerizes me.


I'm the same way, though I feel like this flies in the face of reason. Switching to a less familiar language usually implies more headaches and less productivity, but the novelty makes it more enjoyable. Another example of how programming is oddly emotional.


Nothing odd about it, IMHO. One of the things I think tech-oriented people consistently ignore is the role of emotion and the subconscious in decision making, even in what are nominally objective disciplines. Our conclusions may be based on reason, but then where do our hypotheses and inspirations come from?


Totally agree. More accurate phrasing would have been "another reminder of how..."

Book recommendation: Thinking Fast and Slow by Dan Kahneman. Great overview of how those factors affect decision making.


Nice, I'm going to check that out :)


... oh... that's just magic. i will intellectually dine on that for a week!


Writing good Perl is definitely a blast. Make sure to read Modern Perl.


No, I think you hit the nail head on. I almost often do quick little things in Perl out of laziness (even though Ruby would be so much prettier), but I also like Pascal/Delphi for static typing and relative speed. C is about as close to assembler as I'd care to come.

But this "Java" thing keeps paying the bills for most of the last decade. I guess it doesn't do everything wrong. (as much as I'd like closures & function pointers, tuples or even working destructors sometimes, I get by with Java)


I agree with this sentiment, and I voted for D because of what it is meant to be. They want it to support any paradigm, with any abstraction layer, and be useful in almost any context. I like that kind of freedom. Especially in a native compiled language.

No, it is not there yet. The hope it that it one day will be. Because that would be amazing. It is already about as easy to write as Java, and usually beats it in performance.


I feel the same way, my problem is it usually starts while I'm learning a new language, so I might drop the current to pick up another, which I of course drop again etc. pp... I'm learning Haskell atm which seems to be the first language that captures my interest even after months. (the announcement of Julia made me think of dropping it, though)


This voting scheme is known as "single-vote-plurality". And it's a giant suckfest. Beyond two candidates, it completely falls apart, and tends to suggest very different results than the actual preferences of the voters.

Hypothetical example. Let's say that 1/4 of HN likes C, then Lisp, then Python, then Java. 1/4 of HN likes Python, then Lisp, then C, then Java. 1/5 likes Lisp, then C, then Python, then Java. And 3/10 like Java, then Lisp, then Python, then C.

So we have:

1. Java has the highest number of votes, even though 7/10 of HN thinks it's the worst language. Java wins!

2. Lisp has the fewest number of votes, even though it's the only language to appear in the top two preferences of 100% of the voters. Lisp loses!

In other words, the results from your voting scheme suggested the opposite of what people really liked (and disliked). This is a known, and very common, pathology of single-vote-plurality and becomes more and more of a problem the more candidates enter the race (and you have a gazillion of them).

Since you can't have people easily express their rank ordered preferences on HN (eliminating Condorcet, IRV, and the like), the next best thing would be to do approval voting. To do approval voting, you'd change the wording in your posting to:

"What languages do you like? Vote for as many as you want."

Then the winner is then the language with the most votes.


I agree with the flawed voting scheme. What I don't understand is why the number one voted comment thread is on how great C# is when I can't last remember an article on HN talking about C#. This whole thread seems so contradictory to my perceptions of the HN community. Either there's a whole host of C# lovers that finally decided to participate in todays discussion (a silent majority), or microsoft evangelists are taking over HN! I'm so confused.


I don't think anything sneaky is going on. I don't code in C# because the MS stack doesn't really make sense for what I'm doing, but it's a good language with a fantastic IDE.

Put another way, there are a fair number of HN articles about PHP but I don't think that's because it's an inherently great language.


Um, what? Maybe I haven't been paying attention, but I haven't noticed any PHP articles around here on any kind of regular basis.


Spot on. Though I’m not sure that instant-runoff voting would be as infeasible as you suggest.


Here are the languages ranked by likes/dislikes ratio (I compared the above poll with the "dislike" poll: http://news.ycombinator.com/item?id=3748961). For example, for each person who downvoted Clojure, there were 28.8 who upvoted it. This ranking is fairer to languages that are well liked by those who use them, but not as well known:

  Clojure        28.8
  Python         26.5
  Haskell        19.7
  C              17.3
  Lua            16.4
  Lisp           11.5
  Erlang          9.9
  Ruby            8.4
  Scheme          8.1
  C#              7.9
  OCaml           7.3
  Smalltalk       7.1
  Scala           6.4
  D               4.4
  CoffeeScript    3.6
  JavaScript      3.5
  Forth           3.2
  Groovy          2.9
  Assembly        2.5
  Ada             1.7
  Objective C     1.6
  Perl            1.6
  SQL             1.4
  Pascal          1.3
  Rexx            1.3
  Delphi          1.2
  C++             1.0
  Tcl             0.9
  Fortran         0.7
  PHP             0.7
  Shell           0.7
  Java            0.6
  Actionscript    0.6
  ColdFusion      0.4
  Cobol           0.1
  Visual Basic    0.1


Not everybody can downvote. That adds significant noise to this data.


I used the term "downvote" figuratively -- I don't mean literal downvotes on this poll (I don't think anyone can downvote a poll option anyway, and even if you could I wouldn't be able to isolate upvotes from downvotes since we just see the combined number); I mean votes for "least favorite language" in the other poll.


I really like go. It's very succinct, clean and orthogonal, yet is enormously powerful. The amazing compilation speed and concurrency primitives are the icing on the cake.

I especially like the lack of a type hierarchy. I have come to think that type hierarchical structures are somewhat brittle - you create these initially correct representations, however when something changes or isn't quite right suddenly you either have to rewrite your hierarchy which is potentially a lot of work, or hack it up whereby it ends up not only incorrect but also misleading.

In go, you get implicit, dynamic interfaces whereby you define an interface and get duck typing against it without having to explicitly indicate that types implement it. The capabilities of a type determine its abstraction, nothing more.


I find it difficult to divorce 'favourite language' from 'favourite stack'.

I use C# a lot, and I love it. But it's tied into MS's heavy stack for web stuff (ASP.NET, etc.) so recently I've switched to using node.js and CoffeeScript in my projects. It's fantastic. So right now my favourite language is JavaScript/CoffeeScript, but just because of the things I can do with it.


I agree.

I'm not especially fond of the Haxe language, but it's Good Enough that I'm happy using it day to day.

However, its ability to export to so many different targets (C++, Javascript [+ Node.js], Java in beta I believe, Flash SWF, AS3, Tamarin, PHP etc) is a real killer feature.

Would that count towards this poll or not?


Which targets are you using?

Wouldn't be awkward to use Haxe for a project that employed language specific APIs? It seems like the sweet spot would be using it to write basic libraries that had no external dependencies.


C++, Flash, and Tamarin and Neko experimentally.

Platform specific APIs are awkward, which is why it's mainly used for writing games. NekoNME abstracts most of that away. I'm not so sure how easily it does node.js.

But the standard runtime for Haxe has been ported to the other languages in a fairly bulletproof way.


So the end result is being able to make games that run in the browser and on the desktop from the same source code?

Any other reason why someone might want to use it?


I love the Python ecosystem but I prefer Coffeescript as a language. Guess I'll upvote both.


> just because of the things I can do with it

I am hard pressed to find a better reason to like a language or stack.


Well, I was thinking that it's possible to like a language in a very pure, abstract way- C# is a great example of that. Lambdas, LINQ, anonymous functions... it's a slick, slick language. If I'm looking at language alone, it's probably my favourite.

But I can't do anywhere near as much with it.


I love Haskells purity -- simply because it is so audacious and so different from everything else. I love Lisps and how it made meta programming first class even though I will never be in a position to use it in my day to day work.


But it's tied into MS's heavy stack for web stuff (ASP.NET, etc.)

For what it's worth, ASP.NET MVC is much, much less heavy than the original ASP.NET (if that's what you're referring to). This is especially the case if you use the Razor syntax for your views.


Being a little offtopic, but I have a personal pet peeve with ASP.NET MVC ... since they bothered to release it as open-source, why are they keeping Razor as a binary blob? Shit, why are they keeping ASP.NET itself as closed source?

This is something that always bothered me about Microsoft-related stuff. Right now I'm using Python and Django for web development. I'm also using Ruby on Rails for a side project. Having access to the source code is vital for me as I've become accustomed to reading a lot of source code. And reading source-code for lack of better documentation is sweet, but then I went further and for instance I also copy/pasted a lot of snippets straight from Django's source code, or worked-around bugs by patching components.

That's why I consider open-source to be superior, regardless of all the polish that Microsoft is able to apply to their products. I'm a software developer, not your average user. Just as a sports-car racer would find unacceptable the lack of access to the internals of her own car, I find unacceptable the lack of source-code that I can read, modify and distribute.


While Microsoft could be more open source friendly, in the enterprise world I work on, I would consider Microsoft one of the good guys when compared with some of the other companies.


That hasn't been a problem for me personally, but I see where you're coming from.

For pure debugging purposes, have you tried using a decompiler? For reasonably well-written (and not obfuscated, naturally) code, the decompiler output is remarkably clear.


> For what it's worth, ASP.NET MVC is much, much less heavy than the original ASP.NET

And thats if you even use that... I use 2 open source libraries to build web apps - Nancy & Simple.Data - and they are both f'in amazing. This is about as "light" as you can be. I have a prezi presentation on my blog about using these libraries to build web apps for a few talks I gave at code conf's. (thinkdevcode.com)


Love seeing shout-outs to Simple.Data- I know the author. Great guy, awesome library.


Cool. Thanks for sharing. I'll absolutely check those out.


Oh, I know, and it is much better. But the whole stack is still heavy- compare setting up an ASP.NET MVC site and IIS to node.js's "http.createServer()". There's no comparison.


You should try NancyFx (https://github.com/NancyFx/Nancy) some time. Its a light weight web framework. Simple and beautiful.


NancyFx is pretty cool. I'm not thrilled with Mono's performance as a server app, however (and I wouldn't bother with a Windows server). I should note, though, that the GC seems a little questionable, though 2.11.0 apparently has made SGen production-ready so I need to look at that again.


What the fuck is a stack?


Given the audience on HN, it's not surprising to see Python and Ruby disproportionally upvoted. (For the record: 145 for Python, 114 for Ruby at the moment, next highest is C at 53). Coffeescript is also significantly overrepresented. It's currently on 34, beating C++ (29), and in the same region as C# and Java.

What I am surprised at however is that C# and Java (37 and 35) are doing as well in this poll as they are. It seems that Java in particular is disliked here for it's heavy reliance on classes, classes everywhere, while C# is more approved of, but still disliked. Partially for the same reasons, but also for how Windows-centric it effectively is.

I guess it shows that HN isn't as seperate from a typical subset from programmers as it appears from just reading articles that are upvoted, and reading comments.

Personally, my favourite is Python, but between college and Android development, I've mostly been writing Java for the last few months. While I find that Android makes it less painful than applications using other big Java APIs (Swing for example), I'd still rather be writing Python.

I also wonder how different the results of this poll would be from a similar poll asking "What language do you write in a daily basis?". I'd imagine Haskell and Coffeescript as the biggest losers in such a comparison, while I'd imagine that PHP would have the biggest gain.


C#, the language, is not windows centric. The framework released by microsoft might be, but the language itself is decoupled from windows.


Looks like 'Go' is missing, 'Lisp' should probably be 'Common Lisp' since Scheme and Clojure are also 'Lisp'.


I would have voted for Go. Agree, should be on the list.


Agreed, same here. Go gets my love these days!


Same here, golang is my day to day language of choice now. The very large project I've just started I've selected Go! for.


Same here.

Also obligatory #golang so people can search for it on the page! (Had to sift through every "x hours a<go> to find this thread.)


I see a lot of votes for python, but a disproportionately small representation of python fans in the comments.

If you asked me a year ago, I'dve said python. But lately, I've been using Clojure for personal projects, and it's making python seem just... boring. (I get the same feeling when I write in Ruby too)

The "one right way" paradigm is a great one, and the language is solid. The built-ins are top-notch, and while not exactly a functional language, it's certainly expressive enough. In my mind, it's probably the ideal general-purpose language. But lately, I feel like I use it for everything because it's "good enough" for everything -- without being "great" at anything.

Point? I don't think I had one, sorry. I just thought I'd share that notion to see if it resonated.


If you don't mind my asking, as a Python person, how did you learn Clojure?

I'm mostly programming in Python and JavaScript today, and I want to learn Clojure, but I keep seeing these very strange talks. I don't know how to articulate it, really. My best metaphor is, it feels a little like I wanted to go out and learn about Catholicism and they said, "oh, that's easy, we'll just have you sit in on a bunch of confessions and you'll figure it out in no time." People explain why they made certain language decisions and I (as yet) lack any of the background needed to know what the hell they're going on about.


I also switched from Python to Clojure. After picking up the syntax (there is almost none) I spent a few weeks reading the source of Ring by Mark McGranaghan [1] and constantly referring to ClojureDocs [2]. (My goal was to port Ring to Python [3], but after I did I realized I now knew Clojure and could just use Ring.)

[1] Ring: https://github.com/mmcgrana/ring

[2] ClojureDocs: http://clojuredocs.org

[3] Pump: http://adeel.github.com/pump


4clojure.com was very helpful for me, as was this: http://jkkramer.wordpress.com/2011/03/29/clojure-python-side...


Thanks! I don't know how to pay you back, but I shall try to pay it forward.


No worries, glad I could help.

I think another thing that gave me a boost was when, for whatever reason, I decided that I should avoid for loops when writing day-to-day python. I started using list comprehensions, and then map, filter and reduce, and functools.partial, whenever possible. I had tried to approach lisps before, but I found it easier after those became habitual.


if you just wanna get a feel for clojure without getting too serious - here's a demo of livecoding in overtone - http://vimeo.com/22798433

overtone comes with a stock emacs config that will get you livecoding in no time.

after that, Joy of Clojure by Fogus. (edit: fwiw i have had no trouble with this book even as my first lisp, but i've been coding in a functional style for about 6 months before clojure)


I find Practical Clojure and Clojure in Action easier for beginners. The Joy of Clojure is a little advanced suitable if you already know Lisp. All 3 are good books.


A good start: http://java.ociweb.com/mark/clojure/article.html

Clojure force you to think and program in functional manner, where in Python you can skip FP. Thus learning Clojure IMHO will improve how you program in general. I am learning Clojure now for this purpose and I might not use it for real work.


If you just want to get a feel for Catholicism without getting too serious, you should leaf through 'In the Beginning'

http://books.google.com/books?id=a47neDIBaSkC&printsec=f...

It starts assuming virtually no background in the faith and it really gets you into the nuts and bolts quickly.


> I see a lot of votes for python, but a disproportionately small representation of python fans in the comments.

This is probably because describing the virtues of Python (clean & simple syntax, one right way to do everything, easy-to-use yet comprehensive standard library) just feels like beating a dead horse. Almost everybody in this community has heard of Python. The circle-jerk factor on HN is still somewhat low when it comes to this topic.

I currently use Python personally and professionally, and I love having it as my go-to language. However, I'll be happy to add some more languages to my repertoire in the future.


I was not expecting Python to be getting near as many votes as Ruby.

It is my favorite language simply because the pseudocode I write on whiteboards is basically Python. Strangely, it has been since well before I really started using it regularly.


Python is rapidly replacing ruby as the de facto scripting language for automation. It's also starting to replace Java as the language of choice for teaching programming and CS.


Python has been the de facto scripting language of choice for automation in a number of industries for quite some time.

I don't believe (but correct me if I'm wrong) that Ruby has ever gained much traction outside of the software development world. Perhaps we're just seeing some natural consolidation.


Ruby is the language that Puppet and Chef (the 2 most popular configuration management systems) are based on.


The roles Puppet and Chef fill are small parts of "automation".


Puppet is written in Ruby, but has it's own DSL, so it doesn't really count.


I never knew ruby was ever considered the "de facto language for automation". Maybe you are thinking of perl?


I was commenting on the popularity of Python in absolute terms, not necessarily in the context of a relationship with Ruby.


No, he's thinking of Ruby. Puppet and chef.


What is the Python equivalent to Puppet and chef?


The only modern and novel alternative is http://saltstack.org


Fabric comes to mind.


Fabric is more of a task-oriented SSH replacement with some really nice bells and whistles, much different from Puppet or Chef. Some folks are working on Salt Stack which is python-based and more akin to the others.


Fabric is more like Cap than Puppet / Chef


bcfg2 I have been using it for a few years now. Have enjoyed it much more than the other similar tools we evaluated: puppet, chef and cfengine


bcfg2 I have been using it for a few years now. Have enjoyed it much more than the other similar tools we evaluated: puppet/chef/cfengine


With tools such as?


There are those who think that if a programming language is only usable with bloated tools, the programming language might be flawed.


That's interesting. It was exactly what I was thinking while reading the C# thread at the beginning of this article's comments. Yes, yes, mono whatever, but really ...


I'm not sure what point you're trying to make here. Are you claiming I'm wrong or do you want me to do a google search for you?


A google search may not be as insightful as someone talking about a trend in popularity for a specific niche (automation.) I think the poster was just asking you to share specifics that helped form your opinion.


I find that I'm rather productive in python for scientific computing and go towards C (or occasionally even fortran) when I need something faster. I also find that it has a rather shallow learning curve for students who come in knowing java...

But generally, I think it's good to pick the right language for the right domain. I keep trying to find an excuse to learn Erlang ;>


  > ...go towards C (or occasionally even fortran) when I 
  > need something faster
Try cython next time.


Or PyPy.


Since he's specifically saying that he does scientific computing, PyPy is not a good suggestion. Pretty much all of the codebases of the stack for scientific computing can not be used in PyPy, and this will most likely not change in the foreseeable future since porting them is non-trivial.

I'm not trying to talk down PyPy here, but for this domain of application, it's not appropriate at the moment.


I'm not quite ready to cast my vote for Python, but this statement is so true. Basically all of my notes from planning stages as well as algorithms I'm looking at or working on... might as well already be in the interpreter.


Python seems to have higher penetration outside career programmers. When I learned Ruby about a decade ago, there was this "Ruby shouldn't be your first language" sentiment. I think there's been progress on that front, but Python had an early lead.


Some language generate a lot more noise then others--the noise is not at all correlated to actual usage or popularity.


I chose Smalltalk, not because its a language I get to use every day, or have even used a lot, but it has influenced two of the languages I'm most productive in, and from it has sprung foundational technologies which nearly all developers (especially those who program VM targeted languages) have been able to take advantage of.

It was one of the first languages I used which really introduced me to a completely different way of problem solving and thinking about the structure of a program. I know that language was probably Lisp/Scheme for a lot of people, but for me it was Smalltalk. Implementing control structures without language keywords!? Operators implemented using the same message passing techniques as any other method call!? Querying any instance for its implementation and documentation at runtime!?


The number of C# votes makes me very happy. When I originally signed up oh.. 1333 days ago it felt like I was the only .Net dev on the site. It was a huge deal for me to find other startups built on .Net back then. Now I discover them far more often. I think Microsoft must be doing something right. I blame Scott Gu.


Yeah, isn't it great that more people are backing a proprietary, closed source, Windows-centric technology?

(As a pre-emptive strike, Mono does not make .NET any more "open". If Mono was maintained and supported by the same people that design the language/APIs I might change my tune.)


That's a pretty substantial downside to C# for sure but it doesn't stop it from being a fantastic language. I can only imagine how popular it would be if MS supported non-Windows VMs (technically the CLR) directly.


Well C# is a great language, that runs very well everywhere (thanks to mono). I wouldn't ever dream of using ASP.NET but C# as a language is pretty nice.


Asp.net MVC is fine. Webforms is a crime.


> As a pre-emptive strike, Mono does not make .NET any more "open". If Mono was maintained and supported by the same people that design the language/APIs I might change my tune.

If Microsoft controlled both major implementations of C# and .Net, you'd consider that more open? Maybe you should think about that a little bit more.


Mono is open source. If it were the official (reference) implementation, of course I'd consider .NET more of an open platform.


That doesn't sound more open to me. Is Java more open than C++? Java's official implementation is open source, but it's controlled by Oracle. C++ doesn't even (to my knowledge) have an official implementation, yet it has numerous practical implementations, some of which are open source.


The programming language described by standard ECMA-334 is, like most any other ECMA standard, non-proprietary, open for anyone to use, and not particularly tied to any one platform.

There is of course a particular implementation of that language which is proprietary, closed source, and tied to a particular platform. However, this is not a particularly unique feature of the language. The same is also true of ECMA-262, ISO-1539, ISO-9899, ISO-10279, and many others.

For its part, Mono is supported by the same people that design the Mono branch of the language/APIs. This is a quite robust fork of the platform, which includes a great many useful APIs which are specific to that version, and forms the foundation of popular tools such as the Unity game development framework.


The parent comment specifically mentioned more people using .NET. I don't have a problem with C# as a language.


Yes, it does.


Hacker News is all about Python/Ruby/Clojure/Scala/Haskell most of the time, but then we find that there is this huge group of very happy Windows/C# developers that are passionate about their environments. Where are you the rest of the time? What have you people been building?


Standard ML!

Of course, I do research on Manticore (parallel dialect of Standard ML) and am one of the primary developers left on the SML/NJ implementation. So I'm a bit biased.

But trying to be objective, the module system is absolutely amazing. It's a simple / small set of syntax with a formalized semantics that is powerful enough to do almost everything you want to do with generics, classes, macros, and other module systems.


Bless you! Standard ML is the closest thing we have to a perfect language, in my opinion. My only wish would be a solution to the non-extensible overloading issue, but to fix it without also fixing the formal semantics around it feels like throwing the baby out with the bathwater, and is why I haven't gotten into Felix or Mythryl.

I mostly use Haskell myself. I find myself missing the laziness and purity when I use Standard ML, but I think the biggest obstacle for me is the shortage of libraries. I'm happy to use a language without a community, but compared to Haskell it feels a bit like a ghost town. Such a shame, it really is fantastic and would have been the perfect tool for building huge systems on.


Thanks!

Yes, the overloading issue requires changes to both the parsing rules and some fairly tricky formal semantics changes as well. I've talked with Dave MacQueen about it in the past, and it didn't sound like something he was terribly averse to, just that it would take a long time to really get _right_. And then it places a burden on the SML implementations, though at this point that's really SML/NJ, MLton, and possibly Poly/ML (though I don't know that team very well yet).

Unfortunately, the SML implementor community largely either moved on to other research projects after the implementation-y papers had been mined or left to work in finance (interestingly, it seems to be about 50/50, with the exception of a Googler or two). We don't really have anybody in research labs to do the kind of amazing full-time implementation, support, evangelism, and publication work that the Simons do so fabulously for Haskell!

That said, as a researcher, having many more SML users would require us (particularly Manticore) to Get Real in ways that are not on the path to publication. And considering I'm already only going to have 7-ish publications when I graduate, I see a probable future locked behind the doors of Big Finance for myself as well...


Which finance companies are using ML languages?


Apart from the obvious Jane Street example, quite a few. F# is used pretty widely at this point in the Chicago area. Many of the larger banks either have their own private dialect of ML or a strict, ML-like subset of Haskell (Standard Chartered).

But for most it's not their primary language; those roles are usually still filled by C on the server and some GUI-friendly language for the trader apps. It's mainly used less latency-sensitive work that is more financial modeling in nature.

Sorry for being vague with names; other than Jane Street and Standard Chartered, most of them will only talk about it confidentiality. Many take secrecy to the point of lunacy.


I selected Forth, but Postscript was a lot funner. I have always wanted to sit down and create a cross between the two. Perl for short scripts (just because of CPAN and always have Perl installed) and Objective-C is my main application language.

I gotta admit I miss Occam but it is over 20 years since I did any programming in it. I am currently researching agent based languages as I still have some Telescript documentation and have always been fascinated by the concept.


I answered Objective-C only because I'm considering the entire ecosystem around a language in addition to the actual language (its features, idioms, and syntax).

Objective-C isn't a particularly pretty language, in my opinion - but when XCode's powerful code completion, decent visual debugger, and awesome static analysis come into play, it's a lot more attractive.

Plus, for me, programming is about the goal, with the journey an oft-pleasant and very engrossing side effect. Objective-C hits the sweet spot where the language and toolchain gets out of my way and lets me build beautiful, functional software that people actually use.


In my consulting work, I seem to have benefitted greatly from a shortage of people still versed in old-school systems work, heavy C, Perl, and solid knowledge of the esoteric feature sets of traditional RDBMs. There is a decreasing number of people in the market who really know their way around Linux and other Unices as well, and who can bring some historical insight to bear.

I am not a bearded hacker. I'm only 26, but it seems that everyone in my age group has moved onto fashionable web programming tool chains, Ruby, etc. Personally, that's just as well; leaves me with less competition. :-)


Most of my "for fun" coding lately has been in Arduino's C/C++ language subset - which, given it's lack of many of the standard libraries usually assumed available when people talk about C or C++, I tend to not think of it as "C programming". In fact the resource-limited nature of Arduino programming feels much closer to assembly than anything else.

(Perl is still my "favourite" of all the languages I get paid to write…)


Mathematica. But not because of the language - it has some warts. But because of the problems I'm working on when I choose Mathematica as a tool.


What kind of problems. Could you elaborate a bit please?


Nice try Stephen.


What makes me really happy is when I'm working on something new. Particularly science. Some sort of new kind of science.


FYI, canned reddit-esque responses don't go over too well here.


Perhaps a better question is “what is your most favored language?”. My favorite language is F# but my most favored language is C#. It’s like how a dog might favor a particular limb until the other fully heals.


I voted for Python, but I would have voted for F# if it had been in the list. A good mix of strong language design (the ML pieces, plus some of the bits like workflows) and pragmatic utility (all those .Net libraries and such).

I code mostly in C# for employment reasons, but I do personal code in F# or Python, depending on what kind of tools I need access to.


Same post from 6 hours ago. http://news.ycombinator.com/item?id=3745084


My favorites:

- Ruby for an imperative scripting language

- Go for an imperative systems language (previously C)

- Clojure as a functional language


Although most Rails devs code Ruby in a strikingly imperative way, those of us who did Ruby long before Rails tend to code it in a functional way.


Go Team Ruby! But on a serious note, I wonder how many of those are < 2 years (I am) and were influenced by the Ruby community, a lot of which seemed to have hung around on HN for the same period of time.


I picked Python and Assembly. There was a day when C++ would have gotten the pick but not today. As for my reasons.

Python, simple enough to explain why. I get to quickly make and test a program with a language that is well documented, comes with a tutorial that in my opinion was just as good at getting me into programming with Python as any other books I've found out there, and the growing libraries for AI based fields is very nice. Lately (doing the NLP class, and was using SimpleCV/OpenCV for another project.) I've grown to love it even more then before.

As for why Assembly was my second runner up? One very simple, but hopefully thought provoking reason. Assembly Language was the absolute most simple yet complicated programming language I had ever dealt with, it taught me more about how and why computers do the things they do then anything else I learned about computers. (since I keep people's computers going as a living, it was extraordinarily helpful in making me a pro at fixing them.)


IMHO, Python is probably one of the best languages in general. But I consider Perl, its opposite in many ways, one of my favourites.

In Perl I can be witty and find my personal style. Sadly enough, my code poetry might not be somebody else's. Reading other people's Perl code can be hard.

On the other end of the spectrum, Python feels aesthetically dull to me sometimes. But it's a great language to program in with larger groups of people, even when they have different skill levels and coding styles.

In the end, these languages are all just tools; you can do a hammer's job with a screwdriver, but really all tools have their purpose in the right context.

(Go's missing, though.)


Moonscript (voted for Coffeescript and Lua). It's like Coffeescript for Lua instead of JavaScript, which is great of you need a fast and concise language to embed in another application (compiling the standard lua interpreter for a platform consists mostly of dragging the source to your IDE and compiling). ( http://moonscript.org/ )

I also love OCaml (and miss it's static inferred typing and pattern matching everywhere else), but it's ecosystem has never fit with what I'm working on outside of coursework in it.


It's really a shame that Groovy is not even in this list. It's understandable as it is very poorly marketed, but it is really a shame that it is not mentioned more, especially on such a forum. For entrepreneurs, it has so many advantages. As productive as Ruby and Python, and yet running on performant Java runtime. Plus, being a derivative of the Java language, it makes it so easy to find experimented developers. It's my personal favorite, and I really think all entrepreneurs with a Java background should give it a try.


Yeah, Groovy really is an awesome all round language. Nearly all the benefits of Java, Python & Ruby rolled into one. And so easily embeddable into any Java app, you can use it just where you need it or everywhere. It benchmarks substantially faster than Python and Ruby for the things I do, and it's really easy to optimize by just dropping into Java for anything that is a bottleneck which is far better than dropping to C and losing the all the benefits of living in a VM.


And don't forget groovy++ to easily achieve java like performance.


LISP and Scheme still have one killer feature all other languages don't have: extremely powerful macros.

http://www.apl.jhu.edu/~hall/Lisp-Notes/Macros.html

This article gives a good insight what about LISP is so awesome:

http://www.defmacro.org/ramblings/lisp.html

I also vote for Ada because this is the best language I know to write maximum quality software. I would love to make money for living by coding Ada for Embedded Systems.


I finally created an account because of this :) Python FTW!


How sad - down-voted to oblivion on your first comment.

Quick tip to get the appropriate tone right. Don't post anything that sounds like a typical Reddit comment.


maybe some day I will finally become reddit user :D


So brave!

(Don't worry, I have a ton of karma to burn here)


Good choice. Welcome :)


nice to become a legal part of this awesome community :)


Perl, especially when parsing and manipulating text files. Still the best glue language between applications that don't like each other, such as when the output from one is incompatible with the input of the other (of course, vendor of second app promised it would be compatible). The only downside after perl saves the day is that it makes whoever decided to buy that application look far less bad than they deserve.


For me, there is a huge difference between programming languages I like, and what I can build with them. Clojure is my favourite, followed by Io. Both languages have a clean, minimalist aesthetic, are rediculesly powerful, and very expressive.

When it comes to getting stuff done, Javascript is an interesting language, and there are some things about it I like a lot, but there are many things in it where a) there is syntax for things that make no sense (like the ~ operator), b) the syntax for something common and important is horribly clunky (like function, or assigning to a prototype), c) the syntax having odd rules that almost seem like little traps (like the way that () will call the previous line as a function, or how you need a trailing comma on everything in an object literal except for the last thing). All that being said, I love what I can do with it. And I really find that CSS/JS/Semantic HTML has some of the nicest seperation of concerns of any UI programming toolkit I have looked at. So when it comes to what I can build (and get paid to build), I would say my favorite language is javascript.


Voted C, C++ & Haskell, but other languages are also nice. C is pleasant for its simplicity and straightforwardness. C++ is huge and complex, and I’ve never believed in OOP, but I know of no better language for generic programming. Haskell, on the other hand, is rather small and pretty. It doesn’t get in your way, it informs your writing in other languages, and its type system makes the angels weep.


Here is a plot of the votes (updated hourly):

* http://koldfront.dk/misc/hn/wyfpl/data.png


Did you keep track of the changes? I see relative changes in votes every time I check. It would be really cool to see how things went. You could also infer a geographical distribution of voters, as this poll goes through time zones :)


I have always maintained that if you have an unqualified "favourite" thing, you are probably not very in to that type of thing :)

I use C the most because it is the most appropriate tool for the job at hand for most of the jobs I do. I appreciate the simplicity and elegance of Scheme, and wish I could use it more. I envy Haskell's type system.

None are my favourite. After all, all programming languages suck.


Awe, that's the spirit!


I voted Ocaml because it is what I'd call my favourite language: of all the language I have actually used, it is by far the one I enjoyed the most, and the one that made me most productive.

However, Ocaml is not the end of it. I know of Haskell, and I sometimes resent Ocaml's value restriction, or lack of laziness. I know of Lisp, and I sometimes resent the complexity of Camlp4.

However, Haskell and Lisp are not the end of it. See, http://vpri.org/html/work/ifnct.htm and http://www.vpri.org/pdf/tr2011004_steps11.pdf showed that with the right tools, a few hundreds lines of code is sufficient to make a TCP stack, or a Cairo-like graphic system, or even a whole programming language stack that's more powerful than Lisp itself. When I see that, I know that I think Lisp, Haskell, Forth… are already obsolete. The market just doesn't know it yet.

However, COLAS and OMeta and Maru are probably not the end of it…


I primarily use c# but I dont know if it is my favorite because that is what I get paid to write code in or if its because I know C#, Objective-C, VB, SQL, and a bit of C++.

Of those languages, C# feels the most feature rich and easy to read, while I find working with the Cocoa framework and Objective-C particularly enjoyable. The others I work with but find no particular enjoyment from.


I chose Java, but hackers shouldn't have a language that is their "favorite". They should use all languages and pick that one that is best for the job. I realize this may be an unrealistic task, but I try my best to do it. While I probably the best at coding Java(Quickest, and get the most done in it), I don't always use it because its not the best language for the job.


> They should use all languages and pick that one that is best for the job.

That's certainly a correct answer, but it's correct because it's almost tautological. 'The language that I like the most is the one that's best [for what I want to do]'. The issue is that, in this question, 'favorite' is a bit vague, and the task isn't specified. (This is why I have a problem choosing 'favorites'.)

Despite that, in this situation, I interpret it to mean 'What [general-purpose] language has the best design?' Theoretically, a perfectly-designed language would be designed in such a way that it has an absolute advantage over all other languages for every type of task.

Given that definition, it follows naturally that I would choose Lisp - it's actually not my strongest language, but even a novice Lisper can see that Lisp is both as minimal as possible and yet as powerful as possible . Since it's a shapeshifter of sorts, it can adapt itself perfectly to any setting.

The drawbacks with Lisp (in my view) have nothing to do with the design of the language itself, but rather the environment. The libraries of languages like Perl and Python are much larger, by sheer fact that the community is larger. Lisp is cross-platform, but the installation (quicklisp aside) is still messier than Ruby's gem-based packaging or Python's eggs. And lastly, because most people don't learn functional programming as their first step, it's got a learning curve.

But none of those are problems with the language itself - at least not the design of the language. (I'm assuming here that we're dealing with high-level languages - it wouldn't really make sense to compare x86 assembly to Python - if you're writing assembly, you probably have a very good reason, and Python isn't even on the table).

So in the end, your answer to this all determines on how you interpret the question, so it's fun to see what the results are... just don't try and compare them directly - I think anybody who interpreted the question the way I did would probably choose Lisp, but it's clear from the comments that many other people interpret this a different way.

(Thankfully HN is good at avoiding flamewars, but I'm sure everyone here has seen enough useless 'debate' of this same topic on other forums to understand why I mention it!)


As someone who is just starting to learn to code, this is an interesting list, but I can't help but want more info. The "why" each language is preferred is missing. Obviously some of this is in the comments, but summarizing that text will take quite some time. I can't help but think additional related questions might provide greater context to each preference.


Coding in Ruby all day using Sublime Text 2 has been totally awesome for a little while now.

Debugging is not as slick as in Visual Studio-land but... that's what test coverage is for! (and it's super easy to do...)

Here, I wrote a class today which subclassed Delegator (https://gist.github.com/2305169) that will let you return a value from a function that looks like a typical single scalar value but actually has "hidden" attributes riding along with it. Smoke and mirrors :) This is the first time I used this class or the Delegate pattern for that matter. (I came at programming from a Psych major.)

Notice the test inline with the class definition itself at the bottom that is only run when the file itself is run (not when it's merely included by another file). A simple Command-B (for Build) in Sublime Text 2 and I get the tests passing in a split second and know I didn't break anything.


I would love to hear from the people who voted for Rexx explain what they are doing with Rexx - I am really curious.

A few years ago when working for a bank in Germany I had to learn Rexx but only for some extremely unsophisticated stuff - so I am asking: What are you doing with Rexx and what makes it your favorite programming language?


Does anyone here feel that all of these programming languages have their own flaws? I started programming 8 years ago (mostly as a hobby), and I feel like all these languages are missing something. That said, my "favourite" language is Haskell, but I don't really like it. I've only used Haskell since a year ago and there are still many concepts I have to master. Maybe my feelings will improve, but if they do it won't be by that much in absolute terms.

Emacs and Vim? Twenty years later and these are still the state of the art? Even when our computers are at least 1000 times more performant? I guess there are IDE's out there trying to do better, but in the end I'm still typing text into a computer, occasionally getting autocompletes that is exactly what I want, but usually its not.

Do I like programming? Yes I do, I like programming more than I hate the tools I have to use.


I am interesting in knowing at what time exactly would people think they have experienced enough language exposure to decide on the favorite one. Like, my favorite now is C, because thats the one I know best, and I cant say that this wont change, since I am learning Ruby and it rocks.


I voted for Clojure because so many of design decisions seem to be correct, but there's still plenty to complain about: unreadable stack traces. slow interpreter startup. meaningless function names in core.

I think I really want an immutable-data language that uses rubyish message-passing style.


My favorite language is not listed , it is LiveCode from http://www.runrev.com, it is an HyperCard on steroids. I am very productive with it and it is terribly fun to use. Besides that I like Lisp/Scheme =)


Awk, C, Go, rc, Scheme.

Simple and conceptually-consistent languages that my simple mind can fully understand.


I kind of wanted to vote for groovy. It's pretty much what you get if Java and Ruby had a baby and is a pleasant language to work with. Truthfully though, I like a lot of the languages on that list so it's hard to pick just one as a favorite.


No Groovy? Seriously?!?? C'mon, man...

Anyway, put me down for "Groovy" at the moment, although it could potentially be knocked off that perch at some point. I have some other languages I'm interested in exploring but haven't gotten deeply into yet.


C# is great, it is even better with the vs.net, I found it is easier to express what I want to do in c# syntax. ASP.net is fine too, you can choose not to use the server control approach which I think is the bad part of asp.net


I'd be interested in hearing why anyone would choose Tcl.

I have to use it during the day, but use Ruby on my side-project. Tcl and it's lists (and lists-of-lists) is wicked painful - especially compared to my Ruby experience at this point.


My choice would be Go.


The beauty of Java is that is not ONLY a language, it´s three things:

1. A runtime environment 2. A software ecosystem 3. A language.

:)

So you can use 1. and 2. without having to write a line of Java if you don´t like it. There´s plenty of languages that run on top of the Java virtual machine: JRuby, xRuby, Jython, NetRexx...

Even Lisp and Cobol if you want.

http://en.wikipedia.org/wiki/List_of_JVM_languages

There´s a yearly summit about new languages ported to the JVM... http://openjdk.java.net/projects/mlvm/jvmlangsummit/


I do like Go a lot. It's not on the list yet.


The one I'm developing, duh.


These days, I'd have to say Smalltalk is my favorite. I think more modern languages are still catching up. Modern open source implementations like Squeak and Pharo make Smalltalk very accessible.


I like Python because I'm an inexperienced and infrequent programmer. While I took a few courses on programming (VB, Java), it wasn't til I discovered Python that I would actually code in my own time. All the boilerplate crap I had to deal with for Java was wiped away, and I could just write. I'm sure if I wrote more complex things, I could find better languages, but for simply getting things done and just jumping in and writing a few lines, Python just feels right.

Does that sound about right to those of you with more experience?


Give Ruby a try. You will be pleasantly surprised. I was.


The real beauty of Python is the fact that it is easy for beginning programmers, yes, but it has also a lot to offer for experienced coders concerning all the advanced things they might need.

It's no accident that services like Dropbox[1] or YouTube[2], both arguably very complex systems, are relying on Python as their language of choice.

[1] http://blip.tv/pycon-us-videos-2009-2010-2011/pycon-2011-how...

[2] https://www.youtube.com/watch?v=G-lGCC4KKok


None. I like Lisp but it has its problem. I don't like Java but it is useful and it has good tools and a ton of libraries. I like C, but it needs better libraries and it can be a little cumbersome to write. I don't like C++, but there are cases where one of its features are useful.

I hate PHP but it is easy to write a quick backend in which can be deployed everywhere. I hate Javascript, but it is hard to beat it in the browser.

I summary I don't have a favorite language, they all kinda suck and kinda don't. It all depends on what I need to use them for.


Sounds like you would like clojure.


No. I tried it but it fails in two ways:

1) all the libraries are it takes advantage of are written in Java and this doesn't fit the closure style of coding at all.

2) the available tools just suck. Sorry, but without autocompletion the time it takes to write something balloons way, way too high.

I guess 2 would have been less of an issue 20 years ago -- back then most of the IDEs that we use today did exist -- but it is not 20 years ago. It is now.


Totally agree with you on 1). I found Clojure uses Java libraries even for the most basic stuff, and that forced you into unLisp like code. That is acceptable for Java folk, but when you want to stay closer to Lisp, that's a problem.


There are many impressive Lisp dialects which aren't mentioned here like Mark Tarver's Shen programming language and John Stutts Kernel programming language, so I am just going to vote for Lisp which hopefully covers most of these dialects. I have been a Lisper for over a year.

I am not particularly impressed with most things which aren't Lisp based or which aren't at least functional. In particular, I am not impressed by Python. Admittedly, I am biased towards functional languages like Lisp because I am a mathematician.


The first thing I always check out when looking at a programming language is the debugger. Smalltalk's debugger is the most useful and fun because of the dynamism of the system as a whole.


Those days I feel (unless you write backends for Google or embedded sw) that "Python is all you need" (unfortunately - I wish I could work with more languages with equal productivity).


C still remains my favorite programming language. Though compared to modern languages it has fallen way behind, still nothing beats the simplicity of C.

With less theory to learn compared to other languages, the power of C lies in the implementation only. Just few simple ayntaxes combined with terrific logic can make some really powerful applications.

Also, maybe little bit nostalgic here, but it feels good to return to C every now and then just to make some highly logical program and challenge the logical side of my brain.


I love Ruby, but ultimately Python is my favorite.

Ruby is consistent and cool, but I can do everything I want with Python and I can make it FAST as hell.

Over the past week I've been moving some things into Cython and it has literally sped 200 times faster than Python which is 10 times faster than Ruby, and with a lot less memory overhead. Speed _does_ matter when the two languages are nearly the same in terms of development speed. Furthermore Python has more libraries and less wtf moments when looking at peoples code.


Perl becuase it does what I want.

Haskell because it makes me do what I ought to do.


Python for when I'm "thinking in code", or doing data analysis that's not too performance sensitive (NumPy). I probably enjoy Python the most.

Ruby for when I'm doing configuration management or occasional webdev.

Fortran for when I'm doing serious computation, C for when I'm trying to do something fast that isn't number-crunching. (Though I'm trying to learn Go for that.)

And a smattering of other languages (Perl, shell, Java, etc) for interacting with tools that speak those better than anything else.


I was under the impression that Python/Ruby were pretty much interchangeable. In what situations do you chose one over the other?


Well... they're both popular, dynamic, object-oriented programming languages with a clean syntax. But that doesn't make them interchangeable. ;-)

In general I find that Python is the easiest language for me to "think in", syntax-wise. It is almost pseudo-code in its simplicity, and I like that it has extremely powerful namespaces. It also seems to me that it's easier to write programs in Python which ignore object orientation in favor of a more functional style, than it is in Ruby. I'm slowly falling out of love with OOP, and Ruby loves its objects.

I also really like Python's libraries for numerical and scientific work. For whatever reason, Python took off in the scientific community, and it's got libraries like NumPy and SciPy which I haven't seen duplicated in Ruby. It's also easy to integrate with existing Fortran and C libraries... and if you've done much work with Fortran, you know that it might be blazing fast but it's not the most pleasant thing to work in. Much nicer to glue it together with Python. :-)

Where Ruby shines for me is in its libraries for server configuration and web development. I like Python's webdev libraries, but I still find it easier to work with Rails or Sinatra than with Django or Bottle. I also think that Chef is one of the best things ever for managing servers in a programmatic fashion, and for that you need Ruby.


The number of votes for Objective-C is really funny to me, because I've never talked with a fellow objc developer that would describe it as their favorite language. Apples platform may be their favorite platform to develop for, but I and everyone else begrudgingly uses objc to target it.

Granted, they have been adding some very useful features to the language over the past couple years that I rely heavily on, but I'd never go so far as to call it my favorite.


I like the message sending syntax of objective-c. At first it was so weird, but now I almost hate looking at anything else.

After awhile, I think most people even begin to appreciate it's verbosity. You can make it read like english pretty well.

Of course, I'm sure I wouldn't like Objective-C without Cocoa or I wouldn't like writing it on Windows.

I've never been able to get round the whole whitespace thing in Python and Ruby. I really like brackets and they've always been the strongest thing to signal where code starts and ends.


A minor correction: Ruby is not as whitespace dependent as Python. Ruby uses "end" to end blocks, not changed indentation. Whitespace matters though in other ways, for example newlines and in some places if there is a space or not.


I'm curious as to why D doesn't get more love. It's had a pretty rocky liftoff, but there's a lot to like there, regardless of your preferred programming paradigm.


I picked Python because I like Python the language.

I put up with the standard library, I'm not thrilled about there being so few decent cross-platform IDE's supporting Python, and module hell can drive me nuts, especially considering the fact that a minor version discrepancy means the module won't work (e.g., module built for 3.1 refusing to work on Python 3.2, although perhaps there's an incredibly simple solution to this which has evaded me thus far).


Mercury (http://www.mercury.csse.unimelb.edu.au/), a strongly-typed, fast, relative of Prolog.


I marked C#, Clojure and Javascript.

I use C# and Javascript at work, and enjoy both. (Not saying I enjoy .NET though, just the language.) I like the way C# is evolving towards functional programming and includes new paradigms while retaining the (ostensible) familiarity of Java and C.

Clojure is a great language and there is a great community around it. Here I am just a beginner, though, and it is not part of my everyday life. Hopefully it might change in the future.


I see Python leading in this poll. Two things that can be happening: 1. Python is going mainstream. 2. Programmers who are hackernews readers like Python more.


I moved from Java to Python, hopefully I will never have to go back. Writing in python is a pleasure. I do a lot of SQL too though I cant really say I like it.


Mesa and/or Modula3 was always a nice language to write in.


langs = list()

f = open('langs.txt', 'r') content = f.readline() while content != "": line = content.strip() if line != "": temp = {} parts = line.split(" ") if "points" not in parts: temp['title'] = parts[0]

		nextline = f.readline().strip()
		parts = nextline.split(" ")
		temp['score'] = parts[0]
		langs.append( temp )
	content = f.readline()
newlist = sorted(langs, key=lambda k: int(k['score'])) print newlist

"""

[{'score': '6', 'title': 'Cobol'}, {'score': '6', 'title': 'Rexx'}, {'score': '7', 'title': 'Fortran'}, {'score': '8', 'title': 'Ada'}, {'score': '8', 'title': 'Pascal'}, {'score': '9', 'title': 'Groovy'}, {'score': '12', 'title': 'ColdFusion'}, {'score': '14', 'title': 'Delphi'}, {'score': '14', 'title': 'Tcl'}, {'score': '16', 'title': 'Shell'}, {'score': '18', 'title': 'Forth'}, {'score': '20', 'title': 'D'}, {'score': '23', 'title': 'Visual'}, {'score': '24', 'title': 'Smalltalk'}, {'score': '29', 'title': 'SQL'}, {'score': '30', 'title': 'Assembly'}, {'score': '31', 'title': 'OCaml'}, {'score': '32', 'title': 'Actionscript'}, {'score': '51', 'title': 'Lua'}, {'score': '57', 'title': 'Erlang'}, {'score': '74', 'title': 'Scheme'}, {'score': '92', 'title': 'Scala'}, {'score': '100', 'title': 'Other'}, {'score': '120', 'title': 'Perl'}, {'score': '123', 'title': 'Objective'}, {'score': '125', 'title': 'Lisp'}, {'score': '163', 'title': 'CoffeeScript'}, {'score': '187', 'title': 'Clojure'}, {'score': '192', 'title': 'C++'}, {'score': '194', 'title': 'Java'}, {'score': '205', 'title': 'Haskell'}, {'score': '235', 'title': 'PHP'}, {'score': '303', 'title': 'C#'}, {'score': '355', 'title': 'C'}, {'score': '515', 'title': 'JavaScript'}, {'score': '718', 'title': 'Ruby'}, {'score': '1133', 'title': 'Python'}] """


You can see a chart here: http://hnlike.com/hncharts/chart/?id=3746692


Throwing:

  Warning: file_get_contents(http://open.dapper.net/RunDapp?dappName=HNChart&v=1&applyToUrl=https%3A%2F%2Fnews.ycombinator.com%2Fitem%3Fid%3D3746692) [function.file-get-contents]: failed to open stream: HTTP request failed! HTTP/1.1 503 Service Temporarily Unavailable in /home/content/c/a/l/callindia/html/hnvote/hncharts/chart/index.php on line 6
  Error fetching the Hacker News Poll.


I just broke down and got a login on HN because of this poll. I was astounded at the number of python votes. Mmmm -- I got a reg and also voted for python, but still... Why is this poll so lopsided? I would have guessed a murkier distribution, after all, we all have to write in at least 5-6 langs just to get along. Does HN simply attract pythonistas?


Here's my programming language usage history so far. (learned order)

1. DOS batch scripting (1994)

2. C (1996)

3. Bash (1998)

4. Pascal (2000)

5. PHP (2001)

6. Ruby (2002)

7. Javascript (2004)

8. Python (2005)

9. Ruby (2009-present)

Now I'm in love with Ruby more than ever, I turned it down several times during my college years in favor of Python, but finding Ruby is like finding your true love. I was in loved with her more than ever. I have gone through Python, and back to Ruby and I am much happier as a programmer. :-)


I like ruby with RubyMine IDE . They work fine on the server side apps (web and console). Havn't tried desktop apps and dont know if it is possible ( i know its possible with jruby and swing but no info for ruby it self). It has a good feeling and flexibility when you work with it. Good class library and gems are easy to fetch and install


How ironic is that when someone ask you to write a program that put some text ob screen and you are unfortunately using C#/Java or similar languages, your code comes out something as : public class main { public static void main(string[] args) { Console.WriteLine("Hello world"); } }

Which should have been just: (print "Hello world")


Top ten 24 hours later out of 11689 votes

    Python     2591  22.17%
    Ruby       1451  12.41%
    JavaScript 1182  10.11%
    C           817   6.99%
    C#          678   5.80%
    PHP         544   4.65%
    Java        460   3.94%
    Haskell     450   3.85%
    C++         449   3.84%
    Clojure     388   3.32%


My list:

1. Go 2. Python 3. Everything else


By voting for Scheme, I really mean Racket.


Can you add Go please?


My favorite language is the one I don't know yet and desperately want to master. Objective C, in my case.


It changes all the time, and all languages have their merits and drawbacks. But I'd say Rust for now.


We did something similar with the 40,000 code submissions made on CodeEval last year. Python was also the winner :)

http://blog.codeeval.com/the-most-popular-programming-langua...


3 votes for Shell script and none for Tcl? I guess every kind of insanity has its limits.


It is worth the observation that we can only really upvote the languages that we have used -- others simply aren't eligible for the 'favorite' moniker; even if we've seen a little code written in them, we haven't really felt them.

So, like, JS was my second language. Ruby and Clojure have as yet proven impenetrable for me to learn, but I'm working on that. I have shell scripted and done plenty of PHP, Python, Matlab, and Java, and I learned Scheme when using SICP but I feel like I never have anything available when I'm writing in it -- I hear Haskell is much better at this. I have seen some Smalltalk and it looked very pretty, some C and I was able to trace through it but I felt nervous as hell. That's the extent of my education.

My point is, out of this, the only stuff that I know well enough to choose my favorite is PHP, Python, Java, and JS. This poll cannot give a meaningful result for the question of "what languages are good?" without also asking everyone who responds: which languages have you written more than a hundred lines of code in? which have you read more than a hundred lines of code in? Then we could ask, "given those that have used X, how much has it been loved?" and get a measure of lovability.


Python, because it lets me concentrate on what I want to do, and by default I think about algorithms in something that looks a lot like Python.

Runner-ups:

Clojure, because it's different and elegant.

Javascript/java/c++ because sometimes it needs to work in browser/use some library/be fast.


It's a fairly circumstantial question. If I had to pick one language for the rest of my life and could be asked to build all manner of applications, I'd pick Java. Otherwise it's ruby all the way - it's fun to work with, but has limits.


You really might enjoy Groovy. It's eerie how similar it is to Ruby and yet somehow it pulls off being nearly Java compatible at the source level (I know you won't believe that statement if you haven't tried it, at least I wouldn't). It really is a kind of 'have your cake and eat it too' kind of language.


SQL isn't really general purpose programming language, it's hard to call it `programming' language at all. It doesn't really feel comparable to the other ones.

Also Lisps could be merged into single entry since all shell languages are one.


Any Visual FoxPro refugees out there? It was the first language used for a serious project. It's still one of my favorites due to nostalgia. I do fire it up occasionally when I need a quick tool written for the office.


Got to be C/C++ because everything relies on it in some fashion. For example, interpreted languages almost always use a C/C++ built interpreter. It's also the most direct route to assembly which is the ONE....


Why have a single favorite language, use language as a tool to get the things done.But for the question sake I will say Java and Python, but if this questions come up next year, I will like to click few more...


Standard ML. The implementations and the standard library situation both need a lot of work, but the language itself is by far the cleanest and most practical very-high-level language I've encountered.


I'm surprised to see such a low number of Fortran programmers. Are we really at the brink of extinction or are people from science and engineering not interested in all this kool new (hacker) stuff?


That's cool question! It's like who is stronger Vandam, Chuck Norris or Stallone )) It will be great to include chart here - to illustrate all languages with more then 'N' points for example.


Its really a mix of erlang and python at this point. I love erlang for its error handling and concurrency performance. I love python for its easy to read factor, libraries, and simplicity.


I voted for Ruby and JavaScript because that's what I use. I've tried some Python/Django but it somehow didn't feel right. I guess it really comes down to your personal preferences.


Favorite != most used. Sometimes you're "forced" to use a language because "that's what the company use". For example, I use Java in my company, but I won't make it my favorite.


Groovy: Added two hours late and out of alphabetical order. Not the most popular language, but definitely a rising star. Too bad it's not getting a fair shake in this poll.


q (http://en.wikipedia.org/wiki/Q_%28programming_language_from_...)!


It depends what I'm trying to do.

The question is like asking a carpenter what their favorite tool is.

It'd be more enlightening to (somehow) ask what kinds of problems people apply each language to.


Depends on what you're doing, but favorite implies I enjoy it, which would have to be something that isn't used for work, which would be something Pd/Max for me.


If Coffeescript is on here, Moonscript should be added too: https://github.com/leafo/moonscript


Favorite language, not to be confused with a language I can practically use yet. I love and voted for Haskell but for now my weapon of choice is Python.


I think programmers have to choose best suited tools for solution considering existing requirements and constraints.

But giving an answer I'd like to vote for Go. :)


Hm... Maybe one of the reasons why replacement-for-C kind of languages don't quite take off is because people apparently still like C quite a lot.


I just wish I could downvote. I'm looking at you, PHP.


Have to admit that seeing PHP 2:1 over Lisp casts the HN audience in a much different light, though Haskell's fairly good showing is at least a little reassuring.


I prefer PHP to Lisp.


Go without a doubt.


F# and Dart should also be on this list considering they're the source of a lot of programming language innovation that's happening atm.


'None' is missing!


Perl 6.


Who are these masochists who are voting for C++?


people who prefer compiled to interpreted


I prefer compiled over interpreted...but I prefer almost anything over C++!


PHP is nice... but if I could improve it, I'd like it to be not quite so loosely typed. I would like to specify the datatypes.


Every now and then, someone comes up with ideas to "improve" PHP. Some of those ideas are actually quite good. The only problem is that PHP is about as obsessed with backwards compatibility as Windows is. Good luck getting the devs to accept a feature that will break scripts written in PHP 3. (Yes, that was a bit of an exaggeration, but libraries like phpass actually do claim to work in PHP 3, 4, and 5 without modification.)


My favorites:

- Ruby, because it's easy and straight forward with lot's of nice features

- Python, because... I don't know. I just enjoy writing Python code :)


I went with Shell since I am not even a programmer, more of a designer. Shell scripts helps me automate almost everything.


It is quite surprising to see that Ruby and Python are the most criticized and also the most popular languages on HN.


Do people like Actionscript? I've always felt like this language is only used when programmers have no other choice.


Out of all the languages I've used (C/C++/Perl/Javascript/Erlang/Objective-C/Ruby)

I like Perl the best and javascript+ruby the least.


That's really surprising to me. Whenever I tried Perl it always turned into a painful mess. When I started using Ruby I felt it was the best of Perl and the best of ... Smalltalk I suppose — and I never looked back.

Maybe I'm missing something about Perl?


Ruby looks nice.

You better follow the best practices for Perl and it is like the other scripting languages. Check the Modern Perl book.

My reason to prefer Perl is because it is fun and the culture is good. The business case for Perl is CPAN. E.g., check Moose and additions like http://search.cpan.org/~flora/MooseX-Declare-0.35/lib/MooseX...


No single language is the best for every situation. Know the tools and pick the right one for the problem at hand.


I guess I'm making a fool out of myself right now... but C# comes before C++ in the alphabetic sorting order ;-)


[Witty comment on the correlation of great software being written in the two most hated programming languages.]


AWK. When I get to use it, that is. It's not right for most problems, but when it is, it's a pleasure to use.


Are you referring to SQL the standard (which isn't a programming language), or to any enhanced flavour of it?


I think we need another thread of favorite scripting languages. Shell would have more than 15 points then.


It's slightly depressing when a poll about favorite languages has 30+ options and your choice isn't there :-(

+1 Groovy!


Love how much love CoffeeScript gets!


Most of these languages are not as good as my favourite language, Blub, apart from the Lisps.


Racket http://www.racket-lang.org/


How is Haskell almost as high as Java? I've never seen it in use anywhere, Java everywhere.


A lot of love for C#. I would have assumed that there would be a lot of C# / .NET bashing.


Surprised to see the poll includes coffee script amongst the list of these elite languages


I cannot understand why 180 people voted up PHP. It's the worth language I've ever tried.


Ruby and Lisp for me. A couple of years ago it would have been Python but not any more.


C# is my favorite language, too bad I can't use it since I work at a Linux shop.


I am verymuch surprised that there are over 2x JavaScript votes than Java or C++


Why isn't `awk` on this list?


http://www.cobol.com/


Come on Hackernews! Is it hard to sort the list by number of voites?


People see to be confusing "favorite language" with "language i use".


i like the constructive conversations. when i first saw this i was afraid this might turn into which one is better in the comments. glad to see a mature crowd on HN,very informative =D


Ok, who are the five people that said "Cobol"? Show yourselves! :)


F#

It's really fun to use; a bit like Python but with the benefit of static typing.


SQL is not really a programming language. PL/SQL is.


This proves that python is the best language.


Gotta be PHP! Half the web is built on it!


No Limbo? Dennis Ritchie will be let down.


The recent success of Python saddens me.


everyone stop upvoting python ! http://imgur.com/gtLOb


No love for Ladder Logic? sniff


What about Go?


I guess Bash would fit under Shell ?


Putting my vote on perl was important enough for me to finally create an account here after lurking for a year or so. Still on perl 5


Go is my current favorite language.


i dont have a favorite language, but i really enjoy to play around with BlitzMax and Monkey.


other: hypertalk http://www.runrev.com/


Max/MSP/Jitter. Dataflow 4 life.


Python, Never comes in your way.


How do I vote this polling crap down? Pointless and subjective and if this was stackoverflow, would be deleted.


Should SQL really be up there?


i really loved working on C# it's quite cool but for web RoR and PHP are best


WLanguage from PCSoft-France


+1 for Go.


Go


No Go?


Where's R?


On my keyboard, it's between E and T, if you use a different layout, then I can't help you.


R is a delightful environment hobbled by a hideous language.


What? No love for Prolog?


MATLAB/Octave ... by far!


Why isn't F# in the list?


wtf, you put in cobol and visual basic but forget to add Go?


How about Go? #golang


Java's the best!


D. The only way.


Where's Racket?


Add Objective-J


SQL is the best


Python or GTFO.


XSLT and PL/SQL


Prolog ∈ Other


damn... Matlab is not on the list! :)


programmer happiness. end of story.


Where's Go??


what, no modula-2 or modula-3?


Circlejerk.


Where's F#?


I love D


PL/SQL


Perl


PHP


Matlab


Groovy


F#


SML


R


LabVIEW


C++


No F#?


ABAP.


Oberon-2


LPC


HyperTalk


Eiffel


No Self?


R


Prolog


Voting me down for stating my preference ? Really ?


rebol (& family)


prolog ∈ Other


LOLcode anyone?


c、java and python is professional！


Prolog


Other: LPC


wow, lots of pyfans


gawk


Hey, the C language is pretty well scored. I really really loved the C. For me, it's the king/father language. Everything is in it seriously (I mean, types, flow controls, memory management etc.), and it's just on top of the assembly language. I could code with C during centuries I think.

By the way, Ruby is pretty well scored also. I should try it eh. Is it for back-end programming or front-end, native apps? What's the point with it?(Really less code?)

And about Python? Why is it so awesome?


"And about Python? Why is it so awesome?"

Because you already know it. Turn around and look at the pseudo-code on your whiteboard.


Generally my pseudo code looks like: for all for all for all =)

I highly prefer engineered coding than syntaxic coding. So there is no code in my white board, only -french- words. Code follow. And unlike mathematic and what most people think, concerning coding, details never stop you. Or really really really rarely. Bad design (=engineering) do and a lot.


I voted "other" because it is really impossible for me to name one. I just don't know enough.

OCaml wins on fundamentals. Scheme also rocks as a language. That said, there's something exciting about being able to leverage the latest OS technologies and solve the hardest real-world problems, which is an asset for the leading JVM awesomenesses: Scala and Clojure. Java sucks but there's a lot of awesome stuff available in that ecosystem (if you're discriminating and tell the FactoryFactory crowd to consider careers in investment banking).

I just got off a 3.5 month consulting gig and I'm really itching to buckle down on a hard Scala or Clojure project. I would probably vote for Scala because static typing is such a huge win on large systems where reading others' code is as important as writing new code. It actually makes reading others' code fun to have static typing, because you get automatic documentation of structure right away.


I Love C, PHP. I also worked on Python long back during GSOC but did not get a chance to work on Python projects later. And after I started working on frontend, I have been a sucker for Javascript ever since!


Those always reflect "vote the language you like the most from the 2 or 3 you use frequently"


Who in god's name voted for SQL??? And who voted for TCL??!!? Ouch! That hurts my soul!


I love JavaScript. C# is pretty rad too, but I do mostly front-end these days.


Wow, there are people who actually like JavaScript?!


I'm pretty sure they mean jQuery. Coffeescript is on the list as a separate item so that can't be it. Not much popularity behind Objective J and such. Definitely one of the javascript libs, I think we can all agree the javascript language sucks.


This list has SQL but lacks XSLT.

XSLT is a wonderful thing.


what? no Assembly?


PyCon 2012


Groovy?


Groovy


Where is Arc?


cause you don't have the ability to abstract things.


you write any more 100 lines and cannot eXpress your idea clearly with diagrams charts is a crap.


No Go or haxe?

Epic poll failure!

Of the ones on the list, I'd say C# is my favorite language though I virtually never use it due to the practical and political problems that tie it to Microsoft.




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

Search: