What are the most common stumbling blocks when it comes to learning programming, in order of difficulty? [closed]

Question

I seem to remember that linked lists, recursion, pointers, and memory management are all good examples of stumbling blocks - places where the aspiring programmer typically ends up spending significant time trying to understand a concept before moving on and improving, and many end up giving up and not improving.

I'm looking for a complete/comprehensive list of these types of stumbling blocks, in rough estimated order of difficulty to learn, with the goal of making sure that an educational program for programmers is structured to properly guide students through them

Is this information available somewhere? Ideally, the difficulty to learn will be measured in some sort of objective manner (ie, % of students which consistently fail to learn the concept) What sources are most appropriate for obtaining this information?

Answer 1

My list would be:

1. Pointers: the concept of a reference, being aware where the data is stored and the arithmetic on them are quite confusing at first.
2. Linked lists: In my experience this is the first data structure with some logic operations different from arrays that a CS student learns. An introduction to data administration and representation makes them a little complex.
3. Tree structures and Recursion: Here is where my mind had to take some time to think about things before i started typing. Recursion is a powerful concept that when misused leads to big problems, and Trees are the best structures to learn to use it.
4. Paradigm Shifts such us Object Oriented, Functional, Distributed, Logical, etc. This is where all your lines of code that where in a nice simple imperative way, turn into a mix where lots of concepts change the way you need to think your solutions. At least in my case, these made me re-think a lot of what I have done and see that is was not the only way as I thought.
5. Concurrency and Parallelism: this is what I believe the most complex topic on computer programing I have faced. It changes absolutely everything in a way that the problem is not: "Why the heck it always gives me the wrong answer!" but a more disturbing option: "Why the heck it always gives me a different result that is not what I expected!". The complexity about Concurrency is that now the solution is not only the result of an algorithm but also the way this algorithm is calculated on a certain hardware in a certain situation, so the possible results goes up and the capability to determine what is happening in a certain moment of execution decreases.

I should notice that Data Management is a topic that is not necessarily easier or harder than the ones I mentioned but rather it goes in parallel with them. To understand them you need to first know what a pointer is (so the key on a table then will seem natural), understand that a database is not a magic box where you execute queries and create tables and then results come out but rather that there is some data structure (such as Hash, B Trees family data structures) that uses indexing and other techniques to be able to retrieve information that might be stored in memory or in a hard disk, and also is able to be access by multiple users at the same time.

Finally I though I might add: Dealing with clients which is an important point because at the end, you're programming something for someone. In my case I see this as the ultimate barrier a programmer should face. It comes naturally to some or very difficult to others, but this is a concept that is always changing and that will always surprise you. Being able to understand and see in advance what a client might need is a huge step towards learning how to program because if you can see this, your code will be able to adapt when the moment comes. I don't know if this is the HARDEST but at least is the most variable stumbling block.

Answer 2

Having taught, been taught, and studied teaching, the big three are:

1. Pointers.
2. Pass by value vs pass by reference.
3. Recursion.

Those are the 3 items that weed out 2/3rds of CS majors.

Answer 3

1. Fear of breaking the computer
2. Being scared that only having GCSE level (or equivalent) maths education will hinder you
3. Thinking that you need to be as good as Jon Skeet to make learning worthwhile
4. Not having the right tools
5. Not knowing where to get answers to your questions
6. Gathering requirements
7. Designing good user experiences

Answer 4

Pointers and Memory Management was tough for me during my starting days.

Answer 5

In addition to the answers by guiman and el fuser:

• Regular Expressions. Some people never get them.
• something relatively new: SQL (relational data) vs. NoSQL (key => value or other data structures)
• Programming patterns (both ways: going abstract with a concrete problem to create a pattern, or to translate a pattern into a solution for a real problem)

But I don't think you will get a general list. Different people will get different topics with different speed or sometimes never. Some might break when talking about pointers, some other might break when talking about OO vs. functional vs. logic.