What is a list of programming languages ordered from easiest to hardest to learn?

Updated on : December 8, 2021 by Robert Beard



What is a list of programming languages ordered from easiest to hardest to learn?

Well, it is quite difficult to objectively say which languages ​​are easier or more difficult to learn, and different people may find different languages ​​more difficult. Still, there are some candidates for being "objectively tough." So, listing only the languages ​​I know, from easiest to hardest (subjectively, of course):

  1. Basic - Come on, it's in the name! Originally conceived as a "teaching language", it is not very useful in the industry.
  2. Pascal - Also a "teaching language", it does not have much use in the industry either. A little more concepts to learn than with Basic.
  3. x86 assembly: can't be much lower than that at t
Keep reading

Well, it is quite difficult to objectively say which languages ​​are easier or more difficult to learn, and different people may find different languages ​​more difficult. Still, there are some candidates for being "objectively tough." So, listing only the languages ​​I know, from easiest to hardest (subjectively, of course):

  1. Basic - Come on, it's in the name! Originally conceived as a "teaching language", it is not very useful in the industry.
  2. Pascal - Also a "teaching language", it does not have much use in the industry either. A little more concepts to learn than with Basic.
  3. X86 Assembly - Can't get much lower than that in terms of abstraction. What complicates matters is an unholy amount of various extensions (to name a few, MMX, at least 4 versions of SSE, FPU, etc.) and at least three different modes (16, 32, and 64-bit), all of which use differently. memory models and allow different subsets of commands.
  4. Python: it is very easy to learn the base language. But to really claim that you know Python, you also need to know some libraries, and the library layout is not always consistent. So to sum it up, there is simply a lot to learn.
  5. Go - Very similar to Python in terms of learning complexity, although the library layout is generally somewhat more consistent. However, it could be a bit more difficult to learn, mainly because it masquerades as a low-level language when in fact it is not, so there is a bit of a disconnect at times.
  6. Java - Also very similar to Python in terms of complexity, but possibly a larger collection of libraries to consider.
  7. PHP: It could be close to Python in terms of complexity, but PHP is much less consistent than Python. Newer versions are better, but backward compatible, which means there's still a lot of frankly weird stuff in the language and a lot of hideous code floating around.
  8. C: It is quite easy if we talk about learning the language, but there is this thing called "undefined behavior" that complicates things a lot. Basically, there are some gaps in the standard of the language. If you are using any of that, which is not defined, the compiler is free to do whatever it wants and in most cases it will not notify you about it. That said, ironically, "undefined behavior" is well defined, so it is possible to know and avoid it. Still, that adds complexity to learning.
  9. JavaScript - The base language is really simple, but there are many pitfalls and inconsistencies, which you should be aware of, similar to "undefined behavior" in C, but not as well defined. Also, lately, a lot of frankly unnecessary syntax has been added in the new standards, so you'll have to learn that too (with all the pitfalls that come with that, and there are a few)
  10. Rust: You will struggle a lot with the compiler, because Rust tries to give you a lot of static guarantees. There are a few unexpected things you may come across, but for the most part, it's pretty consistent and intuitive. Well, at least after understanding the whole "static warranties" thing.
  11. Haskell: You will struggle a lot with the compiler, also because Haskell tries to give you a lot of static guarantees, but not necessarily the same guarantees as Rust. Haskell is much easier if you have a math background and little to no programming experience (imperative). Seasoned (imperative) programmers often struggle with Haskell because they need to break some preconceived stereotypes first. Still, Haskell is packed with very abstract concepts that can be difficult to grasp at first. Google "monads" for example. An intimidating list of language extensions also complicates things a bit.
  12. C ++: First of all, it is vast. C ++ is basically three different languages ​​that you need to know: preprocessor, C ++ itself, and template metalanguage; All three use a different syntax; all three have their own traps. There are also a lot of frankly strange things in the C ++ standard, many of which (but not all) are historical accidents. As a consequence, C ++ is full of often unintuitive rules that you need to know. Add to that a huge standard library, that horrible thing called "undefined behavior" inherited from C, and a little bit of new stuff that is introduced with each new standard, and you have a language that is unintentionally very difficult to learn.
  13. Malbolge: an esoteric programming language. It is specifically designed to be nearly impossible to use or learn. Named for Dante's eighth circle of Hell in Hell, it says a lot about the general intention of its authors.

4-9 are somewhat interchangeable, there is not much difference in complexity between them. Of these 6, some might argue that C is the most difficult, but of those that would, most would point to manual memory management. Manual memory management is not difficult to learn, it is difficult to use. Conceptually, it just amounts to "allocate memory before use, free up memory you have allocated, do not use after free, do not try to free more than once." Actually doing all of that without errors is quite difficult and the compiler will not notify you if you make a mistake. Still, manual memory management isn't unique to C, and it's not impossible to go wrong even in garbage collection languages, so I think this sentiment isn't justified.

You may have noticed that there is only one functional language in the list, namely Haskell. I could have also mentioned OCaml, Scala, and F #, but I'm not that familiar with any of them, so I don't think I'm qualified to comment on their learning complexity. All of these 3 have object-oriented parts to worry about, while Haskell doesn't, so it's an open question whether they are harder to learn than Haskell or not. I would say that adding "objects" from OOP to the type system makes the type system more complicated and therefore more difficult to learn. On the other hand, Haskell is usually more abstract, and some people have a hard time with that.

It is also a difficult question to rate on a single scale. Since other people rated things in order, I'll be more across the board (except with Python, which I think might be my general answer as the easiest. I know this isn't a 1–10, but I think it's valid to say that many languages ​​can be thought of as being at both ends of the scale from different perspectives.

C # is one of the hardest for a junior developer and one of the easiest to learn, but if you've been writing it for 5-10 years you can accomplish a lot quickly because it has a lot of frame / library / size so many words key

Keep reading

It is also a difficult question to rate on a single scale. Since other people rated things in order, I'll be more across the board (except with Python, which I think might be my general answer as the easiest. I know this isn't a 1–10, but I think it's valid to say that many languages ​​can be thought of as being at both ends of the scale from different perspectives.

C # is one of the hardest for a junior developer and one of the easiest to learn, but if you've been writing it for 5-10 years you can accomplish a lot quickly because it has a lot of frame / library / size so many words key while remaining very consistent and well designed. Is it easy or difficult? I would say difficult, but I will still choose it often.

Go I would choose the easiest for an experienced developer who needs to learn a new language. The word pointer seems to confuse developers, and experienced developers are often the opposite because they love to have a clear representation rather than having to know how the specific language thinks of the concept of a reference type versus a value type.

JavaScript is probably in some ways the easiest and most difficult at the same time. If you don't know about NPM, various transpilers, and the ten billion other things people have written to help you, then it may be the hardest thing, but at the same time, if you are doing something very simple in a context where you may not need those things, it's very forgiving. If the correction and errors are not very important, then it is wonderful! A lot of people are battling the web with a StackOverflow search for "how do I do X in jQuery" at once, and since the problem goes away after a quick execution context instead of blocking the whole process, the impact of bad code doesn't it's not that big.

Python really could be the simplest in many respects. Personally, I am proficient in C #, Go, TypeScript, and Python. Although I use Python at least 4, I feel very comfortable recommending it as a simple first language for very versatile. The problem that I first ran into with Python is that a Windows developer may have a hard time learning about package management and distribution of the final product, but there is a lot in that for any language so you could actually not be a bad thing. . If they get to the correct PyInstaller tutorial and the code is pure Python, it can look very simple even on Windows.

For the more difficult ones (ignoring languages ​​that are not often used by new developers), I could say C because you can shoot yourself (your memory allocation) in the foot easily, not a great answer on build / management Packing / integration with real libraries. For a new developer, there are some rough concepts. However, this does not make it a bad first. I think I learned a lot from having it as the first even though I never used it professionally. You can see what's going on deep down in C, and that means you have a LOT of misunderstandings and basic logic to work out as you struggle to build something useful.

IMHO poorly phrased question.

I think a better question would be "What is a list of programming languages ​​ordered from easiest to hardest for you / me / them to learn?"

I think learning is quite a subjective task and requires different levels of effort for different people. A language that is easy for you to learn could be difficult for me and vice versa.

I "grew up" learning Basic, and after it got too boring, I migrated to assembly language (Motorola 680xx processor) and programmed some simple games on an Atari ST and Commodore Amiga. Once I had to do more "serious" programming,

Keep reading

IMHO poorly phrased question.

I think a better question would be "What is a list of programming languages ​​ordered from easiest to hardest for you / me / them to learn?"

I think learning is quite a subjective task and requires different levels of effort for different people. A language that is easy for you to learn could be difficult for me and vice versa.

I "grew up" learning Basic, and after it got too boring, I migrated to assembly language (Motorola 680xx processor) and programmed some simple games on an Atari ST and Commodore Amiga. Once I had to do more "serious" programming, I started using C. In college I was "forced" to learn Fortan as it was considered the programming language of science and engineering. The moment OO became "mainstream", I switched to Java. For my work I also had to learn VisualBasic (although it has nothing to do with the old Basic with which I started). At the time, all of those languages ​​felt relatively easy to learn and it was more of a natural progression to go from one to another and it didn't seem like a lot of effort.

Around 2002 with the arrival of "Web2.0" I started learning Javascript and I really didn't like it. The prototypical programming model just struck me as weird. As a result, I perceived it as really difficult to learn, although it was probably more perception than reality. By the way, I still don't really like Javascript, but I use it more and more out of necessity.

Sometime in 2005 a project of mine required me to learn PHP and a later Python project. I've dabbled in Scala a bit lately (I was completely intrigued by its combination of OO and functional programming) but gave it up shortly after Java 8 came out introducing functional programming constructs. At some point I needed to brush up on Erlang when I had to debug some problem in ejabberd and I can say that Erlang "feels" like one of the strangest programming languages ​​to me (except Brainfuck probably) and therefore it was difficult for me to learn. .

More recently I started looking into go, which feels a bit like going back to the "roots" in "C", but I'm starting to like it a lot.

If you asked me which languages ​​are easy or difficult to learn, I would say none and all together. I practically converted to most of them (except PHP and Erlang). Sometimes it felt like an effort and other times it felt more "natural."

My favorite language is still Java simply because I spent most of my time as a programmer with it and am more productive with it than with any other language as I know it so well now. Over time, most languages ​​feel similar and it all comes down to logical thinking and then using any language to express your logic.

Some of the languages ​​took longer to learn and become productive, not because of the language itself, but primarily because of the size and complexity of its ecosystem. For example, there is probably no computing problem that has not yet been solved in Java, but the art is to find the library and learn how to use it correctly. PHP and Python also have a huge standard library that takes time to learn. I also found that go has a fairly large and comprehensive standard library, and I have just started to scratch the surface and it will take time to learn.

Also Javascript has evolved significantly and now I consider it "adult". Ecmascript 7, as the latest version is now called, is a very different language than the one I learned in 2002, but I still don't like it very much. In addition, the Javascript ecosystem has grown so much that it is almost impossible for a single person to know everything.

So after this long answer my summary would be that it should be equally easy or difficult to learn most languages ​​for a qualified person who is willing to learn. However, actually mastering one will take time and experience, no matter how difficult or easy the language itself is.

To sum up and go back to my initial statement: what seemed like a relatively easy learning experience to me could be incredibly difficult for you, as you come from a different background with different life experiences that connected your brain differently, allowing you to learn differently from me.

I can think of three languages ​​that are easy to learn syntax: Lisp (in all its flavors), Forth (in all its flavors), and Smalltalk (in all its flavors).

They have a very simple syntax and are also very easy to extend. However, to do useful things with them, they usually have extensive libraries. Consider Scheme, for example, a version of Lisp, which has a specification of 50 pages, but if you want to have a version that has extensive libraries, you are now flipping through 800 more pages.

Furthermore, due to their simplicity and extensibility, they allow programming

Keep reading

I can think of three languages ​​that are easy to learn syntax: Lisp (in all its flavors), Forth (in all its flavors), and Smalltalk (in all its flavors).

They have a very simple syntax and are also very easy to extend. However, to do useful things with them, they usually have extensive libraries. Consider Scheme, for example, a version of Lisp, which has a specification of 50 pages, but if you want to have a version that has extensive libraries, you are now flipping through 800 more pages.

Also, due to their simplicity and extensibility, they allow programmers to do very difficult things, things that other types of languages ​​can only dream of doing. However, because these things are difficult, these languages ​​sometimes have a reputation for being difficult to learn.

The hardest programming languages ​​to learn? They are things like C ++, Perl, and PHP. They're hard to extend in a meaningful way, they have tons of inconsistent features that you need to fully understand, because one little thing can completely change the meaning of your code, and they have a host of inconsistencies and pitfalls that need to be remembered, lest you fall for it. constantly in ridiculous traps. Ironically, they are offered as "easy to learn" because they have C-like mathematical constructs, complete with precedence, but precedence is one of the main reasons these languages ​​are difficult to extend.

If you're new to programming or have just been doing it for a living, do yourself a favor: learn Lisp, Smalltalk, and Forth. You will discover things that you never dreamed were possible!

The obvious but useless answer: the most difficult are the various "esoteric" languages ​​that are written as jokes: Brainf ** k, Malbolge, Intercal, Whitespace, etc.

If you've already started programming, it's like natural languages: the ones you like, the ones you already know, are easier. In particular, most people are concerned with imperative languages, and that is at least one of the reasons that functional programming languages ​​like Haskell are difficult to learn.

Another issue is: what do you mean by learning, learning enough to do a few simple things, or learning a language as a whole? The langu "kitchen sink"

Keep reading

The obvious but useless answer: the most difficult are the various "esoteric" languages ​​that are written as jokes: Brainf ** k, Malbolge, Intercal, Whitespace, etc.

If you've already started programming, it's like natural languages: the ones you like, the ones you already know, are easier. In particular, most people are concerned with imperative languages, and that is at least one of the reasons that functional programming languages ​​like Haskell are difficult to learn.

Another issue is: what do you mean by learning, learning enough to do a few simple things, or learning a language as a whole? The "kitchen sink" language of the 1960s and 1970s was PL / I; now it's C ++. (If you follow the work of the C ++ committee, you know that Dijkstra's anecdote about PL / I applies a lot to C ++ today.) There is, or at least there was, a book by O'Reilly that describes a usable subset of C ++; In the preface, the author wrote that he realized that this subset was necessary when he encountered a situation in which the creator of the language himself was suddenly unaware or unable to recall some aspect of the language. Here's the catch: If memory serves me correctly, that book is nearing its 20th birthday. C ++ has been growing steadily over the decades, the more recent assimilation of some features from functional programming languages ​​(with the existing structure making the features more difficult to use, for example having to enumerate the values ​​that a given lambda expression "captures"), and the demands of Backward compatibility means that anything will likely never be discarded. I'd say C ++ is the hardest to learn just because of its size. (Be sure to watch Scott Meyers' presentation of "The Last Thing D Needs.") And the demands for backward compatibility mean that anything will likely never be discarded. I'd say C ++ is the hardest to learn just because of its size. (Be sure to watch Scott Meyers' presentation of "The Last Thing D Needs.") And the demands for backward compatibility mean that anything will likely never be discarded. I'd say C ++ is the hardest to learn just because of its size. (Be sure to watch Scott Meyers' presentation of "The Last Thing D Needs.")

As others have said, scripting languages ​​tend to be easier to learn, at least initially. Python is, in my humble opinion, particularly straightforward.

I am not willing to provide one more list. Clearly, languages ​​like Python, Visual Basic or the old Pascal are easy to learn (I would add Scratch, despite being very different and mostly educational) and others like C, C ++, Haskell are difficult (I would add PERL Scripting and Bash ).

A more interesting question is: why? In my experience as a software developer, the things that most influence the ease of a language are:

  • Clear syntax, close to English, which is detailed enough. For students, "if ... then ... if not ..." is easier than: "<expr>? <expr>: <expr>” (PERL or Bash are quite difficult to use.
Keep reading

I am not willing to provide one more list. Clearly, languages ​​like Python, Visual Basic or the old Pascal are easy to learn (I would add Scratch, despite being very different and mostly educational) and others like C, C ++, Haskell are difficult (I would add PERL Scripting and Bash ).

A more interesting question is: why? In my experience as a software developer, the things that most influence the ease of a language are:

  • Clear syntax, close to English, which is detailed enough. For students, "if ... then ... if not ..." is easier than: "<expr>? <expr>: <expr>" (PERL or Bash are quite difficult mainly because of that).
  • Be consistent and clean, not a bunch of different things, paradigms, programming approaches, the result of years of different trends thrown into an existing language (I think that's one of the main reasons why C ++ or PERL is considered difficult , and why PHP is considered dangerous for doing large projects).
  • Static type checking and declaration enforcement are good things in production contexts, but less good for a student, so you need some balance (one of the reasons Python is more loved than Java).
  • Being able to tell the computer about fancy windows with buttons and text boxes and see them on the screen one minute after you've finished writing the code is clearly much more preferable than having to learn about a build tool, configuration files , package structure, and a thousand other things (Java is disgusting at that, even for seasoned developers).

With that said, I'd like to hear from psychologists / cognitivists on the subject, to find out more about how people learn, how they learn programming languages, and the language characteristics that are related to this. You could find some possibly relevant titles on Google Scholar (eg 1, 2, 3), but an expert would be more helpful.

Whatever language you can read and understand to some extent, it is an easy language. Like: C, Java, C ++, structured language, object-oriented, etc.

Here is the list of the 5 most difficult programming languages ​​that give mainstream programmers nightmares. These languages ​​are difficult to digest and unusual to understand.

1.Malbolge

Malbolge is one of the toughest programming languages. In fact, after his arrival, it took 2 years to write the first Malbolge program, can you imagine now how difficult it is? The author of the Malbolge programming language is said to have never written a single p

Keep reading

Whatever language you can read and understand to some extent, it is an easy language. Like: C, Java, C ++, structured language, object-oriented, etc.

Here is the list of the 5 most difficult programming languages ​​that give mainstream programmers nightmares. These languages ​​are difficult to digest and unusual to understand.

1.Malbolge

Malbolge is one of the toughest programming languages. In fact, after his arrival, it took 2 years to write the first Malbolge program, can you imagine now how difficult it is? The author of the Malbolge programming language is said to have never written a single program. It is a public domain esoteric programming language created by Ben Olmsted in 1998.

Hello world program in Malbolge

(= <`# 9 ~ 6ZY32Vx / 4Rs + 0No- & Jk)” Fh} | Bcy? `= * Z Kw% oG4UUS0 / @ - ejc (: '8dc

2.Cow programming language

The cow programming language is released sometime in early 2013. It was designed with cattle in mind. Cows have limited vocabulary skills, so developers inherit the words they know. The command language consists of different variations of 'moo', that is, moO, MoO, mOo, mOO, Moo, etc. It is a case-sensitive language and the other words and symbols between the language instructions are ignored.

Hello world program in Cow programming language

MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Moo OOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO Mo Moo MOo MOo MOo MOo MOo MOo Moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo MoO MoO MoO MoO MoO MooMu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu MOo MOo MOo MOo MOoMOo MOo MOo MOo MOo Moo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOO MOO MOO MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOO MOO MOO MOO MOO MOO MOO MOO MOO MOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MooMu muMu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu mu MOo MOo MOo MOo MOoMOo MOo MOo MOo MOo MOO MOo MOo MOo MOo MOo MOo MOo MOo MOO MOO MOO MOO MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOo MOO MOO MOO MOO MOO MOO MOO MOO MOO MOO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MooMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo moo MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoOMoO MoO MoO MoOMoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO MoO

3 brain fuck

Brainfuck is an esoteric programming language introduced in 1993 by Urban Muller. The language is also similar to the 'Brainfuck' language title which is complicated and unusual. The language consists of eight commands and the program is the sequence of these commands. This language has an instruction pointer that starts at the first command and runs sequentially.

The eight commands of the Brainfuck language are (each symbol is a command):
<> + -. ,

Hello world in Brainfuck language

++++++++++ > +++++++> +++++++++> +++> + <<<< -> ++.> +. + ++++++ .. +++.> ++. << ++++++++++++++++.>. +++. —— .——–.> +. >.

4.INTERCAL

INTERCAL is a compilation language without a pronounceable acronym. It is also an esoteric programming language created by Don Woods and James M. Lyon. At the same time, it pokes fun at the aspects of various programming languages.

Hello World at INTERCAL

PLEASE DO, 1 <- # 13

DO, 1 SUB # 1 <- # 238
DO, 1 SUB # 2 <- # 112
DO, 1 SUB # 3 <- # 112
DO, 1 SUB # 4 <- # 0
DO, 1 SUB # 5 <- # 64
DO, 1 SUB # 6 <- # 238
DO, 1 SUB # 7 <- # 26
DO, 1 SUB # 8 <- # 248
DO, 1 SUB # 9 <- # 168
DO, 1 SUB # 10 <- # 24
DO, 1 SUB # 11 <- # 16
DO, 1 SUB # 12 <- # 158
DO, 1 SUB # 13 <- # 52

PLEASE READ
OUT LOUD, 1 PLEASE Surrender

5.Blank space

White space is another esoteric programming language introduced by Edwin Brady and Chris Morris. In these languages, white space characters such as space, tab, and linefeeds have meaning. The interpreter ignores all non-whitespace characters. The language itself is a stack-based imperative language, and the virtual machines the program runs on have heap and heap. Surprisingly, the language was published on April 1, 2003 (April Fools' Day).

Hello world in blank space

Hope it clears up.

I don't think this question can be usefully answered, but I will at least explain why I think this is so.

First, remember that whether a programming language is easy or difficult to learn is a red herring. You learn a language once and then use it many times.

No programming language is really difficult to learn, if applied to it, because all (with the exception of languages ​​designed to be difficult to understand) are significantly simpler than natural language.

No programming language is really easy to learn, as they need to have a basic level of complexity to be useful.

A professional

Keep reading

I don't think this question can be usefully answered, but I will at least explain why I think this is so.

First, remember that whether a programming language is easy or difficult to learn is a red herring. You learn a language once and then use it many times.

No programming language is really difficult to learn, if applied to it, because all (with the exception of languages ​​designed to be difficult to understand) are significantly simpler than natural language.

No programming language is really easy to learn, as they need to have a basic level of complexity to be useful.

A programming language that is easy for one person to learn may be difficult for another to learn.

Nowadays, being easy to learn is considered an important "selling point". Languages ​​that are perceived as difficult to learn are avoided. To achieve acceptance of a new language, the designer will make an effort to make it easy to learn, even at the expense of making it difficult to use.

In contrast, when programming languages ​​are difficult to learn, it is often because the designer wanted the language to be easy to use. In C ++, for example, the designer recognized that

  1. a + b 

is a simple notation that becomes powerful through recognition. C ++ goes through terrible contortions to make it possible to use this exact notation for virtually any data type. In theory, this makes the source code easier to write and understand, with fewer errors as a result.

In practice, the earnings are questionable, in part because we are misleading in deducting too much from this. Algebraic addition is commutative (math a + b / math is the same as math b + a / math) and is related to multiplication (math a + b + a + a + b / math is the same as math 3 \ times a + 2 \ times b / math): neither of these statements is necessarily true for expressions that use the (overloaded) + operator in C ++. You are not even guaranteed that the underlying transaction looks like the arithmetic sum.

It depends on your native skills and what you mean by "learn". I'm going to give it a try though, so here it goes. By "learn" I mean "teacher".

I think the most difficult programming language to master is C ++. Especially since it is too complex. The definitive book is around 1000 pages long! Also, even if you read and understand the entire book, you * still * need a lot of experience to really understand what you're doing.

The easiest would be Algol 60 (Note: * not * Algol 68, which is terrible). The Algol 60 definition requires approximately 1.5 pages of text. Another 20 pages or so give you the

Keep reading

It depends on your native skills and what you mean by "learn". I'm going to give it a try though, so here it goes. By "learn" I mean "teacher".

I think the most difficult programming language to master is C ++. Especially since it is too complex. The definitive book is around 1000 pages long! Also, even if you read and understand the entire book, you * still * need a lot of experience to really understand what you're doing.

The easiest would be Algol 60 (Note: * not * Algol 68, which is terrible). The Algol 60 definition requires approximately 1.5 pages of text. Another 20 pages or so give you the semantics. It is very self-consistent internally. You can be active and programming in Algol 60 in one day (well, not programming at a very high level, but still…).

The problem with Algol 60 is that it lacks many newer language facilities. If you want a more modern "easy" language, maybe Go is a good choice.

An additional problem is that language is only part of the barrier. Most of the work you need to do requires learning a huge library. You also need to learn how to change repository tools and GUI interfaces if you are doing something that has a user interface. Today's computer language is just the beginning.

Think of it this way. You want to write a book. You need to know the language in which you are going to write. You probably want to be able to express yourself very well in that language. Also, you must have something to say that is interesting to others. Plus some experience or context with which others can identify. Learning a language is only the first step, if necessary.

I think there is no easy answer to this, and watching a "hello world" show is not: people don't want to learn a language to make hello world, and the differences between many languages ​​show once you go beyond "Hello World". .

IMHO, the answer depends a lot on where you come from. Note that a language is a notation for specifying what a computer should do. If someone has a very strong background in math (for example) and wants to focus on math problems, something like MatLab or R might be "the easiest." If anyone has spent time learning how computers work

Keep reading

I think there is no easy answer to this, and watching a "hello world" show is not: people don't want to learn a language to make hello world, and the differences between many languages ​​show once you go beyond "Hello World". .

IMHO, the answer depends a lot on where you come from. Note that a language is a notation for specifying what a computer should do. If someone has a very strong background in math (for example) and wants to focus on math problems, something like MatLab or R might be "the easiest." If someone has spent time learning how computers work as digital circuits, assembly language could be very easy for that person.

This is also why domain-specific languages ​​can be extremely powerful and very easy for people in that domain to learn.

Once you have mastered the relevant concepts, learning a new language is not that important in my experience. Based on what you've used a lot, you may have an "accent" of that language in your newly learned one (eg, writing "C-style" in Python programs, that is, not using the simplest ways of doing something in Python ), almost like in natural languages.

There is still something about “difficult” languages: those that try to do something for everyone are difficult to learn, since it is very easy to get confused when taking the first step and accidentally enter something that you did not intend. C ++ would qualify as such a language…. as would Scala…. I still like them and use them both….

It varies a lot from person to person, but let's give it a GO (pun intended) from easiest to hardest. Only current and common languages ​​count:

1. Python

Easy to learn, great support for everything, directly and intentionally states. It basically looks like English, if you see it. Little snippet to demonstrate:

  1. #! / usr / bin / env python3 
  2.  
  3. word = input ("Enter a word:") 
  4.  
  5. if the word is "apple": 
  6. print ("Stop and set fire") 
  7. the rest: 
  8. print ("Everything is fine") 

2. GO

Trivial, handled, but incredibly fast. Go to the language for serverless backends, if you are as disgusted with node.js as I am. Small snippet:

  1. mai package 
Keep reading

It varies a lot from person to person, but let's give it a GO (pun intended) from easiest to hardest. Only current and common languages ​​count:

1. Python

Easy to learn, great support for everything, directly and intentionally states. It basically looks like English, if you see it. Little snippet to demonstrate:

  1. #! / usr / bin / env python3 
  2.  
  3. word = input ("Enter a word:") 
  4.  
  5. if the word is "apple": 
  6. print ("Stop and set fire") 
  7. the rest: 
  8. print ("Everything is fine") 

2. GO

Trivial, handled, but incredibly fast. Go to the language for serverless backends, if you are as disgusted with node.js as I am. Small snippet:

  1. main package 
  2. import "fmt" 
  3.  
  4. func fib (n uint) uint { 
  5. if n == 0 || n == 1 { 
  6. return n 
  7. }  
  8. the rest { 
  9. return fib (n-1) + fib (n-2) 
  10. func main () { 
  11. n: = uint (10) 
  12. fmt.Println (fib (n)) 
  13. // src: https://gist.github.com/shockalotti/d29021387e8bb3875d28 

3. Javascript / Node.js

Web developers genuinely think that Javascript has a place on our desktops, servers, and wherever else they lay their hands. They think so for a very simple reason: it's incredibly fast and easy to develop something in js. It's not the most efficient, it's not the most attractive, but it works anyway.

  1. function isPalindrome (str) { 
  2. return str == str.split (''). reverse (). join (''); 
  3. console.log (isPalindrome ("aaabaaa"). toString ()); 

4. C #

The bread and butter of Windows desktop application development needs no introduction. A simple, managed, Java-like language with portable .Net binaries (portable == portable between Windows machines with .Net)

  1. //! Source: https://www.sanfoundry.com/csharp-programs-check-leap-year/ 
  2. using the system; 
  3. using System.Collections.Generic; 
  4. using System.Linq; 
  5. using System.Text; 
  6.  
  7. Namespace program 
  8. class leapyear { 
  9.  
  10. // A defined entry point 
  11. static void Main (string args) { 
  12. leapyear obj = new leapyear (); 
  13. obj.readdata (); 
  14. obj.leap (); 
  15.  
  16. int and; 
  17.  
  18. public void readdata () { 
  19. Console.WriteLine ("Please enter the year in four digits:"); 
  20. y = Convert.ToInt32 (Console.ReadLine ()); 
  21.  
  22. public empty jump () { 
  23. if ((and% 4 == 0 && y% 100! = 0) || (and% 400 == 0)) { 
  24. Console.WriteLine ("{0} is a leap year", y); 
  25. the rest{ 
  26. Console.WriteLine ("{0} is not a leap year", y); 
  27. }  
  28.  
  29. Console.ReadLine (); 

5. Java

Runs everywhere, if you can spare some resources for the JVM. Really widespread and mostly because of ease of use, large amounts of coders and the difficulty of shooting yourself in the foot. I'm running out of examples, so you'll get a Hello World.

  1. public class HelloWorld { 
  2. public static void main (String args) { 
  3. System.out.println ("Hello, World"); 

6. PHP

Vanilla PHP is no laughing matter, the meme acronym for it is _PHP Hates Programmers_. With good frameworks, the inconsistency is gone, the pain is gone and you're left with relatively safe stuff. Laravel and Symphony are great examples. Here's the most boring PHP program you'll ever see:

  1. <?php 
  2. $string = 'Hello, World!'; 
  3. echo $string; 
  4. ?> 

7. C

The language once designed to be ‘portable assembly’ still holds true, still is down to the metal and it’s simplicity feels awesome sometimes. It’s great for limited environments or ones without a good C++ compiler. The GNU/Linux kernel is almost entirely C (with inline assembly in some cases).

  1. #include <stdio.h> 
  2. #include <string.h> 
  3.  
  4.  
  5. int count_char(const char *, char);  
  6.  
  7. int main(){ 
  8. /*  
  9. C89 compatibility. 
  10. It only allowed you to declare variables on the top. 
  11. Many companies still follow this standard. 
  12. */ 
  13. char buf256; 
  14. int cnt = 0; 
  15.  
  16. fgets(buf, 255, stdin); 
  17. cnt = count_char(buf, 'a'); 
  18.  
  19. printf("Letter 'a' was found %d times in the input. ", cnt);  
  20. return 0; 
  21.  
  22. int count_char(const char * str, char chr){ 
  23. int len; 
  24. int count = 0; 
  25. int i; 
  26.  
  27. len = strlen(str); 
  28.  
  29. for(i = 0; i < count; ++i){ 
  30. if(stri == chr) 
  31. count++; 
  32.  
  33. return count; 
  34. }  

8. Perl

You heard it right, Perl is more difficult. It’s not more difficult to learn per se, but the amount of horrible quality legacy code lurking in the industry is horrible.

  1. # they will warn you if... never mind, I see 
  2. # you've found an even uglier hack that doesn't even 
  3. # generate a warning 
  4. use strict; 
  5. use warnings; 
  6.  
  7. print "Hello, World!\n"; 
  8.  
  9. # btw: This draws a heart of @s 
  10.  
  11. map(($r=$_,map(($y=$r-$_/3,$l24-$r 
  12. .=(' ','@')$y**2-20*$y+($_**2)/3<0),(0..30)),),(0..24)); 
  13. print join("\n", map(reverse($_).$_, @l)), "\n"; 
  14.  
  15. # Source: http://karwin.blogspot.com/2009/01/best-perl-script-ever.html 

9. C++

It’s difficult, because it basically requires you to be at every abstraction level at once. The basic concept behind writing good C++ is giving bare metal, but high level-ish abstractions. You’re looking to write efficient, simple code which requires you to write a couple of fairly complex classes to hide complexity. You’re hiding complex problems just to solve other complex problems with those now hidden complexities ‘solved’. If you’re not managing a big and performance critical problem, you might be better off not using C++, despite it having it’s own beauty.

RAII is insanely powerful, one of the most beloved features of C++, you’ll witness a simple demonstration of it in an (incomplete, but still rather useful) example.

  1. class safeFileDescriptor{ 
  2. int fd_ = -1; 
  3.  
  4. public:  
  5. operator int() const noexcept{ 
  6. return fd_; 
  7. operator bool() const noexcept{ 
  8. return fd_ >= 0; 
  9. safeFileDescriptor(int fd) : fd_(fd){} 
  10.  
  11. safeFileDescriptor() = default; 
  12.  
  13. // You don't copy a file descriptor, that's dangerous 
  14. safeFileDescriptor(const safeFileDescriptor&) = delete; 
  15.  
  16. // Moving it is fine 
  17. safeFileDescriptor(safeFileDescriptor&& rhs) noexcept{ 
  18. auto tmp = rhs.fd_; 
  19. rhs.fd_ = -1; 
  20. fd_ = tmp; 
  21.  
  22. ~safeFileDescriptor(){ 
  23. if(fd_ >= 0) 
  24. close(fd_); 
  25.  
  26. int main(){ 
  27. auto fd = safeFileDescriptor(open("some_file")) 
  28. if(!fd) 
  29. halt_and_catch_fire(); 
  30. // We opened it with some special flags, fstream wouldn't 
  31. // have done it 
  32. // for example for a serial device, you'd set it's baud rate 
  33. // or set it to non-blocking in certain cases 
  34.  
  35. // This function expects an int. 
  36. //(file descriptors are ints, negative values indicate errors) 
  37. // We've provided a way 
  38. // to cast our little class, so it runs no problem 
  39.  
  40. strange_posix_call(fd); 
  41.  
  42. function_that_can_throw(); 
  43. //No need to close it 
  44. return 0; 

10. Assembly

It’s fairly easy to write a simple program in assembly, but managing any sort of complexity is next to impossible. If you’re looking at asm, you’re either programming a microcontroller or reverse engineering/debugging something most likely.

From Hello, world!. Such a nice language, isn’t it? Bare metal, not portable in all the cases, but gives you direct control over what instructions are being executed ( unless speculative execution has side effects Spectre (security vulnerability) - Wikipedia ).

  1. section .text 
  2. global _start ;must be declared for linker (ld) 
  3.  
  4. _start: ;tell linker entry point 
  5.  
  6. mov edx,len ;message length 
  7. mov ecx,msg ;message to write 
  8. mov ebx,1 ;file descriptor (stdout) 
  9. mov eax,4 ;system call number (sys_write) 
  10. int 0x80 ;call kernel 
  11.  
  12. mov eax,1 ;system call number (sys_exit) 
  13. int 0x80 ;call kernel 
  14.  
  15. section .data 
  16.  
  17. msg db 'Hello, world!',0xa ;our dear string 
  18. len equ $ - msg ;length of our dear string 

Edit:

Honorable mention: Haskell

Please try it, at least once. It’s considered difficult, but it’s fun in its own ways. If you’re into functional programming, it’ll be a great experience.

Edit2:

Typo. s/phyton/python/g

Other Guides:


GET SPECIAL OFFER FROM OUR PARTNER.