Programming

Bash script. Not necessarily hard to understand but very unintuitive in my opinion. I've written so much bash script over the years and still have to look up how to do simple things like iterate over associative arrays or do basic string manipulation. Maybe it's just a me problem though 🤷

Brainfuck

Have you ever taken a look at Windows API, it's disgusting.

If by "hard to understand" you're including trying to understand someone else's code, Perl can be a nightmare.

Depends on what you already know.

Functional languages like Haskell, Clojure or Erlang have a reputation of being hard to grasp.

Rust's borrow mechanics are hard for some people at first, especially because it's very unique to the language.

Javascript can be frustrating because it also has some rare features among popular languages, and uses the same keywords for different concepts. It's not bad at all once you let go of your assumptions and dedicate the time to understand how it works under the hood.

C++ is also notorious for being hard but I haven't used it for a very long time so I can't say anything about it.

Perl is a write-only language.

C++ because you have multiple versions, you can write in different styles (C, OOP, functional, meta-stuff, very low level like assembly, very high level like Python), it has undefined behaviors, and you can waste your whole life optimizing code.

Any language if the code was written by me

C and C++. The pointer syntax being slightly different than the pointer declaration syntax always confuses me to no end. I conceptually under pointers perfectly but their syntax is wack.

Fearing a bit to say it but Haskell. I know that it is a different concept, but it's not just that for me. The way the elements are separated, sometimes spaces sometimes symbols, makes it hard for me to understand how things are grouped, and what gets plugged into what.

Objective-C and Objective-C++ are an abomination. Extending languages with other language constructs is ok, I guess, but I find Apple's extremely poor documentation to worsen a situation that's already quite bad.

INTERCAL seems pretty hard.

For example, you have to occasionally say PLEASE or else the compiler will throw an error calling you unpolite. You can't also say PLEASE evey time because it will call you overly polite.

Here are some of the other compiler error messages: https://gist.github.com/kconner/a5c73557230dee1f7a3934d6a7abee13

The hardest languages to learn are the ones that have a different paradigm than the ones you're used to.

Most modern languages today somehow derive from C, in a way or another. JavaScript, Go, PHP, Java, C#, even Python... If you're used to one of these languages, you should be able to get a high level understanding of code written in other languages. Some like Rust can be a bit harder when diving into idiosyncrasies (e.g. borrow checker and lifetimes), but it's not too hard.

But if I encounter a Lisp, or a more domain-specific language like Julia or Matlab, I need to put in a lot more effort to understand what I'm trying to read. Though Lisps are inherently simple languages, the lack of familiarity with the syntax throws me off.

Malbolge https://en.m.wikipedia.org/wiki/Malbolge

It required a cryptanalyst to write hello world.

I find syntax wise, Rust is very closely bordering on esoteric. My employer is currently considering switching to Rust and I can say working in a department with a bunch of Data Scientists with varying degrees of programming experience and capability, this switch, if it happens, will probably be poorly received.

Probably whitespace.

Ignoring the intentionally esoteric languages, of languages in actual use: J, K. Any descendant of APL, basically, and APL itself, though arguably APL is less obtuse than many of its descendants.

E.g, quicksort in J (EDIT: Note Lemmy seems to still garble it despite the code block; see the Wikipedia page on J for the original and other horrifying examples)

    quicksort=: (($:@(<#[), (=#[), $:@(>#[)) ({~ ?@#)) ^: (1<#)

(No, I can not explain it to you)

Assembly.

No one has mentioned COBOL yet, but COBOL.

Haskell. I'll just repeat what I said elsewhere: monads are escape hatches to imperative programming. The majority of haskell code I've read in projects must've been written by imperative programmers who picked up haskell, because there are monads everywhere.

But the hardest to read are List, then C, then C++. Even PHP is easier to read.

Brainfuck

malbolge

and just after haskell