1. 112

I worked with JavaScript for a while and I hope to never have to do that again. However, I got used to how natural that writing async code feels. Every time I go back to my language of choice I miss this.

This got me thinking that it’s so easy to find rants about different topics nowadays, and those posts usually engage people really quickly. But let’s try something different: What is something you appreciate from a programming language you don’t like?

  1.  

  2. 58

    go fmt is the kind of hero every language deserves.

    1. 3

      For those who don’t know about it: The go fmt equivalent for Java is Google Java Format.

      1. 3

        Would just like to mention Prettier here, in case anyone is writing JavaScript / TypeScript and doesn’t know about it.

        This has become such an important point for me, I almost consider languages without a tool like this unusable.

        1. 7

          I think Go takes it a step further by disallowing configuration (unlike Prettier). Much like type systems eliminate a class of errors, go fmt eliminates a class of bickering.

          1. 5

            You should check out black for Python, it’s really nice and builds on the same ideals.

            1. 1

              disallowing configuration (unlike Prettier).

              That’s one reason I like Standard JS.

              1. 1

                Absolutely true, and I wish they’d just straight up remove the option. Still, I’m glad it works without configuration, and stubbornness is punished with extra dotfile clutter in your repo that is entirely on you.

            2. 1

              mix format for Elixir code. Same philosophy too, I believe. No more arguments about formatting.

            3. 37

              C: For all of its imperfections and sharp edges, I feel like C is small enough to not get in the way while I’m figuring out a problem.

              C++: Templates let me skip a lot of the boilerplate I’d use while still giving me some type system that’s better than C.

              Ruby: The syntax is just super comfy and the standard library always has whatever I’m reaching for.

              Javascript: This language makes it super easy to rapidly bang together things and switch from functional to imperative to OOP paradigms as it is convenient for a problem.

              Rust: The webassembly story is neat.

              SQL: I really like how good this is for business queries and how it’s always there for me.

              Elixir: The tooling for this language is very convenient.

              Go: The standard library for Go just has things that I actually care about built in.

              And yes–I don’t really like any programming languages anymore.

              1. 25

                Go: the basic idea behind defer is excellent.

                Rust: memory-safety without GC is an amazingly wonderful goal.

                Java: pioneered one of the (now) most prevalent strategies for write-once/run-everywhere (bytecode VM).

                C#: fixed a lot of boiler-plate and ergonomic problems from Java.

                Ruby: prizing developer ergonomics is lovely.

                Javascript: making programming accessible to everyone (essentially every computer ships with a fully-functional IDE) is awesome.

                C++: offering blessed, zero-cost abstractions is a lovely gift.

                Python: the idea of only having one way to accomplish a task is the dynamically-typed version of my C++ comment above.

                PHP: what would we even do without wikipedia?

                Excel: phenomenally-intuitive in a way that no other modern GUI programming has managed to rival

                1. 10

                  Java: pioneered one of the (now) most prevalent strategies for write-once/run-everywhere (bytecode VM).

                  I enjoyed your list. Except this was popularized by UCSD Pascal which you might find interesting. I think Wirth said this design got Pascal ported to over 70+ architectures in 2 years with diversity ranging from 8-bit personals to odd-sized mainframes. System/38, later AS/400, also had platform-neutral code it compiled to to make it future-proof. See this for it among others.

                  1. 2

                    Python: the idea of only having one way to accomplish a task is the dynamically-typed version of my C++ comment above.

                    I truly enjoyed this idea of Python 20 years ago.

                  2. 22

                    Java: it sets the standard for IDE support

                    1. 18

                      Java: Checked exceptions are a good idea, I’m so sorry everyone hates them in the only language that used them. Also, with Guava + Java 8, you can write pretty nice code. Won’t win on raw efficiency, but beats a lot of dynlangs handily. Primary use-case for the JVM, which is a delightful little VM for people to also write Kotlin, Scala, Clojure…

                      Python: All my Python complaints are contextual: it’s best-in-class for writing quick, readable, versatile code. One of the better communities for their scale.

                      Go: Prioritizing quick compile times and gofmt show a commitment to developer happiness that other languages would do well to emulate.

                      JavaScript: I love how all the data is more-or-less transparent, you can inspect any object and its properties, easy to printline-inspect/debug. Browser tools are some of the best the world has ever produced, available to everyone. One of the better “maps and objects are the same!!!” implementations (thinking of Python object slots, and/or some issues I ran into when trying to work with Lua).

                      This was a cute exercise, thank you! 😄

                      1. 3

                        Checked exceptions are a good idea, I’m so sorry everyone hates them in the only language that used them.

                        I sort of feel that algebraic effect will end up similar to checked exceptions (basically tracking effects like exceptions in the type system) hopefully without the annoyance that Java’s checked exceptions brought. Best of both worlds.

                        1. 6

                          I think the core failure of checked exceptions were that you couldn’t really do anything useful with the “list of checked exceptions potentially thrown” that the language gave to you.

                          One couldn’t really write a function that accepted a function with various checked exceptions, handle a specific exception, and receive a function back with the checked exceptions minus the one just handled.

                          In the end I think exceptions (regardless of checked or unchecked) are rather unnecessary – just use types.

                          1. 4

                            Checked exceptions are a use of types. I think the reason they get unweildy is people want to treat then like unchecked exceptions. If you have a long list of throws in your method signature then you are doing it wrong. Checked exceptions should be handled close to where they are thrown. You may want to wrap them in a new exception, but you probably don’t want to carry them all the way up. That is what an unchecked exception is for. I do think a better time system makes checked exceptions unnecessary.

                            1. 2

                              The big usability failure of Java’s checked exceptions, I think, is that you are forced to handle (or explicitly declare) them exactly one stack frame away from where they are thrown, whether it makes any sense in the context of the application code or not. You probably don’t want most checked exceptions to silently bubble 20 layers up the call stack, but, say, 3 layers can make complete sense depending on what the intermediate layers are.

                              1. 3

                                I think that usability failure is because of the checked exception is being thrown at the wrong layer. Checked Exceptions should be viewed as a second return type that you are required to handle. Unchecked exceptions should be treated like a panic. This means careful consideration of exceptions in your API.

                                Where people go wrong I think is that they pretend like the exception they throw can be treated as separate from their API. This results in a lot of miscommunication and confusion. Docs hide the exceptions that get thrown from you. Some people think you should never catch an exception. Some people think you should always catch an exception. At least checked exceptions give you a way to distinguish between the exceptions you expect the caller to do something with and the exceptions that you expect the caller to ignore.

                            2. 3

                              Yes, the make or break issue I see is composability. We will see how that will play out.

                              We do use result types in OCaml at work but the problem is the composability of the type representing the failure. For once, you can’t really force all 3rd party libraries to use the same representation, thus leaving you to write wrappers to convert from the provided behaviour to that you want to have. The other issue is that even then then, how to join multiple error types from different functions is difficult. If you represent it as ADT you can’t easily join constructors A | B with C | D without defining a boilerplat-y new type. If you use open types like polymorphic variants you can easily get code that over or underestimates the set of error types and it doesn’t support shrinking the set of variants (as you mention above, a pretty important feature).

                            3. 1

                              I am reminded of the Vexing Exceptions blog post.

                              Summary: Exogenous exceptions are the reason why checked exceptions exist. Vexing exceptions are the reason why everyone hates checked exceptions.

                              Exogenous exceptions represent the messy external realities that impinge on our nice clean code. It’s good to force developers to do something somewhere about them.

                              Vexing exceptions are sort-of ridiculous use of exceptions to handle non-exceptional situations that commonly happen, especially in standard library code. It’s super annoying that there’s so much boilerplate around things that should be handled in a simpler way.

                          2. 17

                            PHP‘s deployment and resource management story is the “right way to do it” for most web apps. A single failed transaction cannot bring down the entire server by default, and if I don’t explicitly close a connection or something, it’ll just clean up at the end of the web request for me.

                            1. 14

                              PHP: If you just want some simple server-side scripting with nearly no resource use, nothing comes close. A form to make the server send you an email? Just upload a single file with a few lines of PHP.

                              bash: It is so easy to automate things in Unix-world and bash is everywhere.

                              1. 4

                                re PHP. Almost all web hosts support it, too, when I shopped around for one. Can cost-optimize it to about nothing if you want.

                                1. 8

                                  When I was at uni, all those years ago, you could get a shared PHP host for a dollar or two a month. That was the only kind of shared hosting available.

                                  If you wanted process isolation, you had to get an entire machine, starting at $200/mo with a 6-month minimum.

                                  I think this explains quite a bit about why PHP got popular. There’s simply no way I’m going to shell out that kind of cash for a new project that might never turn a profit.

                                  1. 4

                                    You said it better than me. It democratized the masses in getting their code online. So, it got big.

                              2. 12

                                Clojure: Provides good concurrency primitives.

                                JavaScript: Made me not have to eat with homeless people anymore. Prototypal inheritance is a cool idea, which for a time was embraced by some JavaScript developers.

                                Scala: It may have introduced some people to FP. …Maybe.

                                PHP: Encouraged a large number of programmers to learn basic Hebrew.

                                1. 7

                                  Are you sure PAAMAYIM NEKUDOTAYIM counts as basic hebrew? ;)

                                  1. 4

                                    Well you have to start somewhere!

                                2. 11

                                  Datalog: For showing me how short complicated logic code could be. If I could ever understand it.

                                  C: So perfectly simple, nearly every language talks to you.

                                  C++: The language feature ball-pit. You might get pink-eye, but it’s lots of fun.

                                  Rust: RAII and your enums. Also, for pushing C++ to start getting its act together.

                                  Go: An easy language to read, though I’ve never had to write a line.

                                  Python: Pulled me out of many a tight spot. 99% of the time, draws a straight line between “now” and “the goal”.

                                  Ruby: Beautiful syntax and ridiculous metaprogramming possibilities is so seductive to me.

                                  Clojure: Spec is awesome.

                                  JavaScript: The language multiverse in our universe. Enough variations/add-ons (or whatever they’re called), you can find one flavor you like.

                                  Bash: Making simple things simple and saving hours of my life in automation.

                                  Powershell: The ISE is incredible. If you have Windows, try it!

                                  Java: For establishing the JVM as a platform.

                                  1. 10

                                    Prolog: Somehow, whenever I’m not sure what a good way to approach a problem is, Prolog gives me a path that performs well and is much easier-to-read than anything I’d normally evoke.

                                    JavaScript: The same language I know is available absolutely everywhere I work, and comes with an impressively rich object system and an amazing GUI library.

                                    C++: It’s easy to write C-level abstractions in a much higher-level language—even still reusing C libraries as if they were native.

                                    Python: It’s a scripting language, but designed in such a way that it cleanly scales up to large projects, especially if you use the optional and amazingly flexible optional typing.

                                    Ruby: It has a wonderfully expressive syntax alongside the clean runtime paradigm of Smalltalk—and with a very rich standard library to boot!

                                    [Edit: and a bonus, because I have a complex past with Smalltalk]

                                    Smalltalk: It’s the only language I have ever worked in where diving as low-level as you need to go is just as easy as getting as high-level as you want to work.

                                    1. 2

                                      Ah SmallTalk. The first language I got to learn through a class where each of us got assigned a language to study and present to others. Unfortunately I was too immature to really appreciate it and later when I really understood its value it was too late for me to find work with / in it.

                                      1. 4

                                        “FOUR!” An old-school programmer I met once held up four fingers and emphasized, “FOUR KEYWORDS.” That’s all the keywords he said Smalltalk originally had, but you could do really, really complex things with it. I lie asleep at night wondering how programming might be different today if Java hadn’t displaced it.

                                      2. 2

                                        complex past with Smalltalk

                                        Have you written about this somewhere? I’m interested in actual user testimonials about the language that aren’t ranting about how it’s not C or raving that the language is the computer.

                                      3. 9

                                        Perl: it really pioneered the idea that a language needed libraries, and CPAN delivered on it’s promise.

                                        LaTeX: getting it right is an epic pain in the arse but once it’s right it stays right even as you hack your formatting and rewrite your conclusions.

                                        SQL: has saved me more times than I can enumerate when hit with urgent businessy questions.

                                        C: Hello darkness, my old friend.

                                        1. 8

                                          Java has throws. I wish more languages with exceptions had the design nous to dedicate syntax to this concept, instead of just dropping it in docstrings.

                                          With most languages I prefer not to use, I understand the reasons for their design decisions, I just don’t follow the same philosophy or care about the same things they do.

                                          1. 8

                                            C++: C++11 in particular offers a lot of useful abstractions that are decently easy to use on top of its access to lower-level internals.

                                            Javascript: I acknowledge the “function colors” argument, but async/await is a thoroughly pleasant way to write code for an event-loop-based execution model, which itself is often a useful way to structure programs.

                                            Go: It’s a GCed language that is fast, moderately typesafe, and easy to deploy out of the box, which is a rare sweet spot.

                                            1. 7

                                              I have a big problem there: I don’t dislike programming languages…

                                              1. 7

                                                I’m the opposite. I have this thing where I dislike almost all of them. I’m still able to use them just fine, I just don’t find myself drawn to any of them beyond what I can use them for.

                                                1. 4

                                                  Nerd license: revoked.

                                                  1. 1

                                                    Just give it some more time.

                                                    1. 3

                                                      I learned 10 languages, was heavily invested in promoting 2 and am in the core team of one? How much more time?

                                                      1. 1

                                                        As long as it takes to find yourself working at a big company on a codebase that’s ten years old.

                                                        1. 3

                                                          Been there. Done that. Liked it. Code was faster and more reliable after it.

                                                          I like legacy code. It has shown its worth. It has done things. It solved peoples problems.

                                                          1. 2

                                                            I love your attitude. Wish I could be so optimistic all the time! (no sarcasm)

                                                  2. 5

                                                    PHP: Got me started on a different career path :)

                                                    1. 5

                                                      Javascript: Javascript developers spend so much time reinventing the wheel that they do have some interesting wheels.

                                                      1. 4

                                                        PHP7: good performance, deployment is a breeze, great ecosystem.

                                                        JavaScript: prototypes are fun! Asynchronous programming is easy.

                                                        Bash: very convenient.

                                                        Excel: live variable updating is actually a pretty neat idea sometimes.

                                                        1. 4

                                                          Here’s my hot take for this question: I can’t. If I dislike a language, it’s because I don’t see any benefit (however small or secondary) or redeeming features to it. Here are some nice things about languages I have overall negative mixed feelings about:

                                                          • Python: It’s effortless to write code in. (Just don’t try to maintain or hand off that code later…) The Zen of Python are good guidelines for any language, and most libraries and APIs, for that matter.
                                                          • C: Programming in C feels good, like you’re a Real Hacker down in the guts of the computer twiddling bits and doing magic. It’s pretty much all a lie at this point, and it’s been well-demonstrated that writing nontrivial correct C is functionally impossible, but the illusion is very convincing.
                                                          • Java: Once upon a time, the language was simple enough you could list all of its syntactic constructs in a page or two, and aspects of that simplicity still remain. Write-once-run-anywhere is at least 70% not a lie. (Though once you start writing user interfaces, graphical or otherwise, that drops closer to 40%.) With the additions in Java 8, Java-the-language became essentially usable, if still very verbose (but the ecosystem never recovered from its malignant enterpriseoma).
                                                          1. 1

                                                            You’ve said you can’t, but you could and you did it.

                                                            1. 1

                                                              I don’t dislike any of those three languages. I’ve used two of the three extensively professionally, and per what I said, I like coding in C (I just would never publish anything written in it). Examples of languages I actually dislike include PHP and Javascript, and I have nothing nice to say about those. They’re bad languages used for bad things, and the world would be uniformly better off if they had never existed.

                                                          2. 4

                                                            PHP: wow, I’ll never know what any of this code does, but the html/dynamic mix is actually easier for me to read than most frameworks.

                                                            Java: I’ve never had to learn java professionally yet, and that’s because someone else always already knows it. This is actually because Java is somehow teachable.

                                                            Haskell: Lets individuals write LOTS of code without having to keep it all in their head - there are tons of haskell projects that are just monstrous, and it’s because of the stronger type system imo.

                                                            Go: It’s amazing to me just how quickly someone with little to no understanding of the language’s semantics can whip out a working program quickly. It’s not a duck, but it is.

                                                            Thanks for this post. I’ve been working on gratitude and this was a great exercise.

                                                            1. 4

                                                              Rust: The borrow checker is fundamentally a right idea.

                                                              JavaScript: If nothing else, it’s probably the only programming language that you can run on even the most restricted desktop and laptop computers.

                                                              Go: Channels and goroutines seem like a very good concurrency primitive that I wish other languages could imitate. In fact, now that I think about it, I wonder if it could be generalized to simulate Erlang-like processes.

                                                              (Despite being commonly complained about, I don’t dislike PHP and Java.)

                                                              1. 4

                                                                Go: simplicity of the language is often an advantage. There’s no risk that most developers won’t understand what the code does (like in C++, Rust, Haskell, etc). A fresh programmer will be able to create working code in Go, which is a good thing. Easy syntax means it’s easy to parse, and it’s easier to create different tools which operate on the source code. Backed up by a large corporation.

                                                                Python: Low learning curve, easy syntax, massive amount of different libraries to choose from. Package manager which makes it easy to use dependencies. It doesn’t use complicated syntax tricks to do its job, and the code can be understood for people who don’t know Python.

                                                                JavaScript: Massive amount of tools, cool tooling (i.e. webpack), lots of great libraries, JS has introduced a ‘polyfilling’ concept to me. Out of the box support for really powerful runtimes called “internet browsers”. Its community has lots of skilled people who push the boundary of what is possible with JS. Each month brings something new. Some things originated from JS should be brought to different languages as well.

                                                                Dart: It’s a pragmatic language, made to look similar to JS to get JS developers on it without much hassle, but introduces types so that the apps written in it should be more safe. Dart is fast, compiled mostly to native code in runtime, has a JIT if needed, and synergizes with Flutter framework quite nicely. It has a package manager (pub), command line tools, a language server, good support by JetBrains IDEs, and despite the fact I don’t really like it, I’ve managed to make some money on it! :)

                                                                C++: Can be as low-level that you can debug the app in the assembly dump, or as high-level that the code will be similar to a Java application. It’s really fast and really popular. You can operate hardware with it, write device drivers, a web server, a finance app, graphic processing app, music app, a game, and it has been proven that you can write absolutely anything with it. Operating systems are written in it.

                                                                I’ve skipped languages I like, and languages for which I don’t see any hope :)

                                                                1. 3

                                                                  Java puts food on the table for a lot of people

                                                                  1. 3

                                                                    Haskell: I love how it helped me formalize and structure my understanding of type systems. More than that, I like how much it helped me focus on the structure of data in my programs and how types can be most effectively used by modeling that data. These skills have stuck with me as fundamentals that pervade almost all my thinking ever since then. (I’m not sure how much this was Haskell’s doing vs a right-place-right-time sort of a thing, but it definitely had a strong influence.)

                                                                    1. 2

                                                                      I’m not sure how much this was Haskell’s doing vs a right-place-right-time sort of a thing, but it definitely had a strong influence.

                                                                      I feel the same way, but I’m not sure I’m 100% there, and I find it hard to put it in words when I try to explain it to others. Do you know any resources that cover this topic in depth?

                                                                      1. 2

                                                                        Unfortunately, I don’t know of any particular reading material that I could point to. Your link to “Domain Modeling Made Functional” seems plausible. It appears to have the right words and chapter breakdown. But I’ve never heard of that book myself. I’d also be somewhat skeptical that it’s an OO-vs-functional thing, although I can certainly see why it’s convenient to learn this stuff in a functional paradigm.

                                                                        1. 1

                                                                          Looks like the author has a talk online with the same name, I’ll check that out before buying the book. Thanks!

                                                                        2. 1

                                                                          Can you clarify which topic in particular that you mean?

                                                                          1. 1

                                                                            The lessons burntsushi says his Haskell experience taught him.

                                                                            I have this book on my reading list, I wonder if it’s along the same lines: https://pragprog.com/book/swdddf/domain-modeling-made-functional

                                                                      2. 3

                                                                        I somehow avoided needing to work on any Perl from 2000 all the way until 2016 when I had to work on some Perl code for a service outside our team (which was all Scala) because the maintainer was too busy to work on it. We had another service that would have replaced it easily, but it was his baby or some other political BS; I digress.

                                                                        He had some functions (subs) that were over 1000 lines and I don’t think any of the unit tests worked (or I couldn’t get them to).

                                                                        I will say, documentation for Perl was good. I was able to look up and figure out what was going on pretty easily. Perl has a huge amount of CPAN packages to pull from, and there wasn’t a lot of “is this the best way to do things” digging through a few versions of documents, since Perl 5 has pretty solidified over the years.

                                                                        I don’t like a lot of the syntax or way things are done in the language, but it wasn’t as painful to work on/modify as I thought/expected it to be.

                                                                        1. 3

                                                                          Ruby: It was the language that I first learned to program in all those years ago, and gave me a feel for the generic C-like syntax we all know and love(?). The syntax is really great for beginners. (Codecademy can piss right off though, how I suffered through that I’ll never know)

                                                                          1. 3

                                                                            Go: go run, and the fast compiler softens the blow coming from interactive languages.

                                                                            (Caveat: only slightly, though)

                                                                            1. 3

                                                                              PHP5 - it got me my first summer job, taught me about the wonders of indirection through $$$varname (and why that’s a terrible idea). That experience helped me learn pointers in C, which I rather like.

                                                                              1. 3

                                                                                In my very limited experience:

                                                                                PHP:

                                                                                • gaffer tape has a time and a place, namely, when you’re trying to put together a cardboard box fort and paint it so as to be a prop in some sort of theatrical play / presentation.

                                                                                • it contributes to so much conceptual proliferation in the world & ensuing problems - that it has caused many programming jobs

                                                                                Perl:

                                                                                • can type with spelling errors, fat fingers, typos and a lot of guess work and it still seems to still compile and do something that’s close enough to what you wanted anyway as to be useful for your problem solving right here and now. This is kind of cool.

                                                                                I’m looking for the classical childs report card “plays well with others, gets work done”.

                                                                                1. 3

                                                                                  Pascal: had DOS IDEs that were lean but extremely functional (Turbo Pascal) and still the golden standard for developing GUI applications (Delphi 1.0 was revolutionary).

                                                                                  1. 3

                                                                                    Ruby: It’s a good replacement for Perl, for writing short scripts.

                                                                                    Emacs Lisp: Its syntax does let you parse it backwards unambiguously.

                                                                                    Java: At least they’re trying to improve it.

                                                                                    1. 4

                                                                                      C: It makes it easy to deal with hardware without having to necessarily dip into assembly language. And it’s not PHP.

                                                                                      C++: At least it isn’t Java or PHP.

                                                                                      Java: At least it isn’t C++ or PHP.

                                                                                      Forth: You can extend the compiler. It too, isn’t PHP.

                                                                                      Erlang: You can live update the code on a production server. It’s not PHP.

                                                                                      Lua: It’s small. It’s fast. It’s easy to use. Thank god it’s not PHP.

                                                                                      PHP: Um … it’s everywhere?

                                                                                      1. 5

                                                                                        Is it really that hard to think about some random positive aspects of a language?

                                                                                        PHP: low learning curve, built-in support for SQL, multi-platform, is stable and proven working in lots of commercial projects, has nearly out-of-the-box integrations in major web servers, startup time is fast, so can be used to implement command line tools (i.e. Phabricator’s CLI tools are written in PHP), lots of good tooling and IDEs (i.e. PhpStorm), big community of users, etc, etc.

                                                                                      2. 2
                                                                                        • Java did interfaces right, unlike a lot of class-based OOP languages.
                                                                                        • PHP let a lot of people write dynamic webpages, and its typical request isolation model is still a very good design.
                                                                                        • Subsets of C++ can actually be perfect languages for some use cases, and the modern evolution of the standard is impressive.
                                                                                        • For JavaScript it is kind of the same: ES6 has made it much better than it was. And of course, it’s everywhere.
                                                                                        • Ruby has a great, simple syntax, and its community has really pushed the Web back-end standards forward.
                                                                                        1. 2

                                                                                          Lua: false values are only false and nil, easily embeddable, has fast JIT implementation, has lisp on top of it.

                                                                                          Pascal: length-prefixed strings, no pointer arithmetic.

                                                                                          Go: modern Pascal.

                                                                                          Basic: designed to be accessible to computer users, not software developers; warm nostalgia.

                                                                                          Python: is everywhere, modern Basic.

                                                                                          Java: fast bytecode interpreter/JIT, decent code analysis & refactoring tools, type system somewhat helps, lots of standardized interfaces with multiple implementations, usable cross-platform GUI out of the box, lots of languages on top of runtime.

                                                                                          1. 2

                                                                                            JavaScript gets the job done real quick, and you can find help for your problem basically anywhere.

                                                                                            1. 2

                                                                                              Haskell: The type system guides the programmer into correct and usable systems.

                                                                                              Other people have covered PHP and JS quite well.

                                                                                              1. 2

                                                                                                Python: It helps a lot of non-programmers learn to program. Man, that was hard.

                                                                                                1. 2

                                                                                                  There are those here apparently posting something about every language they know, seemingly disliking them all and yet still finding one positive thing to say about them.

                                                                                                  And there’s me, who dislikes every single one of the dozen or so languages in which I could write something more elaborate than ‘hello world’ without too much fuss. I can think of a few nifty things each of them has, I guess, but nothing really notable.

                                                                                                  I guess leaving the tech industry really was the right choice.

                                                                                                  1. 7

                                                                                                    That comes off as sour grapes.

                                                                                                    Your point is that you don’t like any programming languages, so you left the software industry?

                                                                                                    1. 5

                                                                                                      It bothers me how tools, languages, methodologies are becoming more and more hype-driven[1]. Often they are quite unremarkable and yet manage to attract endless praise from a large fanbase.

                                                                                                      [1] read: driven by the marketing department of some company.

                                                                                                      1. 4

                                                                                                        What are you doing now? I am currently tired of tech too and unsure of what could be next, so I like hearing from others what they do.

                                                                                                        1. 1

                                                                                                          I wanted to say something along these lines. I can say things that sound nice, but my honest opinion is that our young science has yet to discover anything resembling truly deep knowledge about programming, computers, or computation. At best, we’ve outlined a few fundamental questions and limitations. All of the languages we’ve developed have been artistic in nature.

                                                                                                          1. 1

                                                                                                            What are the most interesting languages/ideas to you?

                                                                                                            1. 1

                                                                                                              Aside from my own Monte, the most interesting language I’ve thought about recently is Kernel.

                                                                                                              I’ve lately been trying to find ways to make category-theoretic statements less dependent on syntax. It’s always possible to go from lambda calculus to Cartesian closed categories, and I would rather look at a picture than read code.

                                                                                                            2. 1

                                                                                                              All of the languages we’ve developed have been artistic in nature.

                                                                                                              This is because programming, and the act of dealing with abstraction and complexity while solving problems, is fundamentally an artistic task

                                                                                                          2. 1

                                                                                                            Go, JavaScript, PHP: Their anti-intellectualism attracts a certain breed of programmers; thereby improving the overall code quality of the languages I’m using.

                                                                                                            1. 1

                                                                                                              Pascal: Pascal’s concepts and structure are nearly isomorphic to C’s — once you’ve learned one, it’s quite easy to learn the other.

                                                                                                              1. 1

                                                                                                                C++: I like the elegance of the idea that you can wrap { } around any group of statements to be able to write it where a single statement is syntactically required.

                                                                                                                1. 1

                                                                                                                  C: It’s not assembly language. It can be efficient.

                                                                                                                  PHP: It serves as a useful first language that makes some people more curious about programming, and then those people typically go on to be not-PHP programmers.

                                                                                                                  Perl: Underneath that mess is probably the single best language out there for parsing and analysing textual data.

                                                                                                                  JavaScript: In the early days (late 90s), it actually did provide some cool things in Web browsers. A shame it’s become so abused and obfuscated and useless, because adding that tiny bit of pizzazz to otherwise-static pages made the Web less boring without it becoming daunting and bloated.

                                                                                                                  Rust: Great ideas, poor execution.

                                                                                                                  1. 1

                                                                                                                    ASP.net & Classic ASP: It taught me how bad a language CAN be.

                                                                                                                    1. 1

                                                                                                                      Groovy - the null conditional operator is useful. There is a reason Kotlin, C#, and others have copied it.
                                                                                                                      VB.NET - the LINQ query syntax is more expressive than C#. Some of the string functions are easier to use than the CLR equivalent.
                                                                                                                      PowerShell - it is pretty easy to write a cmdlet that takes either positional or named parameters.
                                                                                                                      Java - enums are a well-designed addition to the language. Static analysis tools and library support are excellent.

                                                                                                                      1. 1

                                                                                                                        Go I get paid. Keeps food on the table.

                                                                                                                        1. 1

                                                                                                                          Ruby: Yes, it is good for testing.

                                                                                                                          Javascript: Seemed like a good idea at the time.

                                                                                                                          1. 1

                                                                                                                            I’ve long since forgiven the Perl community for mocking Python, back in the day. :)

                                                                                                                            1. 1

                                                                                                                              Scheme/Lisp: I really admire the “turtles all the way down” philosophy, and also how a language with such minimal syntax can achieve virtually every programming paradigm in existence. One day I will have the time and brain power to write something substantial in a Lisp :)

                                                                                                                              Perl: As others have said, CPAN was amazingly deep and broad long before any other language specific package repository I’d ever heard of, and I also have to grudgingly admire the way perl sticks to its TMTOWTDI philosophy to an extreme, though that also bugs the crap out of me :)

                                                                                                                              PHP: Though I hate it in so many ways PHP really does represent an on-ramp to programming for a lot more people than many would like to admit. The deployment story is about as easy as it gets.

                                                                                                                              Java: The tooling is some of the best around, and there are super mature solutions for just about every problem you can think about on the server.

                                                                                                                              Tcl: its quoting hell drives me nuts, but Tcl/Tk still drive a lot of code out there, and Tk is still arguably the best choice for cross platform UIs for a number of languages.

                                                                                                                              Visual Basic: Ye-gads the code gets horrendous if you try to implement anything like complex logic or data structures in this, but VB made doing visual prototyping accessible to a ton of people and there’s still quite a lot of it out there, and the development environment was in fact pretty slick.

                                                                                                                              Applescript - There is an elegance to this language that’s not obvious to programmers but that actually shines through when you see code where people are using it to stitch together behaviors from other complex applications that support scripting.

                                                                                                                              BASIC: Yes I know I already mentioned VB but it’s a separate beast. BASIC itself is kind of a marvel in programming language design if you think about when it was originally conceived. It introduced millions of people to programming for half a century now, and it’s still in wider use than you might think even today.

                                                                                                                              1. 1

                                                                                                                                INTERCAL was a good joke. :)

                                                                                                                                1. 1

                                                                                                                                  PHP did an amazing job of becoming the standard for shared hosting and brought a lot of smart and talented people into the industry.