What is your favourite programming language?

Go. Everything feels very concise while also being very fast. No other language I've seen has had such an easy concurrency model. Python there's all these modules and all this setup you have to do around them, to launch another thread in Go it's just a single extra word before your function call to make it non-blocking and maybe 2 changed lines of code.

func BusyWork(val, iterations int) int {
	for i := 0; i < iterations; i++ {
		val /= i+1
		val *= val
	}
	return val
}

func ThreadyWork(val, iterations int, results chan int) {
	for i := 0; i < iterations; i++ {
		val /= i+1
		val *= val
	}
	results <- val
}

Even just blindly launching 100,000 goroutines all at once, ends up being more than twice as fast (7.3 seconds vs 3.4).

It feels quick and easy to write, and honestly for simple scripts go run file.go feels like it rivals python3 script.py in startup speed, while the actual code runs insanely faster. Just as a super bad comparison, the single threaded python busy_work() function takes 50 seconds to finish.

Not as fast as C, sure, but I still feel like I'm getting the ease of writing of Python while also not sacrificing speed.

For me, it's most certainly Rust, and I'm not going to try to force anyone to like it, because it's not perfect, and also, that backfires.

I actually like Rust for several reasons, method chaining, an error story that actually lets you know what error states your program can enter into (looking at you Exceptions, not that I hate exceptions, they're better than some other options at least). and the whole "can't easily write a program that violates memory safety" thing. Going back to the states thing for a second, I like that I can move a lot of errors to compile time, where they might be runtime errors in other languages (Like guaranteeing that a UART controller doesn't accidentally set the wrong register, by using 2 different structs, that physically can't be created without the hardware being in the right state)

For some reason, the following function is my favorite function, it isn't perfect (actually, it isn't even that great), but I smile every time I see it:

pub fn ld(cpu: &mut Cpu, hw: &mut Hardware, dest: Reg, src: Reg) {
    match (dest, src) {
        (Reg::HL, Reg::HL) => halt(cpu, hw),
        (Reg::HL, src) => hw.write_cycle(cpu.regs.hl, cpu.regs.get_reg(src)),
        (dest, Reg::HL) => cpu.regs.set_reg(dest, hw.read_cycle(cpu.regs.hl)),
        (dest, src) => {
            let val = cpu.regs.get_reg(src);
            cpu.regs.set_reg(dest, val)
        }
    }
}

This function copies the contents of the src "register" to the dest "register" (except when they're both actually memory addresses, then it runs the halt instruction).

I'm still a beginner, but, in this order:

1. Python for the beauty, philosophy, practicality and community

• Example of switching values between variables in Python:

a, b = b, a

2. C for the small size, simplicity, terseness and for forcing me to think through certain things

3. Emacs Lisp because I can do a lot with it on Emacs without even really knowing it

Python is my go to language when I need to solve a problem quickly.

PHP.

Fight me. :)

Not any more, really. But I spent a long time writing websites (back when they were web sites, not web apps) and php was great, in it's heyday. The days when if you wanted a framework you had to write it yourself. And I did, several times. I still use it here and there for the few small projects I'm involved with, because why do I need to mess about with Rails or Django or node or any of that stuff for my little brochure site? It feels a bit like driving a classic car - you have to be a bit careful otherwise something might explode or fall off if you go too fast, but it's all there, the foundations on which so much that came after was built on.

If you want to change how you think about software development, give Erlang a try. It’s a really cool language that doesn’t get enough love. The syntax looks odd at first glance, but it’s actually pretty simple and pretty great. Give it a try!

I work in C#/Net Core/JavaScript on a daily basis so I've come to like those languages but my favourite one for general dicking about on personal projects is Python. It just clicks with the way I think.

Haskell! I understand it's not the most practical language, but it's certainly changed how I look at computations and problem solving in general (for the better, I hope at least).

In general I suspect the whole world would be better if we went back in time and built everything in functional languages from the start.

Some of the most enjoyable programming experiences I have ever had is in Golang. While the language is simple (no generics or fancy error handling), I haven't ran into a case where either are explicitly needed. Once I am done writing the code, the program feels robust. It has replaced any of my Python or Node.js development entirely. With that said, I think Rust takes the cake. Rust had a steep learning curve for me. For a long time, I was running into errors with the borrow checker left and right. But after enough time, I truly believe that Rust has forced me to be a more cognizant programmer.

Julia, for multiple dispatch, performance and generally elegant design. It just feels more fun to code with it. If only they could magically fix the loading/compilation times.

C, because I can keep its syntax in my head. Also, it just makes sense to use C in my most-used operating system, OpenBSD. I like the "close to the operating system" feel.

Probably C#, it just feels right. Every time I look at different languages I end up wishing the syntax and everything was more like C#. I used to like Dart, because it can be transpiled to JS, which means I can use it to replace JS and do some fun stuff like making games in the browser from scratch in the HTML5 canvas, but Dart feels a bit dead for this use now. Also Dart is really similar to C#, that's probably why I liked it in the first place.

I also don't like Google, which is definitely a good reason not to like a language... especially considering C# is Microsoft haha.

All of the ML languages. Though, in terms of viability F# takes the cake for having access to the .net ecosystem, as opposed to ocaml's fairy lackluster one.

Kotlin and typescript have good typing systems and the modern features you'd expect from a modern language. They solve some of the uglyness of their base platform's language (i.e you can free functions in Kotlin, no === in TS, sane scoping rules in TS, etc.)

Rust is nice for being an actual systems language with the taste of modernity (and without C++17+'s cruft, and a real module system)

I'm a big fan of java for collaborative stuff, and scala for non-collaborative stuff.

Java seems to make good designs easier to communicate and keep when you have multiple people working on a project. It also has a huge number of good libraries (and a huge number of bad ones, but...).

Scala lets me program in a functional world without losing access to those libraries. I wouldn't want to expose some of the horrors I've created in functional land to others, but you can make some really "clever" syntax with it...

Lua. The main reason is that most of Tales of Maj'Eyal is written in it.

My favourite feature is Lua tables as the universal way to structure data.

Racket for the sheer amount of thought and engineering that has gone into it. The community is wonderful and the standard library is feature-packed but consistent. Everything is well documented and cross-platform-ness is heavily emphasized (this is also a minus in certain cases, because to do platform-specific stuff (eg. fork(2)) you need to either use the ffi or use an external package). It's also consistently among the fastest dynamic programming languages out there.

Two in fact.

First, LISP. Not elisp but classical (or Common) LISP. That language really moved the computing world ahead by decades, you can look it up; on LISP based computers people invented networking, GUI, laser printers, the computer mouse and much more. I believe that everyone should learn LISP. Not to program in it, but to understand it. There is always the moment when you really get LISP and learn a new way to think about programming in general.

Second is Rust. Although it's macros are not as powerful as LISP's, it has some other advantages. I really enjoy how it makes most of what I type an error so I can fix it before I deploy it! Though on the other hand, I also ran into compiler bugs, which put a project of mine on hold for almost half a year by now until they get a newer LLVM merged.

I work with Fortran most frequently, so I guess my favourite is anything but that? I like C++ and OCaml quite a bit, and I'm a fan of Go because of its fairly simple (and well-enforced) syntax and tooling.

As far as languages I thought would be more of a favourite, I'd have to nominate the lisps. I like them in theory, but I've never managed to actually implement a real world project (other than some Advent of Code problems in Picolisp I guess)

Can i ask a kind of offtopic question?
I'm really surprized that nobody mentioned rust. I feel that if this thread would be a year or two ago it would have been mentioned more than once. Was it just a hype? Or is it just not as beloved as i percieved it was?

Javascript, because it’s also the only programming language I know.

It's fairly unpopular these days, but I prefer perl5 for pretty much all of my home programming needs. This is in part because I've been using it professionally for the last fifteen years, but even in that span I haven't really seen terribly much of the 'write only coding' which it's famous for.

I've been taking some halfhearted efforts to switch to python or nodejs in order to stay in the mainstream of languages with available useful modules, but so far it hasn't seemed to be to an extreme benefit. I guess I'll have to switch someday, but so far it's been treating me quite well.

I write code in a lot of languages, but my favourite is definitely Python. Not because it's particularly beautiful, but because it's straightforward and it makes solving most problems easy, even when ignoring all the third-party libraries available for it. If it had a decent standard library, Lua would fill the same niche for me, "arrays start at 0" be damned.

If anything, I find shell - not full-fledged scripts, just one-liner pipelines - more elegant, more aesthetically appealing. But I don't really use languages for their aesthetic: I appreciate it more when they can make things simple. Python does that (but then, so do awk, shell, and make - in their own niches).

(bad/weird syntax, in any case, doesn't deter me much - writing boilerplate does, but not bad syntax)

This feels like a copout shitty answer.

My favorite programming language right now is Python 2.7. Why? Because it comes pre-installed on all CentOS servers which means I can finally stop writing scripts in bash for server monitoring. I fucking hate bash. There are no amount of tutorials that will get that language to click with me it seems. Which isn't to say bash is a bad language. It is to say it is a bad language for me and since 100% of my programming is for work, my favorite language is the one that makes work less frustrating for me. Once there is a CentOS version that comes with python3 natively and we move all our servers to that, then python 3 will probably become my favorite language.

I don't really care directly about the beauty of python or anything about python itself, just how it compares to my other options (bash). I use to work in C# and java and thought they were equally as good of languages as Python, but I don't have to work with those anymore so I don't care about them now.

PHP. For realz.

I've never understood why people give it so much hate. It's always felt unjustified to me.

So hard to choose! But right now my favorite is a language I'm building. It is a scheme-like with unhygienic macros, smalltalk-like messaging facility, delimited continuations, built-in graphics via SDL, and (working on this part now) a PEG-like facility to extend the surface syntax, similar to OMeta. I'm certainly having a lot of fun working on it!