What makes you want to stick with a programming language?

It's cheesy but one of the things that "kept me" around Python back when I started was the Python "zen philosophy" python.org/dev/peps/pep-0020/

You can also get it from the REPL:

>>> import this
The Zen of Python, by Tim Peters

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

As I say in my profile description, I love tech that solve problems and not testing my patience.

So I would say:

• Easy to set up projects
• Clear feedback on errors
• Not much boilerplate(Java anyone?)
• Great community
• Appealing syntax
• 'Magic' tricks. I love Ruby loops, for example. I also love list comprehensions in Python. Really handy features for me.
• Good documentation

The friendliness of the community, as well as how much I enjoy the language itself, keeps me around a lot. F# and Elixir have fantastic communities, and I enjoy them both!

I stick with Ruby because it rarely trips me up in the middle of crafting something new. It has a great REPL environment and the feedback cycle is fast. What I give up in terms of type-driven certainty I make up for in creativity-driven productivity. It's flexible when I need it to be.

I come back despite the headaches that come with its warts. I also come back for the sensible community attitude towards problem solving and the fact that I have a certain type of problem I gravitate towards solving. Ruby gives me the productivity that comes with maturity but the tooling seems to have enough "modern" appeal.

I keep expecting to do less Ruby but I keep coming back for the niceties.

Reasons why I moved, a now am happily sticking, to Scala:

• easy to understand for people with knowledge of Java/C++ like me;
• compiles down to java bytecode, aka it runs on any machine with a JVM;
  • which means you can freely mix any Java/Scala library, and it just works (in my company for example, we're using Spring + other java libs);


• lean syntax for variables/methods declaration, even leaner with respect to generics cough C++ and Java cough (0);


• but still, it's statically typed: it's just that Scala's type inference is so good that you can omit most of the type declarations (still, for a public facing API you'd better explicitly define the types!). And I really wonder why people would throw away such beautiful mechanism to check if "can this variable be passed to that method?" at compile time, instead of having unexpected errors at runtime;


• you can choose whether to program in functional style, or good'n old object oriented way, or mix the two as you wish (0);


• REPL to the rescue if you have to implement/check something quick (0);


• again, functional programming style! The moment you get the hang of it, you'll realize how immutable data plus data manipulation function definition will make your code much more robust than hiding complex state behind an object;


• no more NPEs: stop returning nulls and use Option instead. If you're dealing with Java libraries that do return null, wrap the result into an Option (0);


• powerful, compact and typed pattern matching that would otherwise translate in many nested levels of Java if(){} statements


• case classes to model data in a one liner, instead of POJOs that spans tens of lines


• traits and mixins

(0) yes, yes, Java 8/9 did catch up a bit, even though it's doesn't feel as intuitive and simple as Scala. And keep in mind, most of those features were already available since day zero Scala (2004).

In the initial stages I rely on documentation and examples. I need to quickly see how to do things. I don't care about basic things either, I need actual usable patterns and stuff that gets things done -- I may venture into non-basic territory quite fast.

As long as I can be productive I'll tend to stick with a language a while. My dislike tends to grow as my projects grow and I realize the features that it's missing, or I start to notice the redundancy or inconsistencies in a language. It takes a fairly long time to get to this point.

If frustration comes early I'll be disuaded from the language. This has been my story with Rust so far -- were it not for my stream where I'm forcing myself to learn it, I would have abandoned Rust within the first month or so. I also find it's documentation to be extensive, but quite bad. Lots of filler, not much usable material.

IDE features never factor in for me. As I jump between so many languages I've just come to expect limited and incomplete tooling.

It's hard to pin down exactly, but the thing that makes me want to stay with a language is what it feels like to look at my code after 6 months away.

In my work, I make a lot of prototypes, and then forget about them, and then come back and tweak them after much time has passed. I need the code to be maintainable at that point, and the language I'm using can have a dramatic effect on usability after I leave my "flow state".

I've found my Elixir and Elm projects to be the easiest code to return to. I think it might have something to do with documentation being a first-class citizen in both languages, and excellent tooling.

because it's javascript hah, well, I love the ecosystem which may be sometimes (a lot of times actually) overwhelming but the thing is, we just have to use what we need so the feeling of being really overwhelmed will faint. The community is really cool and I'm really comfortable with writing JavaScript and I can do a lot with it, on the front-end or on the back-end.
Still, If I'll need to use another programming language, I'd love to, I'll pick the 'best' one for me, the one I feel comfortable with, and the one who has a good community.
Actually it's like dating a star, the more the fans , the more you love it, well I guess dating stars doesn't go that way but, get the idea? lol

Documentation, a vibrant and accessible community and offering a solution for the problem at hand are my criteria. This means I work with quite a bit of languages I stick with, each with their advantages and disadvantages so I can switch based on the thing I'm trying to solve.

Currently C#, Python, GO, PowerShell and Ruby fit that description imho.

for javaScript,

You can love it, you can hate it, but you can't ignore it.

It has the monopoly in the web, used in desktop apps, can be used to make mobile apps.