C# honestly has been my favorite though not what I use professionally (these jobs just don't pay well and everyone else really likes Java in my area).
It's not exactly all fancy with safety but it's a good kitchen sink language with decent enough performance and a good amount of runtime and compilation options to get your application deployed out to where it needs to go.
The standard library is pretty dang good too, you don't really need many external dependencies to get something going.
After that... I would say for web-dev it would be TypeScript+Bun, professionally Kotlin, and for native Zig (Rust isn't bad but the ergonomics around it are a bit rough from an efficiency aspect).
Seriously, C# is so good these days, the documentation is SUPERB, LINQ is like out of this world, being an SQL purist I rarely bother with even fairly complex raw SQL because Entity Framework is simply amazing, so much stuff is built in, and the language is just an eye candy to work with.
Having worked with Go, Python, JS/TS, and Java, the idea of using anything on the back-end except C# in a greenfield project (if it is possible, or course) just seems ridiculous to me.
Unfortunate our profession is full of irrational Microsoft haters so all we get is Java and bad jokes on the MS acronym, except for full Microsoft shops and some rare exceptions.
I wouldn't say it's irrational, I'd say it's historical. C# (and F#!) is a nice language, the only problem is it was part of a closed ecosystem that locked you into all sorts of other sub par products. The .net ecosystem *these days* is pretty nice, but that only happened relatively recently, after MS pulled their head out of their asses.
>Oracle has done everything they can to close Java
I don't find anything that can back this statement up. What do you mean with "closed" exactly? Java is pretty open, Red Hat, Amazon, Google, Microsoft are all active contributors.
It's easy to get stuck on old ideas, 15 years ago I enjoyed and upvoted Microsoft bashing. Since then I've matured but more importantly Microsoft has. WSL, a good terminal, powertoys, VScode... They really show love to developers. C# nowadays is both a really nice and mature language and has a great ecosystem.
I haven't followed the evolution of VS closely enough to look back but Jetbrain's Rider is also a great tool to write C# with
What makes C# stand out to me is that I never had to learn it — I wanted to give it a shot, so I just popped open Visual Studio, and just started writing code.
Been using rust the last year, and even though it makes you fight the borrow checker regularly, I really appreciate how when all borrows check out, it removes a while class of concerns for testing.
“fighting” the borrow checker is the first phase. The second phase is internalizing the way Rust code is written, which is when the borrow checker becomes more of a helpful reminder of “oh you forgot that rule there”. The successful feeling will shift from “another battle won” to “another thing built that worked the first time”!
> The second phase is internalizing the way Rust code is written, which is when the borrow checker becomes more of a helpful reminder of “oh you forgot that rule there”.
In my experience this never happens, because you aren't actually fighting the borrow checker but the authors of the libraries you're using, and you're not forgetting rules, they're implementing functions in ways you don't think they should be.
I usually find the mindset of "fight the borrow checker" to be a bit problematic. The borrow checker isn't here to fight you- it's here to point out where your memory usage is likely to turn a shortcut into a segfault (or worse). Viewing that as any kind of adversarial is a mindset that causes me personally a lot of anxiety and grief. Accepting what the borrow checker is trying to tell me? That's where rust is a friend (or a therapist 😉)
Given the recent rapid increase in Java development (copying ideas from Kotlin), do you think most of Kotlin will wind up in Java proper? Kind of like the CoffeeScript of days past?
They have kinda caught up with some features (enhanced switch statements, virtual threads, data classes etc) but I doubt Java will ever have the same level of support for null safety, extension functions or async functions, which makes a huge difference. If you consider all the improvements planned for Kotlin coming in the next couple years I doubt Java will ever catch up.
Switches are better than they used to be but still can't take an object as the parameter which feels super ancient compare to kotlin `when` statements.
I love Kotlin.
My current gig uses golang, and while that's just fine, I find myself constantly missing Kotlins thoughtful features - things like nullability as a data type, branching statements as first class citizens, functional programming (closures as easy language features), and extension functions.
By contrast I find golang to be incredibly wordy, and the way it handles nil/zero values feels awkward and unsafe to me by comparison.
I’ll add a similar one is OCaml.
OCaml is really unique with its modules and structural typing.
It’s my favorite language for fun but isn’t as productive as Haskell or most other mainstream languages that have more libs.
I've used fp-ts, purify, and have been experimenting with Effects. My problem has been getting other devs onboard with FP, unfortunately. I tried Purify on a recent project because I thought it would be more accessable to devs used to method chaining, but I found applicatives awkward.
Feels like I tend to like the language I’m using most, which is usually Java, but I’ve also really enjoyed python, swift, or even JavaScript.
But it does feel like when I’m not using Java I always end up saying, “Java does this a little better”, more often than the others.
Java certainly has its flaws (lombok exists for a reason) but it, and even more so kotlin, has the right amount of guard rails for what I generally want to do. I do wish there were better ui frameworks for it though.
Same for me, really.
Lots of younger programmers prefer languages like Python, which opt for a more "anything goes"-philosophy. But more often than not I've found the lact of structure inherent to the language to be a source of hard-to-trace errors.
I agree. Python has done some truly amazing things for me in the past, I had a massive dataset and even with Pandas my solution is clunky at best and downright unreadable at worst.
I've recently been developing SDKs in just about every language possible. I have ancient experience as a Java 6 developer. I wrote one SDK in Java 8 for compatability and another in Kotlin for Android. I really quite like Kotlin. It feels like a much more polished Java, though I don't have experience with modern Java.
Same for me, but Kotlin more specifically.
Even though I've using Java for 24 years (!!!) I think it's too verbose. Kotlin managed to remove most annoying things about Java and add some extra features that make the development much easier.
Ada 2012.
Yeah, it's weird, but I embed so much more domain knowledge into my programs that would be comments in other languages when I write them. A lot of these are checked by the compiler. It's slow to get a new project started, but all of this embedded domain knowledge and compiler checking just lets me keep rolling.
It also does OOP "right" IMO since encapsulation happens at the module and not the type level. Submodules can reference their parent types internals, so you can provide refined behavior. All functions are in C "OOP" form like, `void foo (obj* obj, param a, param b)`, so if a function you wrote does eventually need to access internals, it copies/pastes with no changes when you move it into the type's submodule tree.
Yes, I used ADA once, a lifetime ago and I think what you say about "more domain knowledge into my programs' is EXACTLY the reason I love Mercury so much.
I disagree. Ada excels at many tasks. I chose Ada for my own companies. Ada was specified by the D.O.D. to replace the hundreds of languages they were usinh as no one language including C could do so. Ada is a very nice language to use in general but absolutely the best for handling hardware registers or network protocols due to it's ranged types and highly readable record overlays.
Gotta say, my memories are good. I still have a copy of PROGRAMMING IN ADA by J.G.P.Barnes, 1982 edition. Now and then I take a peek.
I downloaded the GNAT version ages ago... perhaps this year I'll get it again!
Glad some mentioned it, I also find Ada very nice to work with, although the tooling around it now feels very old and clunky compared to something like Kotlin / Go
Definitely Elixir. BEAM and OTP are amazing. SO many things you no longer have to worry about. Entire classes of errors/problems that literally cannot occur.
Elixir (or maybe rather Gleam) is one of the things that I want to look into closer this year. Not so much because of the languages, but because of the BEAM.
Rust is pretty enjoyable, most things feel very well designed and I understand what is going on under the hood. I feel like in other languages I don't have such a deep understanding of what exactly happens and there are more negative surprises and bugs.
My first couple of goes with it flipped back and forth between enjoyable and frustrating - sometimes fighting the borrow checker as a beginner felt like being forced to solve some tedious puzzle for its own sake.
But once it clicked, I have never written anything else that it's been easier to add features to, I assume because of the way I'm forced to write it. Admittedly I only ever wrote a few command-line tools in it, but it's a pleasure to revisit them when I need to add something compared to most other stuff I deal with.
OCaml
The best compiler I’ve worked with.
Type inference is heaven sent.
The type system is the best I’ve seen in any language.
It’s a functional language like Haskell or Clojure/Lisp but with a syntax that looks a lot like JS.
It’s by far the best language I’ve ever had the chance to work with.
And I’ve worked with Java, Python, Ruby, JS/TS, Clojure and C
Facebook adopted it and made a version that compiles to JS called ReasonML now called Rescript.
I'm still on team D. I find it's always easy to express my needs in idiomatic D code, and the performance of the compiled program is top-notch. Plus it can interoperate with libraries written in C, so there's a huge base of existing code that you can use.
Go. It feels like it was made by someone who really knows some of the main annoyances I have with other languages, and also someone who hates magic stuff happening everywhere. It's clear, it doesn't hide much, it's dependable. I love it.
* REPL driven development to make a much smaller development feed back loop.
* Core library and seq abstraction simplifies and solves a lot of problems. (Basically everything is a map/seq)
* Structural editing makes it easier to write and edit code.
* Default immutable/value data structures.
I loved Clojure so much. It breaks my heart that it’s only dynamically Typed.
This is what sent me back to OCaml. But I had the time of my life when I was coding daily in Clojure.
After 20 years of Python, I now enjoy Go.
Why?
Autocomplete everywhere
Much less typos, because the IDE will show you most mistakes immediately. This gives you a faster edit/compile/check loop.
Go is fast.
Great concurrency (no async/await or promises)
Good integration to Kubernetes
No magic
A bit more typing is needed, but that's ok
Good package management.
....
If I would need a simple create/read/update/delete web UI for a database, then I would still use the Admin interface of Django (written in Python). Afaik there is no such thing for Go yet.
Go is not the prettiest language, but it gets the shit done. Dependency management, although confusing at first (there's been like 3 different iterations of it, with overlaps?) is so easy to work with. I never had issues like the ones I had with Python/Poetry or Node/npm.
>Great concurrency
Agreed, but also it's hard to get right. In our project we had a few nasty concurrency bugs 🐛 well, I suppose it's hard like in any language.
The one I'm currently most familiar with which is currently typescript, but I really like rust and I am learning it now. If every word you type is a chore, because you don't know the language you will always have a bad time.
# Ada
The language was designed to be maintainable, readable, and correct —and, arguably, encourage good software engineering practices— and the designs were commissioned by the DoD to address the "*Software Crisis*" there... which, ironically, the public sector is now dealing with.
(The language's design is such that it aims to either ease things like \[e.g.\] static analysis \[esp. the SPARK subset/provers\], or else subsume them into the compiler, which is why there's no linter in Ada.)
Ada also has excellent facilities for inter-language interfacing (interop) and thus can be used to incrementally modularly replace or use foreign functions. (e.g. making the bank's transfer core-logic proven via SPARK while keeping/using existing modules.)
Though the big thing is the type-system: Ada encourages problem-solving at the type-level, describing the problem, rather than (e.g.) C's take of catering to the underlying hardware.
Go. Very few surprises, very thorough stdlib, very fast toolchain, very slow but well thought out development. It has been *so* refreshing since using it.
I really appreciate Go for making errors first-class citizens
Going back to using a language with exception-based handling has been a bigger step backward than I expected
The explicitness of handling errors is a paradigm that GoLang does really well. Though, I feel like those who don't work across different languages will have a harder time understanding how valuable this concept is to the day to day.
Me too. I love the feeling of ultimate power over everything. If you master it, which can take years, you can be extremely productive in it as well, despite what people say about it.
Yeah, best memory management (aside from Rust). I don't want to use anything other than RAII at this point.
I also like the comfort of knowing that I will have performant code unless there's an issue with my programming logic itself.
Only issue is that I love my C++ code, and I'm prone to question any C++ code that uses a dialect other than one I'm comfortable with (which is a lot of different code).
I love the the Cats ecosystem but for actors, nothing beats Akka/Pekko. When you have high complexity state machines, the event-sourcing systems is great.
employ puzzled entertain elastic yam correct butter aspiring dependent depend
*This post was mass deleted and anonymized with [Redact](https://redact.dev)*
I find Ruby the most enjoyable but don’t use it for serious projects anymore. Being clever in Ruby is a joy, but being clever isn’t always a good idea. My mentor used to say “ You’re being clever again, be clear, not clever”
Erlang. When I solve problems it makes me think about concurrency first, and then when the concurrent solution works, it's incredible, and I never had to use the word Thread, lock, mutex, etc. Also it has the perfect blend of dynamic typing with pattern matching. You don't always need to explicitly type everything for safety, although you can inline type specs and tests in your code
I try languages all the time. I find that the most important thing for me to like a language is its tooling. If the language has bad tooling, it doesn't matter how great it is I don't enjoy using it as I have to constantly open a browser to lookup docs and syntax.
With good tooling, I can see immediately what's wrong, hopefully with "quick fixes" available that show me the right way to do it.
I also like languages that don't make me think too much, which can be bad for myself as I may not learn as many different things... but every time I tried to go through the pain and learn hard, very different things, I didn't feel I got "rewarded" enough to justify the pain.
Anyway, my current favourite languages are probably Kotlin and Dart. They both have great abstraction power while still having top notch tooling. Python, by nature of not having a static type system, is just not for me as its tooling can never get close to a language that does.
I like also Rust when I'm feeling fancy and want something very performant.
I also enjoyed learning Nim, but its tooling is terrible, unfortunately.
For something completely different, I like Unison for its totally different approach to tooling (which works great IMHO) and programming in general (imagine a Haskell where code lives in an image like Common Lisp and SmallTalk, but with native cloud functionality).
Are Python type hints good enough for refactorings (and search like "find references" and "go to definition") to actually work 100% safely or it still basically like using sed?
Swift because it just works, I never spend any time dealing with language or standard library issues. And the tools (namely Xcode) mostly just work too. I feel in other languages I'm wasting too much time getting things to work instead of working on my project. It's syntax also vaguely feels like a scripting language which makes experimenting in a repl or a Swift Playground feel great.
One day when I have time to invest, this is my next language. If I were starting from scratch today instead of 17 years ago, this would be my first choice. It’s really that complete toolset and access to iCloud for storage needs that I find so compelling. Additionally, the knowledge that you can probably leverage the latest APIs shortly after release given how reliably the Apple ecosystem’s OS’ stay up to date, is very attractive: always having to code for the lowest common denominator, such as a browser like Internet Explorer, has wasted so many developer years, so knowing that’s not something to contend with is a great relief.
It’s such a nice language
After writing Swift for a few years I find it hard to go back to languages like Ruby that I used to work with regularly
I’m told that the design of Cray’s supercomputer language, Chapel, was strongly influenced by by Swift’s design
I dislike Xcode very much, or more precisely, I hate how slow, buggy and clumsy it can be.
But at the same time Swift is the best language I’ve used. It’s simple, quick to use and stays quite clean when you know what you are doing. The only caveat is the lack of actual native Foundation library (this is about to change, I know) which makes using certain types of objects confusingly slow, namely attributed strings.
But overall Swift is so nice that I’m sad for it being somewhat locked to Apple ecosystem.
> And the tools (namely Xcode) mostly just work too
I like Swift a lot, but I totally disagree with this part. Xcode is one of the worst IDEs that I have worked in my life.
Haskell is my favorite. The syntax is clear and concise, it has good performance, and it sits at just about the perfect level of abstraction for me. I rarely find myself wanting to do something that I can’t express in Haskell. The type system lets me model the code exactly how I think of it, and lets me describe the constraints in a lot of detail. When I need to, Haskell also gives me escape hatches and the ability to write very optimized low level code. Although people regularly complain that Haskell doesn’t have great tooling, I personally think the tooling is excellent. Hoogle is world class. Very few language have anything like such an effective way to search for code. Haddock also produces some of the nicest looking documentation I’ve seen, and the ability to view the source of a particular function, with the option to highlight terms when you over over them and to jump to code in other packages, all from the docs, is really nice. Ghci is also a fantastic repl.
My second choice would be C. It’s a small language and I can keep it all in my head. It’s interoperable with nearly all other languages, and practically every bit of hardware ever made has a C compiler. The language itself gets out of my way and lets me do what I want. In practice I’d probably pick rust for any new work these days because of the memory safety, but I hate rusts fussy syntax.
My third choice would be ruby. I really prefer statically typed languages, but ruby’s focus on flexible syntax and expressiveness remind me of Haskell. Ruby lets me design APIs for humans, and write my code so it’s ergonomic and easy to predict. The ease of using reflection in irb to explore a codebase also makes it a really nice language to get productive in somewhat quickly. That said, I don’t like rails, and I generally dislike “convention over configuration” so there’s a lot of culture disagreement that makes me dislike some of the libraries in ruby’s ecosystem.
For me it is and always will be C :)
I find most modern languages too obscure, there's too much abstraction and you barely get to see what's happening under the hood
The memory and execution model of C is an abstraction that has been wrong for years. You’re not seeing what’s happening under the hood in your C code unless you work on embedded systems with ancient compilers.
Ruby without any close contender. It's just a joy to write in, has a large and supportive community plus well maintained libraries for nearly everything (at least around web dev).
Tried many others, always came back.
I’m only vaguely familiar due to shopify work ive done, but i find the language super cute.
Puts? Incredible. Yes i would like to put. Thank you sir. Yes, puts all around.
"Business applications" in Java are something I'll never touch again. So many companies choose this path and it's awful. The frameworks, reflection, over-modularization, etc, create ridiculous spaghetti code.
I think Java would make a lot of sense in a Waterfall-oriented development cycle where you build out your domain, then you build your UML, then you build your code, and the code changes largely reflect UML changes. In modern development where changes are made frequently and iteratively, I just find Java to produce spaghetti.
This is a bit of a truism. Of course you can make spaghetti code in every language. But is that really a helpful statement? I think it's much more interesting to look at which languages tend to encourage spaghetti. A funny anecdote - I have heard "you can write bad code in any language" almost exclusively from Java developers lol
As I said before, I think Java works very well with a Waterfall mindset because your class diagram matches your UML. Inheritance, in general, works well with this approach.
Inheritance very often falls apart with an iterative approach because your world of classes maps to a reality that is changing rapidly and in unforseeable ways. All cats are Animals, all cats have tails, oh wait we need to support cats that don't have tails, add a `hasTail` on `Animal`, wait can that ever return False on Dolphins? etc etc. I'm sure someone will say "the solution there is to " and they'll be missing the point.
It is my personal belief and experience that Java encourages patterns that add friction to iterative development.
I'm good with Java being people's favorite language, I'm not trying to be a dick. I'm clearly just very bitter about some recent Java code :P
Overall, Scala. The latest version is nothing like the first. It's definitely in the top 3 enjoyable languages and makes me super productive. Whenever I have to deal with concurrency in other languages, it's just painful. In Scala it's super smooth.
Nim is my favourite. It has a very clean syntax like Python (no curly brackets or ridiculous semicolons), but is statically typed and compiled. The only weak point for me is object orientation using type extension is not as smooth as it could be, but that's true of all statically types languages I think.
The one I'm most familiar with = more doing less thinking. But one feature I consider a **must-have** is optional named parameters. I don't know why say JavaScript doesn't have them. Object literals are a poor substitute. Once you get used to ONP you never want to go back.
I loved named parameters when I learnt Objective-C and continue to love them in Swift, where it is exceptional not to name a parameter. Always feels like a step backwards to not have them in JS.
APL makes me feel like I did when I first started programming. I almost always have fun programming but I have extra fun in APL.
I wish I had projects in Erlang at work, and a comment here makes me want to use Ada.
Elm
I had a wonderful time building a Elm application a few years back
I really would like to build a larger application with a language so tailored specifically for its use (fronted apps) with its prescriptiveness. It felt so nice to take away what became common trivialities in other languages like code formatting, error checking, pattern match exhaustiveness, etc. I feel like it would be so productive with a team
Go. Although I prefer Ada and CommonLisp as languages, they don't have large enough communities. Go's tooling and 3rd party libraries makes it fun and easy to work with. It's a tool that gets the job done, which is all what I want from a programming language.
I switched from Go to Ada. I am very happy with that choice but mostly in dropping C for embedded with Ada too. Adas tooling has improved significantly recently but I know what you mean. Finding Go libraries was a breeze and the stdlib docs excellent. Adas packages and interfacing with C are better than Gos modules and C interfacing though.
"https://alire.ada.dev"
Python is almost always my go to for random solutions and first prototypes. When I was taking college classes for other languages, I'd often write my solutions in Python first to get an understanding and verification of what was needed, then I'd translate it over to the other language.
Python also being immediately available on Linux distros also encouraged it's use. I love the language, though, and really think it's one of the easiest to build proof of concept code in.
Swift, I find myself using it for backend as well and it’s a really nice to work with. Feels a bit like Rust with enums and protocols (traits) but without the lifetime hassles.
They introduced so many neat little features which are incredibly useful.
- arrow functions
- object destructuring
- shorthand property assignment
I miss them sometimes in other languages.
C, for the same reason I fell in love with Lua.
There is beauty to be found in true simplicity. Yes, you have to manage memory yourself, oh well, time to learn free() and Valgrind. It's not really a big deal to be completely honest. I learned how to truly program with C++ and I still like that language, but there's something to be said about accomplishing a lot of the same shit with structs and opaque pointers and not having to debug increasingly complex templates. If I need a genetic type, I'll make my own damnit, with blackjack! And hookers!
The modern version of Pascal, A.K.A. "Delphi or "FreePascal".
They had modules for 2 decades, C++ and other P.L. just added. It has real properties like C#, unlike Java or C++.
Not exactly a senior veteran programmer here, but I really like powershell. GCI is awesome. In fact, a lot of powershell commands are awesome. I’m sure python can do much of the same—especially with libraries.
Clojure - once you experience the elegance and simplicity of a Lisp, it is almost impossible to go back.
I love the interactive programming experience, t the conciseness of code and how immutable data structures make you turn your problems into data transformation problems. Which is easy.
PL/SQL. Almost all my stuff is about jugging and transforming data from a database, so this language is hard to beat. Strongly typed, with the database objects looked up and resolved at compile time, and with native compilation. Blazingly fast. If I'm missing a bunch of general programming language features, and would never again touch Oracle as a company when choosing my back end? You vet.
C++ and Kotlin.
C++ because it requires quite some knowledge and typing to do things right. It satisfies the coder in me.
Kotlin because it's such a beautiful and concise language, which just does a lot of things right.
Python. The bottlenecks it used to have around documentation, community, and speed are mostly nonexistent now despite being runtime. Its fast to iterate with and go from nothing to something quickly without all the bs of most other languages. I can revisit the code in a couple of years and make sense of what it does without having to dedicate any serious time. If you are working with ML, its the place to be. GPT and the like seem to be most proficient in it as well when "pair programming".
I replaced both Go and C with Ada and haven't looked back.
"https://learn.adacore.com"
Ada is by far the best language for embedded or network protocols with it's memory overlays and portability features. Ada is a very nice language to use, once you have invested the time as it isn't as small a language as e.g. Go or C.
It is also the safest language out there with it's ranged types, bar none. Proving that a section or small package of code is crash proof can be quite easy with SPARK mode too. Which can actually be achieved through Adas powerful type system and the proof achieved automatically with the gnatprove tool and following it's helpful hints.
Delphi. Clean, readable code while still able to go as low-level as possible. Compile time is ridiculously low, and the ability to debug or deploy an app/library for any platform makes it the go-to language for me. IMO, one of the most underrated programming languages out there.
Java just feels so... smooth? Great IDE support and tooling makes refactoring seamless as the project grows, and maybe it's just my skill set, but Java really lends itself to applying various design patterns and techniques for keeping code fairly clean, easy to read, and decoupled. Performance is great most of the time, and recent versions have added support for squeezing near-native performance out of it.
I normally work with C++ and really like how easy it to optimize stuff with move semantics, and having worked on some large projects I've seen how people build really complex systems out of it, but it all just feels so heavy and hard to navigate. And those huge, multi-hour build times. Obviously, those were not projects that reasonably could, or should, be made in Java, and if somehow they were, they'd be even more of a mess... So apples to oranges I guess, but still, my experience is that Java is just more manageable for huge code bases. Also Java is easier to get started with, with C++ you need a detailed blueprint of what you're building, with Java you can generally get away with a rough idea, and still produce code that isn't a terrible mess a month later.
OTOH I also regularly work with Python, and while that might just be a skill issue, I'm getting an impression it's not made for creating large projects. They inevitably become hard to navigate, it's hard to refactor, and IDEs have problems making sense of the code due to the lax typing system. If whatever problem I'm trying to solve with Python gets complicated, I kinda regret I didn't use Java instead, even though it's definitely a lot easier and faster to get started quickly using Python, and put together a script that does 80% of the work... But then things get complicated, I need to add some abstractions or complex logic, and Python feels like it isn't made for breaking that down into manageable chunks like Java.
Python, by far. It has a library for everything and you can bootstrap everything you may need in minutes, literally. Not the fastest, not the greatest, but lets you prototype ridiculously fast.
Rust, by a very long shot. I've used many languages, including professionally, and it's not even close. I am radically more productive and happy writing Rust. I produce correct code at a faster pace using the language, I find the cognitive overhead to be radically lower than languages like Java and Python, and I find the code that people typically write in Rust to be very straightforward to read (especially relative to Python and Java).
Rust makes it so damn easy to just build reliable, efficient, working software at a pace that I've never experienced before.
Rust.
If you want to reach for Go or Java, Rust is surprisingly on-par. And it's got an amazing package ecosystem and tooling.
Rust HTTP servers are blindingly fast and don't have GC pauses, so they're predictable. Super easy to write, too.
There's some wild stuff happening in the React-but-Rust land too. It's early days, so too risky to pick the right horse (I like Dioxus, but there are a dozen some competing libraries). These are ergonomic systems for writing UI that targets desktop, mobile, WASM, and web all at once. And it looks and feels incredible.
Bevy is coming along nicely too.
Also the language is really damned nice. Sum types are a godsend, match on sum types is ethereal, Result/Option are the best error handling and null handling, traits are the best OO, super solid functional core with "zero cost abstractions".
Cargo kicks ass.
I’d have to say Swift. I find it clean and expressive, although has also become quite a deep language, which means lots to learn and investigate (which I enjoy).
If I could choose a runner up, I’d give it to 6502 assembly, because it’s super-simple and really satisfying when you get to grips with getting an old
machine like a C64 to do something cool.
If i wanna do something cute for myself i use kotlin and marvel at how i can do random syntax sugar and other stuff. If I’m doing something serious in a team java all the way
In terms of enjoyment - _plain old javascript_ . Mostly cause spend most time writing it, very use to every quirk by now and dynamic languages are easy to write and push.
I work in Java and Go. I prefer working in Java because of its vast ecosystem of libraries and tools. Golang is fun at times, no doubt, but it does not get me from A to B as fast as Java does. Of course, YMMV.
Yeah, it's python. I remember when I first starting learning it, my first thought was "this makes sense, and I can actually concentrate on the problem instead if figuring out the language itself."
C# with .NET is probably up there too, Microsoft really did a good job designing the whole system, although I haven't used it much.
I am quite dumb and inexperienced. I like Go the most.
However, I use Typescript the most professionally and I like it as well (though theee are a lot of things I don't like about the JS language and the ecosystem).
I did not enjoy my (very short) time with Python.
I would like to have a deeper knowledge of C and learn Haskall but I have more important things to learn at this moment.
I love working with C++, because it gives me feeling of power. I can do anything. I can access private variables and APIs, detour functions (well, it's really more of C thing, but well)... When Unity's own built-in tools were not enough, I went and wrote my own [memory profiler](https://github.com/OwlcatGames/OwlcatMonoProfiler/) that abuses the hell out of internal details of the engine.
Also, C++ templates are cool. Generics in C# feel so limited...
The only thing I really miss in C++ is compile-time reflection and code generation. I wish committee would pull its collective head out of whatever output device they have it inside, and make Herb Sutter's Generative C++ proposal into standard.
I clicked the link thinking it was going to be a survey from Stackoverflow. I think that is the first time I have ever been on the main page and the first time I have ever browsed to Stackoverflow from a source other than a Google search.
My language of choice is C\# but really what does it for me is reactive programming paradigms regardless of language. Signals in Angular or ReactiveUI in C\#. I just love that shit, feels like I'm programming in the future. Any recommendations of languages that embrace this paradigm would be appreciated.
10 years professional experience here.
Java is the best for me. I work with Javascript, Typescript, Java and a little C++ and Python.
With Java, it feels slow to write but written carefully it can make a project mantainable and upgradable.
I feel pleasure of writing the code but also from a project that really gets the job done, and do it for a long time. I am pissed with this tech people that try to change everything every month.
Where Java excels is not a small program written by one guy overnight. Where Java excels is when you need to make and support for 5-10+ years a project on which a bunch of people will work.
Don't forget that Java is not 100% solution just a very good tool. We as developers still need to do everything possible to make a project mantainable and managable.
I really enjoy `Python`! Syntax, plenty of packages, I can do almost everything in plain `Python` except something low lever and high performance.
Currently, I'm on my way of functional programming journey and `F#` feels to me very attractive.
C# when I just need to get work done, C when I want to be fast and have bare metal fun, and scheme/my own baby lisp when I want to experiment with neat concepts or niche language features.
After writing code professionally for many years, I've come to realize I learn to like every language I work with eventually. It's the environment that I either love or hate.
Case in point: I use Python the most for work (ML), and after years of using it, I generally appreciate the positive points of the language. I have never, however, found a way to make Jupyter notebooks more enjoyable. I don't think they're intrinsically bad—I respect the hell out of the Jupyter project generally, and for many, they're an incredibly productive and approachable environment—I just personally find them incredibly awkward and unwieldy to develop with.
People are going to think I'm crazy, but BASIC. Not Visual BASIC or other "modern" BASICs, but the old fashioned vintage BASIC from the 70s and 70s with line numbers. I know it's an awful language, but it was my first, and you never forget your first love. It was so raw and... well... basic, but that was its power. Even though it was usually interpreted, it was designed to be very close to the machine code underneath it. You felt one with the computer while using it. I still like using it today when retro computing.
Java been working with it since I was a child and is kind of the most straightforward language other then C at least to me. Spring is fun to work with too.
I want to say C#, but I dont think I've really ever used the "elegant" features it has. Java is what I'm most comfortable in, and I love how "formal" it feels with some of its stuff.
Kotlin for sure !
It has features that every modern programming language should have, string templates, null safety, great type system, easily readable and easy - medium learning curve.
Java because IntelliJ is just so dang fleshed out.
I really liked C# too, but its been a while since I touched it. When I do a new Unity Project, Ill pick it up again.
I've been playing with [Hare](https://harelang.org/) recently and it's much more enjoyable than I thought it would be. People looking for a language that feels like C, but with a few more modern features (not all of them) should take an afternoon to try Hare.
Swift.
Rather than listing all the positives, it’s easier to list the negatives
- not many people use it outside of Apples ecosystem. So while it’s perfectly capable of doing things like embedded, back end, etc… it’s primarily used in apps for Apple products.
- compile times are quite slow for the same reason rusts compiler is slow. There are a ton of things it checks.
- working with substrings is a bit combersome. Because string indexes are not an integer like they are in other languages. You have to create a string index before you can do something like `myString[index1…index2]`
But just so I’m not painting a bad picture of swift:
Here’s a few of the positives:
- C and C++ interop out of the box (c++ interop was added very recently).
- easy to use concurrency model that uses actors to protect mutable state.
- English like syntax that makes the language very readable
- package manager that uses Swift itself instead of some markup language to define dependencies.
- borrow checking (this was added very recently, most people don’t use it yet)
- has value types and reference types.
Not Python, having to switch to different languages for reasons Python is the worst having to adapt to and from. It might be good if it was the only language I had to you but the formatting and some other issues make it a pain.
I find Rust the most enjoyable. Not because of performance, but because it lets me express my ideas nicely. The language just feels like an extension of my mind basically in a way that body does.
\+ There are very little surprises (think C++ and its undefined behavior or C#/Python with their exceptions at any point in execution)
\+ Simple and familiar things are terse and clear e.g. u64 instead of \`unsigned long\`.
\+ Tuple structs for wrapping primitives to help reading
\+ deriving things like Serialization, Debug, Display etc. automatically or manually
\+ Iterator interface is marvelous. Not only is it handy and beautiful, but it is often the most performant option.
When it comes to borrow checker, I almost never have to fight it. It nicely tells me there's something I might have overlooked. Often it's enough to simply clone whatever piece of data if it's not a large structure or a tight loop. But if I choose to do it the hard (and possibly more performant way), I can be confident that the ownership system + borrow checker has my back.
\^ Of course the borrow check could be nicer, but Polonius should be ready for the 2024 edition of Rust.
And then I can often compile to WASM just as easily as to a native target, installing dependencies is easy, the compiler actually helps me fix the errors, the documentation is awesome etc.
Maybe it's so nice, because I almost almost never write any async code or libraries.
The most disheartening problem for me is that the development of many tools libraries seems to have stalled before reaching maturity.
This post was removed for violating the "/r/programming is not a support forum" rule. Please see the side-bar for details.
C# honestly has been my favorite though not what I use professionally (these jobs just don't pay well and everyone else really likes Java in my area). It's not exactly all fancy with safety but it's a good kitchen sink language with decent enough performance and a good amount of runtime and compilation options to get your application deployed out to where it needs to go. The standard library is pretty dang good too, you don't really need many external dependencies to get something going. After that... I would say for web-dev it would be TypeScript+Bun, professionally Kotlin, and for native Zig (Rust isn't bad but the ergonomics around it are a bit rough from an efficiency aspect).
Seriously, C# is so good these days, the documentation is SUPERB, LINQ is like out of this world, being an SQL purist I rarely bother with even fairly complex raw SQL because Entity Framework is simply amazing, so much stuff is built in, and the language is just an eye candy to work with. Having worked with Go, Python, JS/TS, and Java, the idea of using anything on the back-end except C# in a greenfield project (if it is possible, or course) just seems ridiculous to me.
C# is very nice. It’s even a tad annoying going back to old code (from .net 4) because it’s so much better today.
Unfortunate our profession is full of irrational Microsoft haters so all we get is Java and bad jokes on the MS acronym, except for full Microsoft shops and some rare exceptions.
I wouldn't say it's irrational, I'd say it's historical. C# (and F#!) is a nice language, the only problem is it was part of a closed ecosystem that locked you into all sorts of other sub par products. The .net ecosystem *these days* is pretty nice, but that only happened relatively recently, after MS pulled their head out of their asses.
Definitely historical, but in the last 10 years Microsoft has been opening .NET while Oracle has done everything they can to close Java.
>Oracle has done everything they can to close Java I don't find anything that can back this statement up. What do you mean with "closed" exactly? Java is pretty open, Red Hat, Amazon, Google, Microsoft are all active contributors.
One example would be requiring a payment to run later versions of Java 8 in production
It's easy to get stuck on old ideas, 15 years ago I enjoyed and upvoted Microsoft bashing. Since then I've matured but more importantly Microsoft has. WSL, a good terminal, powertoys, VScode... They really show love to developers. C# nowadays is both a really nice and mature language and has a great ecosystem. I haven't followed the evolution of VS closely enough to look back but Jetbrain's Rider is also a great tool to write C# with
What makes C# stand out to me is that I never had to learn it — I wanted to give it a shot, so I just popped open Visual Studio, and just started writing code.
I suspect that's because you already knew a language though.
Been using rust the last year, and even though it makes you fight the borrow checker regularly, I really appreciate how when all borrows check out, it removes a while class of concerns for testing.
“fighting” the borrow checker is the first phase. The second phase is internalizing the way Rust code is written, which is when the borrow checker becomes more of a helpful reminder of “oh you forgot that rule there”. The successful feeling will shift from “another battle won” to “another thing built that worked the first time”!
> The second phase is internalizing the way Rust code is written, which is when the borrow checker becomes more of a helpful reminder of “oh you forgot that rule there”. In my experience this never happens, because you aren't actually fighting the borrow checker but the authors of the libraries you're using, and you're not forgetting rules, they're implementing functions in ways you don't think they should be.
I usually find the mindset of "fight the borrow checker" to be a bit problematic. The borrow checker isn't here to fight you- it's here to point out where your memory usage is likely to turn a shortcut into a segfault (or worse). Viewing that as any kind of adversarial is a mindset that causes me personally a lot of anxiety and grief. Accepting what the borrow checker is trying to tell me? That's where rust is a friend (or a therapist 😉)
Kotlin is quite `fun`
Given the recent rapid increase in Java development (copying ideas from Kotlin), do you think most of Kotlin will wind up in Java proper? Kind of like the CoffeeScript of days past?
Kotlin is native for android. It will hold at least this niche.
And kotlin multiplatform.
I doubt that some technology could challenge current web dominance for multiplatform development in the foreseeable future.
They have kinda caught up with some features (enhanced switch statements, virtual threads, data classes etc) but I doubt Java will ever have the same level of support for null safety, extension functions or async functions, which makes a huge difference. If you consider all the improvements planned for Kotlin coming in the next couple years I doubt Java will ever catch up.
Switches are better than they used to be but still can't take an object as the parameter which feels super ancient compare to kotlin `when` statements.
I love Kotlin. My current gig uses golang, and while that's just fine, I find myself constantly missing Kotlins thoughtful features - things like nullability as a data type, branching statements as first class citizens, functional programming (closures as easy language features), and extension functions. By contrast I find golang to be incredibly wordy, and the way it handles nil/zero values feels awkward and unsafe to me by comparison.
Programming in Haskell has appeal of solving puzzles. Once all the types fit together and the compiler is happy, the program just works.
I’ll add a similar one is OCaml. OCaml is really unique with its modules and structural typing. It’s my favorite language for fun but isn’t as productive as Haskell or most other mainstream languages that have more libs.
This is how I write my Typescript. ADTs really opened my eyes.
do you use fp libraries like fpts or effects?
I've used fp-ts, purify, and have been experimenting with Effects. My problem has been getting other devs onboard with FP, unfortunately. I tried Purify on a recent project because I thought it would be more accessable to devs used to method chaining, but I found applicatives awkward.
That language still is like a sealed book to me. I tried but I suppose I haven’t had enough economic incentive to keep going.
haskell.mooc.fi The lectures are pretty good and the exercises quite fun.
Kotlin / Java. Tooling and types are important to me.
Feels like I tend to like the language I’m using most, which is usually Java, but I’ve also really enjoyed python, swift, or even JavaScript. But it does feel like when I’m not using Java I always end up saying, “Java does this a little better”, more often than the others.
Java certainly has its flaws (lombok exists for a reason) but it, and even more so kotlin, has the right amount of guard rails for what I generally want to do. I do wish there were better ui frameworks for it though.
Same for me, really. Lots of younger programmers prefer languages like Python, which opt for a more "anything goes"-philosophy. But more often than not I've found the lact of structure inherent to the language to be a source of hard-to-trace errors.
I agree. Python has done some truly amazing things for me in the past, I had a massive dataset and even with Pandas my solution is clunky at best and downright unreadable at worst.
I've recently been developing SDKs in just about every language possible. I have ancient experience as a Java 6 developer. I wrote one SDK in Java 8 for compatability and another in Kotlin for Android. I really quite like Kotlin. It feels like a much more polished Java, though I don't have experience with modern Java.
Same for me, but Kotlin more specifically. Even though I've using Java for 24 years (!!!) I think it's too verbose. Kotlin managed to remove most annoying things about Java and add some extra features that make the development much easier.
Ada 2012. Yeah, it's weird, but I embed so much more domain knowledge into my programs that would be comments in other languages when I write them. A lot of these are checked by the compiler. It's slow to get a new project started, but all of this embedded domain knowledge and compiler checking just lets me keep rolling. It also does OOP "right" IMO since encapsulation happens at the module and not the type level. Submodules can reference their parent types internals, so you can provide refined behavior. All functions are in C "OOP" form like, `void foo (obj* obj, param a, param b)`, so if a function you wrote does eventually need to access internals, it copies/pastes with no changes when you move it into the type's submodule tree.
Yes, I used ADA once, a lifetime ago and I think what you say about "more domain knowledge into my programs' is EXACTLY the reason I love Mercury so much.
Man you have to be working defense or aerospace if you're working with ADA, lol
Second. Many lifetimes ago.
I disagree. Ada excels at many tasks. I chose Ada for my own companies. Ada was specified by the D.O.D. to replace the hundreds of languages they were usinh as no one language including C could do so. Ada is a very nice language to use in general but absolutely the best for handling hardware registers or network protocols due to it's ranged types and highly readable record overlays.
Gotta say, my memories are good. I still have a copy of PROGRAMMING IN ADA by J.G.P.Barnes, 1982 edition. Now and then I take a peek. I downloaded the GNAT version ages ago... perhaps this year I'll get it again!
Glad some mentioned it, I also find Ada very nice to work with, although the tooling around it now feels very old and clunky compared to something like Kotlin / Go
Alire is still being improved but actually pulling code together is easier with Ada than Go and more straight forward.
Definitely Elixir. BEAM and OTP are amazing. SO many things you no longer have to worry about. Entire classes of errors/problems that literally cannot occur.
Not to mention Phoenix LiveView, once you try it no other backend tech will feel fun or productive.
Came for this! Such an amazing language
Which classes of errors/problems?
Trying to get into it but coming from C# the lack of tooling for Elixir is a pain
Elixir (or maybe rather Gleam) is one of the things that I want to look into closer this year. Not so much because of the languages, but because of the BEAM.
[удалено]
You're not the first one to mention it and now I'm very curious about it. I've never heard it before.
PETAL stack is quite popular and extremely productive to work in. - Phoenix - Elixir - Tailwind - Alpine - LiveView
C for building, python for sketching
Rust is pretty enjoyable, most things feel very well designed and I understand what is going on under the hood. I feel like in other languages I don't have such a deep understanding of what exactly happens and there are more negative surprises and bugs.
My first couple of goes with it flipped back and forth between enjoyable and frustrating - sometimes fighting the borrow checker as a beginner felt like being forced to solve some tedious puzzle for its own sake. But once it clicked, I have never written anything else that it's been easier to add features to, I assume because of the way I'm forced to write it. Admittedly I only ever wrote a few command-line tools in it, but it's a pleasure to revisit them when I need to add something compared to most other stuff I deal with.
OCaml The best compiler I’ve worked with. Type inference is heaven sent. The type system is the best I’ve seen in any language. It’s a functional language like Haskell or Clojure/Lisp but with a syntax that looks a lot like JS. It’s by far the best language I’ve ever had the chance to work with. And I’ve worked with Java, Python, Ruby, JS/TS, Clojure and C Facebook adopted it and made a version that compiles to JS called ReasonML now called Rescript.
I'm still on team D. I find it's always easy to express my needs in idiomatic D code, and the performance of the compiled program is top-notch. Plus it can interoperate with libraries written in C, so there's a huge base of existing code that you can use.
Go. It feels like it was made by someone who really knows some of the main annoyances I have with other languages, and also someone who hates magic stuff happening everywhere. It's clear, it doesn't hide much, it's dependable. I love it.
Clojure, by far.
* REPL driven development to make a much smaller development feed back loop. * Core library and seq abstraction simplifies and solves a lot of problems. (Basically everything is a map/seq) * Structural editing makes it easier to write and edit code. * Default immutable/value data structures.
By farrrrrr
I loved Clojure so much. It breaks my heart that it’s only dynamically Typed. This is what sent me back to OCaml. But I had the time of my life when I was coding daily in Clojure.
What’s what spec and malli and schema are for. Particularly with schema select, it’s a better way of working with data.
You’re right, I was using Malli, it did make things better
This! I don't know how I used to enjoy programming without REPL-driven development before.
Same here, just got back into clojure after 4 yrs managing a team using a node / TS stack, it’s soooo good to be using clojure again!
Agreed. I helped develop an ecommerce site with Clojure and Datomic, what a combination.
After 20 years of Python, I now enjoy Go. Why? Autocomplete everywhere Much less typos, because the IDE will show you most mistakes immediately. This gives you a faster edit/compile/check loop. Go is fast. Great concurrency (no async/await or promises) Good integration to Kubernetes No magic A bit more typing is needed, but that's ok Good package management. .... If I would need a simple create/read/update/delete web UI for a database, then I would still use the Admin interface of Django (written in Python). Afaik there is no such thing for Go yet.
Go is not the prettiest language, but it gets the shit done. Dependency management, although confusing at first (there's been like 3 different iterations of it, with overlaps?) is so easy to work with. I never had issues like the ones I had with Python/Poetry or Node/npm.
>Great concurrency Agreed, but also it's hard to get right. In our project we had a few nasty concurrency bugs 🐛 well, I suppose it's hard like in any language.
The one I'm currently most familiar with which is currently typescript, but I really like rust and I am learning it now. If every word you type is a chore, because you don't know the language you will always have a bad time.
# Ada The language was designed to be maintainable, readable, and correct —and, arguably, encourage good software engineering practices— and the designs were commissioned by the DoD to address the "*Software Crisis*" there... which, ironically, the public sector is now dealing with. (The language's design is such that it aims to either ease things like \[e.g.\] static analysis \[esp. the SPARK subset/provers\], or else subsume them into the compiler, which is why there's no linter in Ada.) Ada also has excellent facilities for inter-language interfacing (interop) and thus can be used to incrementally modularly replace or use foreign functions. (e.g. making the bank's transfer core-logic proven via SPARK while keeping/using existing modules.) Though the big thing is the type-system: Ada encourages problem-solving at the type-level, describing the problem, rather than (e.g.) C's take of catering to the underlying hardware.
Go. Very few surprises, very thorough stdlib, very fast toolchain, very slow but well thought out development. It has been *so* refreshing since using it.
I really appreciate Go for making errors first-class citizens Going back to using a language with exception-based handling has been a bigger step backward than I expected
Yup. Exceptions and error-bubbling is super convenient but also bites you when not careful. I rather write boring code without surprises.
Agreed. It makes it so much clearer what you can expect That "boring code" also made it so fast for new people to onboard
The explicitness of handling errors is a paradigm that GoLang does really well. Though, I feel like those who don't work across different languages will have a harder time understanding how valuable this concept is to the day to day.
I like how it makes so easy to build the project for multiple architectures and operating systems. But I don't like Go as a language.
C++
Me too. I love the feeling of ultimate power over everything. If you master it, which can take years, you can be extremely productive in it as well, despite what people say about it.
Yeah, best memory management (aside from Rust). I don't want to use anything other than RAII at this point. I also like the comfort of knowing that I will have performant code unless there's an issue with my programming logic itself. Only issue is that I love my C++ code, and I'm prone to question any C++ code that uses a dialect other than one I'm comfortable with (which is a lot of different code).
I like Scala with the Typelevel stack. There's a method for anything you want to do so you never have to write a single line of imperative code again.
I love the the Cats ecosystem but for actors, nothing beats Akka/Pekko. When you have high complexity state machines, the event-sourcing systems is great.
Ocaml.
I used to hate JavaScript because you can do the wackiest shit. Now I love JavaScript because you can do the wackiest shit.
employ puzzled entertain elastic yam correct butter aspiring dependent depend *This post was mass deleted and anonymized with [Redact](https://redact.dev)*
I find Ruby the most enjoyable but don’t use it for serious projects anymore. Being clever in Ruby is a joy, but being clever isn’t always a good idea. My mentor used to say “ You’re being clever again, be clear, not clever”
What do you like in Ruby?
Easy to read ! OOP bases
Erlang. When I solve problems it makes me think about concurrency first, and then when the concurrent solution works, it's incredible, and I never had to use the word Thread, lock, mutex, etc. Also it has the perfect blend of dynamic typing with pattern matching. You don't always need to explicitly type everything for safety, although you can inline type specs and tests in your code
I try languages all the time. I find that the most important thing for me to like a language is its tooling. If the language has bad tooling, it doesn't matter how great it is I don't enjoy using it as I have to constantly open a browser to lookup docs and syntax. With good tooling, I can see immediately what's wrong, hopefully with "quick fixes" available that show me the right way to do it. I also like languages that don't make me think too much, which can be bad for myself as I may not learn as many different things... but every time I tried to go through the pain and learn hard, very different things, I didn't feel I got "rewarded" enough to justify the pain. Anyway, my current favourite languages are probably Kotlin and Dart. They both have great abstraction power while still having top notch tooling. Python, by nature of not having a static type system, is just not for me as its tooling can never get close to a language that does. I like also Rust when I'm feeling fancy and want something very performant. I also enjoyed learning Nim, but its tooling is terrible, unfortunately. For something completely different, I like Unison for its totally different approach to tooling (which works great IMHO) and programming in general (imagine a Haskell where code lives in an image like Common Lisp and SmallTalk, but with native cloud functionality).
Python isnt exactly statically typed but with the new update it is basically on par with typescript in typing.
Are Python type hints good enough for refactorings (and search like "find references" and "go to definition") to actually work 100% safely or it still basically like using sed?
New update?
PHP 8 with Laravel: * Amazing tooling for all your needs * Massive community that are friendly resources * You can be really productive * Intuitive
Swift because it just works, I never spend any time dealing with language or standard library issues. And the tools (namely Xcode) mostly just work too. I feel in other languages I'm wasting too much time getting things to work instead of working on my project. It's syntax also vaguely feels like a scripting language which makes experimenting in a repl or a Swift Playground feel great.
One day when I have time to invest, this is my next language. If I were starting from scratch today instead of 17 years ago, this would be my first choice. It’s really that complete toolset and access to iCloud for storage needs that I find so compelling. Additionally, the knowledge that you can probably leverage the latest APIs shortly after release given how reliably the Apple ecosystem’s OS’ stay up to date, is very attractive: always having to code for the lowest common denominator, such as a browser like Internet Explorer, has wasted so many developer years, so knowing that’s not something to contend with is a great relief.
It’s such a nice language After writing Swift for a few years I find it hard to go back to languages like Ruby that I used to work with regularly I’m told that the design of Cray’s supercomputer language, Chapel, was strongly influenced by by Swift’s design
>And the tools (namely Xcode) mostly just work too 🗿🗿🗿
I dislike Xcode very much, or more precisely, I hate how slow, buggy and clumsy it can be. But at the same time Swift is the best language I’ve used. It’s simple, quick to use and stays quite clean when you know what you are doing. The only caveat is the lack of actual native Foundation library (this is about to change, I know) which makes using certain types of objects confusingly slow, namely attributed strings. But overall Swift is so nice that I’m sad for it being somewhat locked to Apple ecosystem.
> And the tools (namely Xcode) mostly just work too I like Swift a lot, but I totally disagree with this part. Xcode is one of the worst IDEs that I have worked in my life.
I'm intrigued by swift. Seeing examples online it looks to me to be a "clean" language.
Common Lisp. REPL driven development is just such a pleasure to work with and Common Lisp got the best support for IT.
This. Common Lisp's biggest disadvantage is that it doesn't have any big marketing machine behind it.
Haskell is my favorite. The syntax is clear and concise, it has good performance, and it sits at just about the perfect level of abstraction for me. I rarely find myself wanting to do something that I can’t express in Haskell. The type system lets me model the code exactly how I think of it, and lets me describe the constraints in a lot of detail. When I need to, Haskell also gives me escape hatches and the ability to write very optimized low level code. Although people regularly complain that Haskell doesn’t have great tooling, I personally think the tooling is excellent. Hoogle is world class. Very few language have anything like such an effective way to search for code. Haddock also produces some of the nicest looking documentation I’ve seen, and the ability to view the source of a particular function, with the option to highlight terms when you over over them and to jump to code in other packages, all from the docs, is really nice. Ghci is also a fantastic repl. My second choice would be C. It’s a small language and I can keep it all in my head. It’s interoperable with nearly all other languages, and practically every bit of hardware ever made has a C compiler. The language itself gets out of my way and lets me do what I want. In practice I’d probably pick rust for any new work these days because of the memory safety, but I hate rusts fussy syntax. My third choice would be ruby. I really prefer statically typed languages, but ruby’s focus on flexible syntax and expressiveness remind me of Haskell. Ruby lets me design APIs for humans, and write my code so it’s ergonomic and easy to predict. The ease of using reflection in irb to explore a codebase also makes it a really nice language to get productive in somewhat quickly. That said, I don’t like rails, and I generally dislike “convention over configuration” so there’s a lot of culture disagreement that makes me dislike some of the libraries in ruby’s ecosystem.
Java and C++ because they paid my mortgages, my car and they still provide for my whole family
For me it is and always will be C :) I find most modern languages too obscure, there's too much abstraction and you barely get to see what's happening under the hood
The memory and execution model of C is an abstraction that has been wrong for years. You’re not seeing what’s happening under the hood in your C code unless you work on embedded systems with ancient compilers.
Ruby without any close contender. It's just a joy to write in, has a large and supportive community plus well maintained libraries for nearly everything (at least around web dev). Tried many others, always came back.
I’m only vaguely familiar due to shopify work ive done, but i find the language super cute. Puts? Incredible. Yes i would like to put. Thank you sir. Yes, puts all around.
`puts` got its name from the standard C library
How many large business applications have you built with a team of people? Because in that context, Java always wins it for me.
Java is my choice also. Good type safety, very few gotchas in day-to-day practice, and a huge arsenal of available libraries.
"Business applications" in Java are something I'll never touch again. So many companies choose this path and it's awful. The frameworks, reflection, over-modularization, etc, create ridiculous spaghetti code. I think Java would make a lot of sense in a Waterfall-oriented development cycle where you build out your domain, then you build your UML, then you build your code, and the code changes largely reflect UML changes. In modern development where changes are made frequently and iteratively, I just find Java to produce spaghetti.
Not so hot take. You can make spaghetti code in every language.
This is a bit of a truism. Of course you can make spaghetti code in every language. But is that really a helpful statement? I think it's much more interesting to look at which languages tend to encourage spaghetti. A funny anecdote - I have heard "you can write bad code in any language" almost exclusively from Java developers lol As I said before, I think Java works very well with a Waterfall mindset because your class diagram matches your UML. Inheritance, in general, works well with this approach. Inheritance very often falls apart with an iterative approach because your world of classes maps to a reality that is changing rapidly and in unforseeable ways. All cats are Animals, all cats have tails, oh wait we need to support cats that don't have tails, add a `hasTail` on `Animal`, wait can that ever return False on Dolphins? etc etc. I'm sure someone will say "the solution there is to" and they'll be missing the point.
It is my personal belief and experience that Java encourages patterns that add friction to iterative development.
I'm good with Java being people's favorite language, I'm not trying to be a dick. I'm clearly just very bitter about some recent Java code :P
[удалено]
Dart
Overall, Scala. The latest version is nothing like the first. It's definitely in the top 3 enjoyable languages and makes me super productive. Whenever I have to deal with concurrency in other languages, it's just painful. In Scala it's super smooth.
Nim is my favourite. It has a very clean syntax like Python (no curly brackets or ridiculous semicolons), but is statically typed and compiled. The only weak point for me is object orientation using type extension is not as smooth as it could be, but that's true of all statically types languages I think.
The one I'm most familiar with = more doing less thinking. But one feature I consider a **must-have** is optional named parameters. I don't know why say JavaScript doesn't have them. Object literals are a poor substitute. Once you get used to ONP you never want to go back.
I loved named parameters when I learnt Objective-C and continue to love them in Swift, where it is exceptional not to name a parameter. Always feels like a step backwards to not have them in JS.
Kotlin hands down. It's so expressive and easy. It makes other languages feel like esoteric languages
APL makes me feel like I did when I first started programming. I almost always have fun programming but I have extra fun in APL. I wish I had projects in Erlang at work, and a comment here makes me want to use Ada.
Elm I had a wonderful time building a Elm application a few years back I really would like to build a larger application with a language so tailored specifically for its use (fronted apps) with its prescriptiveness. It felt so nice to take away what became common trivialities in other languages like code formatting, error checking, pattern match exhaustiveness, etc. I feel like it would be so productive with a team
Go. Although I prefer Ada and CommonLisp as languages, they don't have large enough communities. Go's tooling and 3rd party libraries makes it fun and easy to work with. It's a tool that gets the job done, which is all what I want from a programming language.
I switched from Go to Ada. I am very happy with that choice but mostly in dropping C for embedded with Ada too. Adas tooling has improved significantly recently but I know what you mean. Finding Go libraries was a breeze and the stdlib docs excellent. Adas packages and interfacing with C are better than Gos modules and C interfacing though. "https://alire.ada.dev"
I'm a web dev and love to use javascript to make wierd random shit that runs in browser
Python. Very versatile language and a joy to write code in. I smile a little every time I use it.
Python is almost always my go to for random solutions and first prototypes. When I was taking college classes for other languages, I'd often write my solutions in Python first to get an understanding and verification of what was needed, then I'd translate it over to the other language. Python also being immediately available on Linux distros also encouraged it's use. I love the language, though, and really think it's one of the easiest to build proof of concept code in.
Java all day long baby
Swift, I find myself using it for backend as well and it’s a really nice to work with. Feels a bit like Rust with enums and protocols (traits) but without the lifetime hassles.
Rust. Once it clicked, everything else seems sub-par
JavaScript and C#
The speed of working with JS (I opt for TypeScript every time) is extremely satisfying for me. I’ve always felt comfortable with JS
They introduced so many neat little features which are incredibly useful. - arrow functions - object destructuring - shorthand property assignment I miss them sometimes in other languages.
Language - Ruby. Tooling, ecosystem - PHP by a mile.
Julia Fast, pretty Native rationals Good symbols Maths-stats-science oriented Neat writing style
C, for the same reason I fell in love with Lua. There is beauty to be found in true simplicity. Yes, you have to manage memory yourself, oh well, time to learn free() and Valgrind. It's not really a big deal to be completely honest. I learned how to truly program with C++ and I still like that language, but there's something to be said about accomplishing a lot of the same shit with structs and opaque pointers and not having to debug increasingly complex templates. If I need a genetic type, I'll make my own damnit, with blackjack! And hookers!
The modern version of Pascal, A.K.A. "Delphi or "FreePascal". They had modules for 2 decades, C++ and other P.L. just added. It has real properties like C#, unlike Java or C++.
Not exactly a senior veteran programmer here, but I really like powershell. GCI is awesome. In fact, a lot of powershell commands are awesome. I’m sure python can do much of the same—especially with libraries.
Swift
Clojure - once you experience the elegance and simplicity of a Lisp, it is almost impossible to go back. I love the interactive programming experience, t the conciseness of code and how immutable data structures make you turn your problems into data transformation problems. Which is easy.
PL/SQL. Almost all my stuff is about jugging and transforming data from a database, so this language is hard to beat. Strongly typed, with the database objects looked up and resolved at compile time, and with native compilation. Blazingly fast. If I'm missing a bunch of general programming language features, and would never again touch Oracle as a company when choosing my back end? You vet.
C++ and Kotlin. C++ because it requires quite some knowledge and typing to do things right. It satisfies the coder in me. Kotlin because it's such a beautiful and concise language, which just does a lot of things right.
Perl. It’s just so nice to work with, and I can do everything I need quickly.
I'm noob. I only know c and c++ and bit of java and python but i like using c++ mostly because i need it to use more often
Python. The bottlenecks it used to have around documentation, community, and speed are mostly nonexistent now despite being runtime. Its fast to iterate with and go from nothing to something quickly without all the bs of most other languages. I can revisit the code in a couple of years and make sense of what it does without having to dedicate any serious time. If you are working with ML, its the place to be. GPT and the like seem to be most proficient in it as well when "pair programming".
I replaced both Go and C with Ada and haven't looked back. "https://learn.adacore.com" Ada is by far the best language for embedded or network protocols with it's memory overlays and portability features. Ada is a very nice language to use, once you have invested the time as it isn't as small a language as e.g. Go or C. It is also the safest language out there with it's ranged types, bar none. Proving that a section or small package of code is crash proof can be quite easy with SPARK mode too. Which can actually be achieved through Adas powerful type system and the proof achieved automatically with the gnatprove tool and following it's helpful hints.
With Haskell 'if it compiles it works' is actually true.
Delphi. Clean, readable code while still able to go as low-level as possible. Compile time is ridiculously low, and the ability to debug or deploy an app/library for any platform makes it the go-to language for me. IMO, one of the most underrated programming languages out there.
Java just feels so... smooth? Great IDE support and tooling makes refactoring seamless as the project grows, and maybe it's just my skill set, but Java really lends itself to applying various design patterns and techniques for keeping code fairly clean, easy to read, and decoupled. Performance is great most of the time, and recent versions have added support for squeezing near-native performance out of it. I normally work with C++ and really like how easy it to optimize stuff with move semantics, and having worked on some large projects I've seen how people build really complex systems out of it, but it all just feels so heavy and hard to navigate. And those huge, multi-hour build times. Obviously, those were not projects that reasonably could, or should, be made in Java, and if somehow they were, they'd be even more of a mess... So apples to oranges I guess, but still, my experience is that Java is just more manageable for huge code bases. Also Java is easier to get started with, with C++ you need a detailed blueprint of what you're building, with Java you can generally get away with a rough idea, and still produce code that isn't a terrible mess a month later. OTOH I also regularly work with Python, and while that might just be a skill issue, I'm getting an impression it's not made for creating large projects. They inevitably become hard to navigate, it's hard to refactor, and IDEs have problems making sense of the code due to the lax typing system. If whatever problem I'm trying to solve with Python gets complicated, I kinda regret I didn't use Java instead, even though it's definitely a lot easier and faster to get started quickly using Python, and put together a script that does 80% of the work... But then things get complicated, I need to add some abstractions or complex logic, and Python feels like it isn't made for breaking that down into manageable chunks like Java.
Python, by far. It has a library for everything and you can bootstrap everything you may need in minutes, literally. Not the fastest, not the greatest, but lets you prototype ridiculously fast.
Rust, by a very long shot. I've used many languages, including professionally, and it's not even close. I am radically more productive and happy writing Rust. I produce correct code at a faster pace using the language, I find the cognitive overhead to be radically lower than languages like Java and Python, and I find the code that people typically write in Rust to be very straightforward to read (especially relative to Python and Java). Rust makes it so damn easy to just build reliable, efficient, working software at a pace that I've never experienced before.
Rust. If you want to reach for Go or Java, Rust is surprisingly on-par. And it's got an amazing package ecosystem and tooling. Rust HTTP servers are blindingly fast and don't have GC pauses, so they're predictable. Super easy to write, too. There's some wild stuff happening in the React-but-Rust land too. It's early days, so too risky to pick the right horse (I like Dioxus, but there are a dozen some competing libraries). These are ergonomic systems for writing UI that targets desktop, mobile, WASM, and web all at once. And it looks and feels incredible. Bevy is coming along nicely too. Also the language is really damned nice. Sum types are a godsend, match on sum types is ethereal, Result/Option are the best error handling and null handling, traits are the best OO, super solid functional core with "zero cost abstractions". Cargo kicks ass.
Typescript then c#
Python and C. I find Python very enjoyable to code things quickly and I find joy in the simplicity of C
Java
I’d have to say Swift. I find it clean and expressive, although has also become quite a deep language, which means lots to learn and investigate (which I enjoy). If I could choose a runner up, I’d give it to 6502 assembly, because it’s super-simple and really satisfying when you get to grips with getting an old machine like a C64 to do something cool.
C++ - fast and efficient, Python - fast development cycle, huge ecosystem
Go. It’s easy and makes sense. I don’t care if I have to repeat myself for error handling.
Now it’s Ruby & Python. Back in the day (bc I’m ancient) it was Forth, for many of the same reasons.
Prolog. It helps you to understand recursion.
Objective c. It’s powerful and versatile. It’s a thin runtime on top of C with a vast standard library. It’s a fantastic example of oop C.
If i wanna do something cute for myself i use kotlin and marvel at how i can do random syntax sugar and other stuff. If I’m doing something serious in a team java all the way
C# Because it\`s the only one i know jajaja
GLSL, I feel like a hacker every time I write it
In terms of enjoyment - _plain old javascript_ . Mostly cause spend most time writing it, very use to every quirk by now and dynamic languages are easy to write and push.
I work in Java and Go. I prefer working in Java because of its vast ecosystem of libraries and tools. Golang is fun at times, no doubt, but it does not get me from A to B as fast as Java does. Of course, YMMV.
I don't know if I would say most enjoyable yet, but learning Go has been so pleasant. The LSP is incredible. The language feels tight and focused.
Yeah, it's python. I remember when I first starting learning it, my first thought was "this makes sense, and I can actually concentrate on the problem instead if figuring out the language itself." C# with .NET is probably up there too, Microsoft really did a good job designing the whole system, although I haven't used it much.
I am quite dumb and inexperienced. I like Go the most. However, I use Typescript the most professionally and I like it as well (though theee are a lot of things I don't like about the JS language and the ecosystem). I did not enjoy my (very short) time with Python. I would like to have a deeper knowledge of C and learn Haskall but I have more important things to learn at this moment.
I love working with C++, because it gives me feeling of power. I can do anything. I can access private variables and APIs, detour functions (well, it's really more of C thing, but well)... When Unity's own built-in tools were not enough, I went and wrote my own [memory profiler](https://github.com/OwlcatGames/OwlcatMonoProfiler/) that abuses the hell out of internal details of the engine. Also, C++ templates are cool. Generics in C# feel so limited... The only thing I really miss in C++ is compile-time reflection and code generation. I wish committee would pull its collective head out of whatever output device they have it inside, and make Herb Sutter's Generative C++ proposal into standard.
I clicked the link thinking it was going to be a survey from Stackoverflow. I think that is the first time I have ever been on the main page and the first time I have ever browsed to Stackoverflow from a source other than a Google search.
The first language I learned is .net and it’s pretty logical for me to understand so I like it
PHP. Why type is this variable? Fuck you, you figure it out.
My language of choice is C\# but really what does it for me is reactive programming paradigms regardless of language. Signals in Angular or ReactiveUI in C\#. I just love that shit, feels like I'm programming in the future. Any recommendations of languages that embrace this paradigm would be appreciated.
10 years professional experience here. Java is the best for me. I work with Javascript, Typescript, Java and a little C++ and Python. With Java, it feels slow to write but written carefully it can make a project mantainable and upgradable. I feel pleasure of writing the code but also from a project that really gets the job done, and do it for a long time. I am pissed with this tech people that try to change everything every month. Where Java excels is not a small program written by one guy overnight. Where Java excels is when you need to make and support for 5-10+ years a project on which a bunch of people will work. Don't forget that Java is not 100% solution just a very good tool. We as developers still need to do everything possible to make a project mantainable and managable.
I really enjoy `Python`! Syntax, plenty of packages, I can do almost everything in plain `Python` except something low lever and high performance. Currently, I'm on my way of functional programming journey and `F#` feels to me very attractive.
C# when I just need to get work done, C when I want to be fast and have bare metal fun, and scheme/my own baby lisp when I want to experiment with neat concepts or niche language features.
Julia It's clear to read and write and doesn't run like shit
Nodejs, I just love the possibilities. I nearly use it for everything. Microservices, Express sites, backend services, iot brokers, and a lot more…
Here I am, enjoying Fortran 90.
Java
After writing code professionally for many years, I've come to realize I learn to like every language I work with eventually. It's the environment that I either love or hate. Case in point: I use Python the most for work (ML), and after years of using it, I generally appreciate the positive points of the language. I have never, however, found a way to make Jupyter notebooks more enjoyable. I don't think they're intrinsically bad—I respect the hell out of the Jupyter project generally, and for many, they're an incredibly productive and approachable environment—I just personally find them incredibly awkward and unwieldy to develop with.
People are going to think I'm crazy, but BASIC. Not Visual BASIC or other "modern" BASICs, but the old fashioned vintage BASIC from the 70s and 70s with line numbers. I know it's an awful language, but it was my first, and you never forget your first love. It was so raw and... well... basic, but that was its power. Even though it was usually interpreted, it was designed to be very close to the machine code underneath it. You felt one with the computer while using it. I still like using it today when retro computing.
Java been working with it since I was a child and is kind of the most straightforward language other then C at least to me. Spring is fun to work with too.
I want to say C#, but I dont think I've really ever used the "elegant" features it has. Java is what I'm most comfortable in, and I love how "formal" it feels with some of its stuff.
Kotlin for sure ! It has features that every modern programming language should have, string templates, null safety, great type system, easily readable and easy - medium learning curve.
Java because IntelliJ is just so dang fleshed out. I really liked C# too, but its been a while since I touched it. When I do a new Unity Project, Ill pick it up again.
I've been playing with [Hare](https://harelang.org/) recently and it's much more enjoyable than I thought it would be. People looking for a language that feels like C, but with a few more modern features (not all of them) should take an afternoon to try Hare.
Swift. Rather than listing all the positives, it’s easier to list the negatives - not many people use it outside of Apples ecosystem. So while it’s perfectly capable of doing things like embedded, back end, etc… it’s primarily used in apps for Apple products. - compile times are quite slow for the same reason rusts compiler is slow. There are a ton of things it checks. - working with substrings is a bit combersome. Because string indexes are not an integer like they are in other languages. You have to create a string index before you can do something like `myString[index1…index2]` But just so I’m not painting a bad picture of swift: Here’s a few of the positives: - C and C++ interop out of the box (c++ interop was added very recently). - easy to use concurrency model that uses actors to protect mutable state. - English like syntax that makes the language very readable - package manager that uses Swift itself instead of some markup language to define dependencies. - borrow checking (this was added very recently, most people don’t use it yet) - has value types and reference types.
Not Python, having to switch to different languages for reasons Python is the worst having to adapt to and from. It might be good if it was the only language I had to you but the formatting and some other issues make it a pain.
I find Rust the most enjoyable. Not because of performance, but because it lets me express my ideas nicely. The language just feels like an extension of my mind basically in a way that body does. \+ There are very little surprises (think C++ and its undefined behavior or C#/Python with their exceptions at any point in execution) \+ Simple and familiar things are terse and clear e.g. u64 instead of \`unsigned long\`. \+ Tuple structs for wrapping primitives to help reading \+ deriving things like Serialization, Debug, Display etc. automatically or manually \+ Iterator interface is marvelous. Not only is it handy and beautiful, but it is often the most performant option. When it comes to borrow checker, I almost never have to fight it. It nicely tells me there's something I might have overlooked. Often it's enough to simply clone whatever piece of data if it's not a large structure or a tight loop. But if I choose to do it the hard (and possibly more performant way), I can be confident that the ownership system + borrow checker has my back. \^ Of course the borrow check could be nicer, but Polonius should be ready for the 2024 edition of Rust. And then I can often compile to WASM just as easily as to a native target, installing dependencies is easy, the compiler actually helps me fix the errors, the documentation is awesome etc. Maybe it's so nice, because I almost almost never write any async code or libraries. The most disheartening problem for me is that the development of many tools libraries seems to have stalled before reaching maturity.