• @[email protected]
        link
        fedilink
        2
        edit-2
        2 years ago

        By versatility, I’m also including the ecosystem. Julia doesn’t seem to be anywhere near python on that.

        However, I’ve heard good things, it’s on my to-do list.

  • Lambda
    link
    fedilink
    English
    32 years ago

    After years, and many languages, I still have to say Ada. Kotlin, Rust, Julia, and Nim are my current contenders to overtake, but here’s what Ada does well enough to still be my preferred tool when appropriate:

    • strictness: typically my code works the first time it successfully compiles with few or no bugs. Rust is almost on par in this respect.
    • structure: a corollary of the above is that it forces me to “plan ahead” more than just “start coding” which I find fits my programming style better, and leads to better “Unix Philosophy” product designs. I haven’t found any other language that has the same effect other than maybe Haskell.
    • speed: I honestly find that Ada code outperforms C/C++ code most of the time. The only times C/C++ outperform Ada is after optimizations that come at the cost of readability.
    • multitasking: Ada’s first-class tasks and protected objects are the only way I’ve ever been able to write bug-free concurrent programs that are more complex than async/await and/or producer/consumer structures (and I took a dedicated elective on concurrency at university!). Kotlin is almost on par in this respect with its coroutines.
    • hardware: The fact that Ada basically ships with a hard real-time OS built-in and can compile to e.g. AVR means that all my fancy libraries I’ve written or saved work just as well for a desktop game, a website backend, or an embedded microprocessor. Just look into representation clauses and interrupt pragmas to see its unique powers.
    • design: The whole design of the language has lead it to be the only language where I can consistently return to a multiple year old passion project with no attempt to write maintainable code, and fully understand what its doing and modify it with little effort.
    • tooling: While this is the biggest downside of Ada (see below) gprbuild is still my favourite build tool. I have no idea why strongly-typed build systems aren’t more common. Its always a joy to work in gprbuild, once you get gprbuild working of course.
    • static polymorphism: Ada’s generics are some of the best I’ve found. But they have some limitations that leads us into…

    There are some situation where Ada shows its age:

    • static calculation: I love Nim (and Zig, etc) for the ability to run arbitrary code at compile time. It allows me to describe what would normally be an opaquely initialized data structure or code path in a clear and descriptive manner.
    • terseness: Ada is verbose, that’s not such a big deal, but I find its just a tad too verbose which can lead to some slight difficulty when parsing code. func/proc (Nim) vs fun (Kotlin) vs fn (Rust) doesn’t make much difference to me, but function X returns Y/procedure X starts to add a lot of visual noise to a file.
    • web compilation: The ability for both Kotlin and Nim to compile to either ASM or JS is AWESOME. If I have to write a “full stack” application, Kotlin multiplatform with ktor every day.
    • operator overloading: Only the built-in operators can be overloaded in Ada. It always makes me wish I could overload arbitrary operators. A small thing, but a symptom of…
    • TOOLING: Ada’s tooling is BY FAR the hardest I have ever seen to get working. It takes the “eat your own dog food” too far. The fact that even in Arch Linux you have to install a bootstrap package, then the real package shows how hard it is to get a consistent build environment. ALR is helping in this respect, but is still not quite mature in my opinion.

    Here’s when I use the alternatives, and their biggest weaknesses:

    • Kotlin: anything where I want both one or more JS artifacts and one or more JVM/native artifacts. Weaknesses: performance, static analysis, on the fence about tooling (gradle is cool, but sometimes seems too over-engineered), Biggest weakness: IDE dependency, writing Kotlin outside of IntelliJ is a pain, which is somewhat fair given who maintains it!
    • Rust: so close to beating Ada, if not for two things: ugly code - so many operators and glyphs that pollute the reading experience, maybe I’ll get used to it eventually, but for now I can’t scan Rust code, nor pick up and revisit it nearly as easily as Ada; language scale - I find Rust suffers from the C++ design attitude of “we can add this as a language feature” it takes too much mental effort to hold the entire design of the language in your head, which you sort-of have to do to develop software. Java and C are IMHO the undisputed kings in this respect. After reading through the specifications of both languages, neither will ever have any surprises in store for you. There’s no magic under the hood or special case. All the cool features are done by libraries and rely on the same simple syntax. Every time I learn a new cool thing Rust can do, its at the expense of another edge case in the compiler that modifies my conceptual model of the code.
    • Julia: multiple dispatch and mathematics plus clean module design and easy unicode incorporation leads to clean code for math-y/science-y code.
    • Nim: templates and macros are excellent, concept system gives access to Rust-style traits without all of the additional “ugliness” of Rust, excellent performance, tiny executables. I just find that the syntax can get clunky. The UFCS easily cleans up a lot of the mess that Rust creates with its added features, since it keeps the parsing the same even when using some fancy language feature.

    Thank you for attending my TED talk :P. Any questions?

  • Jeena
    link
    fedilink
    32 years ago

    Haskel, It’s kind of hard to do some stuff which are easy in other languages but if you find a good problem to solve with it, it’s amazing how expressive you can be and how short your code gets compared to all the boilerplate code you have to write with other languages.

  • Christopher Masto
    link
    fedilink
    22 years ago

    I’ve never been happier and more productive than when I was working in Perl. It’s a language that, at its apex, had a community of incredibly smart and creative people evolving it and its ecosystem. It’s a practical, powerful, multi-paradigm language that let me get work done with a minimum of fuss.

    Perl was a language that felt like an extension of my thoughts, like it was working with me and for me. Most other languages feel like I am working for the compiler rather than the other way around. Or at the very least, spending unnecessary effort satisfying some language designer’s personal pet peeve, which constantly takes me out of the flow of the job I’m trying to do.

  • M-Reimer
    link
    fedilink
    2
    edit-2
    2 years ago

    Python. Works for nearly everything I need. I mostly write small helper tools (most of them shared under a FOSS license) and for my job, I developed a backend API server which sits behind a web application. I also use Python for scientific math stuff as nearly every Matlab also exists for Python.

    I did use Perl a lot before but in my opinion Python took over the role of Perl. I loved Perl for having a module for just about everything but nowadays most Perl modules are unmaintained and you find the “good stuff” for Python.

  • @[email protected]
    link
    fedilink
    22 years ago

    Python

    It’s real easy to just launch it and get a script going, no need to wait for and ide or a compiler, there’s alot of nice modules, and it’s really API friendly

    I’ve spent more time in the blender python API than I’d like to admit

    • @[email protected]
      link
      fedilink
      English
      02 years ago

      I had to use Python for a bit at work and it was confusing

      pipenv, venv, virtualenv, poetry…wtf is all this shit

      a.b vs a['b'] vs a.get('b')…wtf is a KeyError

      • richieadler 🇦🇷
        link
        fedilink
        English
        12 years ago

        What happens in other languages you use when you try to access a non-existing key for a hash/map/dict?

        What language do you use that accessing an object attribute is the same that accessing a dict key?

        What knowledge do you have (or not) that KeyError is a mistery to you?

        • @[email protected]
          link
          fedilink
          English
          02 years ago

          Return undefined.

          Typescript.

          Why error? Just return undefined. Simple, no try/catch needed.

          • richieadler 🇦🇷
            link
            fedilink
            English
            02 years ago

            Because that’s prone to errors. And the Zen of Python includes “explicit is better than implicit” and “Errors should never pass silently”. Languages that do otherwise create bad habits.

            • @[email protected]
              link
              fedilink
              English
              02 years ago

              Is it? It’s just an optional property. And Typescript will tell you that it’s optional.

  • darcy
    link
    fedilink
    12 years ago

    rust thank you for asking

    crab army attack! 🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀🦀

      • @[email protected]
        link
        fedilink
        22 years ago

        I think the stuff with the foundation is kinda overblown by the Internet drama machine. That’s not to say they haven’t made mistakes, but hopefully the leadership council will fix things up.

        Plus, Rust has come into widespread use, so it’ll be very hard to kill.

        • @[email protected]
          link
          fedilink
          12 years ago

          Ah, I do not think it’s really overblown… It’s really a mistake that needs to be fixed up and people screaming to let them know. That is what we should do and it is great!

          Agree by the way, its really hard to kill but i think can be killed if same mistakes happens over and over. Rust is an awesome language, I do not want foundation to overrun it. We should be talking about awesome crates, not an idiot decision made by foundation…

  • @[email protected]
    link
    fedilink
    12 years ago

    Perl. Its installed everywhere I need to run it and stuff I wrote over 20 years ago is still doing exactly what it should.

    • Atemu
      link
      fedilink
      -22 years ago

      You’ll be damned if you ever need to know what exactly you made it do 20 years ago though as Perl is a write-only language ;p

      • @[email protected]
        link
        fedilink
        02 years ago

        That’s the joke, but it’s really not true.

        You can write unintelligable code in most languages.

        Perl’s syntax is fine, and you can write beautiful code with it - but it will also let you write fugly code that works.

        I think those who say this seriously just don’t understand Perl, or even programming generally. (Whilst I like Perl, I’m also proficient in C, Java, JS, Python, PHP, Bash and probably a few more, so I’m not just promoting the only thing I know.)

  • SanguinePar
    link
    fedilink
    1
    edit-2
    2 years ago

    10 print: “Basic”
    20 goto 10

    Run

    That’s about as far as I got :-)

  • Paolo Amoroso
    link
    fedilink
    English
    12 years ago

    Lisp.

    It just feels extremely natural to me, so it’s difficult to pinpoint specific features I like. But two such features stand out: the parantheses-based syntax and the extreme interactivity.

  • Don Corleone
    link
    fedilink
    02 years ago

    Go

    It’s like C with better syntax and without memory management annoyances. It also comes with a decent standard library and making concurrent programs is a breeze. As a bonus it generates static binaries which, granted, are big but in most cases can be copied to any other Linux workstation and executed directly.

  • @[email protected]
    link
    fedilink
    02 years ago

    Go. It’s high level enough in terms of syntax that it’s easy to build complex apps in, and low level enough that I’m able to control pointers, manually run the garbage collector, and benefit from the runtime performance.

    It’s the best of python and JS.