python because i'm not very smart

Same

Elm, because the compiler don't let me ship code that would cause runtime exceptions in production.

Though it allows you to hang on infinite loops

It is true, but that is a computer science problem to be solved, not Elm's, so every other turing complete language has this same "problem". And explicit recursion should be avoided at all cost, using map/filter/fold is way better!

Golang for concurrency

Python cause its easy, has a lot of tooling and not too verbose. Lisp is nice though, my favourite dialect is Clojure.

Elixir, because of the power of the language in its niche, the knowledgeable community, the well designed tooling.

brainfuck cause i fuck your mom

Haskell is fun, elegant and beautiful. It writes my code for me.

Come over to https://ieddit.com/r/haskell/

VBA :-)

Well not really because it lacks a lot of useful features.

However it does let me create applications using the MS Office package that would be a lot more work to do in other languages.

And it has a usable debugging interface that lets you make source code changes on the fly.

Code changes on the fly! vb6 is the path of least resistance and in some ways gives you life back instead of taking (Depending on project size).

typescript (nodeJS) because I use it at work and I'll I have worked in for 2 years o.0

None, I've been searching for a while and come to the conclusion that none of them can ever fit that role.

Nice things I'd like:
- A dependent type system with fallback to a non dependent one for programs that don't need it
- Distributed programming through an actor system (and OTP) or something based around Bigraphical Reactive Systems (still reading up on it)
- Row polymorphism (it's just too useful)
- Datatype Generics for program automation
- Elaberator reflection for automatic theorem proving
- Graded modal type system (goes with the above) as in granule
- Decent pattern matching syntax
- Error reflection (it's great when you can explain what went wrong)
- Copatterns (https://github.com/idris-lang/Idris-dev/wiki/Copatterns)
- Decent Ocaml-like module system (or something else as long as it works)
- Reader macros
- Pluggable Codegens

Currently the closest to that is Idris but it's not production ready and it's missing quite a bit of the other things.

If I write hobby code, it's C++ or C#. But Haskell is also amazing once you get used to it.

Julia is definitely my favorite for the stuff I work on.

F# because it's a nice balance of everyday usability and brain candy.

Xojo, you can drag a button onto your web canvas, double click it and put code inside the button. Compiles for every OS and target x86, ARMv7 (Minus android).

I like PHP, and I work with Laravel

F# for its strong yet little overhead typing system. Combining it with Domain Driven Design (see book Domain Modelling Made Functional by Scott W) makes creating my own software just right (insert Pacha from Emperor's new Groove saying his line about singing hills here)

I know people are going to hate me for this, but I love JavaScript.
It's so simple to use, easy to get going, doesn't force you into object oriented vs functional, lots of community support (although some of the packages are questionable), and basically works anywhere thanks to node.

I also like TypeScript but I kind of have a love-hate-relationship with it. On one hand, the type system is really helpful when trying to document everything and catching silly mistakes, but on the other hand, it also makes some moments that would feel like a breeze in plain JS very difficult. That's why I usually go with JSDoc, which gives me the power of TS but without any of the nasty type conversion errors.

C++, I like the control it gives me and I feel like once you are comfortable with it you can do so much