Many can agree that hard programming languages do exist since programming languages generally fall on a range of difficulty. For example, assembly language is a low level language that some programmers would find too arcane to grasp. Then there’s a slightly higher level language like C – – that closely resembles assembly but whose syntax affords more readability. C – – language can be difficult to learn for the simple fact that the application of the language deals with code generation which involves building compilers.
For example, C++ emphasis memory management, a concept that assembly programmers will be all too familiar with. This may make C++ among a hard programming language to learn when compared to Ruby, which not only takes care of memory management automatically but also removes the need to include curly braces and semicolons.
Still, difficulty or the lack thereof can easily be based on personal strengths and weaknesses. So when the question about what programming language was most hard for a developer to learn, it’s fascinating to see the varying responses. We’ve collected some responses to this very question to give you an idea of what developers considered hard.
I think Prolog was the weirdest of the bunch. Having backtracking done automatically in a language is a far from normal concept although, once you get used to that, you can implement some software in a couple lines that would take hundreds of lines in C.
this behavior, event loop. I managed to finally comprehend the concepts right by the time es6 was out, ironically.
I’d have to point at 6502, Prolog, LISP / Scheme, and F#.
BASIC was the first language I learned. 6502 assembly was the second. 6502 was “hard” only because I was self-taught, and I was a kid.
(Learned 68000 assembly later, and my 6502 experience made me appreciate both the simplicity of the 6502, and the orthogonal expressiveness of the 68000.)
I learned Prolog while I was a linguistics major. It was very different from the procedural languages I learned. I had to do a lot of learning on how to use it. (Shout out to Dr. Kac, he’s awesome!)
I learned LISP / Scheme as a computer science major, with a professor who didn’t click for me. I wouldn’t call them “hardest”, but rather “least appreciated at the time” and I didn’t like them much. I think I have better perspective these days to appreciate how powerful they are.
Haskell is pure FP, Scala is OO w/FP, F# is FP w/OO on the edges (the OO being necessary to fit into the .NET context).
Though I would say that’s the “hardest” I’ve learned in terms of the challenge, I actually found myself really enthused at getting into the low-level realm of programming, and felt far more excited by the nitty gritty of C than when I learned Python not too long after. I’ve considered diving into Scala, but haven’t taken the plunge quite yet.
I adore the learning process of taking on a new programming language, and so have just started exploring Rust, and am liking what I’m seeing so far.
this operates in arrow functions just made the language inconsistent).
Like I understand how
After focusing on writing a parser in C, I was told that I had to then rewrite it in Java.
Since I had just taught myself C, to write the parser, I assumed that teaching myself Java wouldn’t be much more difficult and probably easier.
It was my first taste of OOP and the contract ended before I could wrap my head around the concepts much less the differences.
In recent memory, Idris was the most mind-bending language I’ve tried out. It’s capable of some really astounding feats, but wrapping my head around dependent types was really challenging. It was very rewarding though; I recommend checking out Idris if you enjoyed Haskell!
Probably Rust and Elixir for me. I felt like if I had given it a little more time, I could have gotten to an aha moment with Elixir, but needed more practice. Rust’s memory management is really hard to grok and the difference between str and String was frustrating. One of the reasons I really like Go is that you get the static typing and speed of Rust, but it has a lower learning curve.
Likely C++, and not because the language is supposed to be somehow particularly difficult, but because it’s terrible.
The compilers are useless at telling you what is wrong, even when it’s something super obvious to every other language’s compiler on the planet. The language is full of gotchas, “oh your destructor isn’t virtual so I’m not going to call it” kind of things.
Working with Verilog (a hardware-description language) in college was a real struggle for me. Even though it looks kinda like conventional code, it does not execute like conventional code, top-to-bottom. Instead it executes as hardware would, in “time-slices”, which made it very difficult for me to reason about. It was really cool when I simulated a MIPS CPU entirely in Verilog, except that I could never get it working properly.
I tried learning Scala early in my career (started from PHP), and I felt it was over my head. I tried for a month or so and eventually gave up. It was a nice language, but I realized over time, it just wasn’t what I needed, or wanted.
Objective C always makes my eyes glaze over. I wanted to do some iOS development and that language always made me give up. I basically learned the language but never found it very easy.
Answers were sourced from Dev.to
Please follow and like us: