Time and time again I keep coming back to the same conclusion - anyone who has the desire can learn to code. I would say that 95% of people have enough innate logic to write code, they just need to be taught to express it formally.
Good programmers are adept at being able to visualize complex trees and with experience to be able to quickly prune (exclude) suboptimal paths.
This is a pretty limited skill set and is closely correlated with spatial reasoning. Studies have shown that that skill is somewhat malleable through training but still follows a bell curve. Better training could double the number of people who could potentially succeed in stem careers but that is still far from everybody being able to code.
And the effect of training is to largely move people from the middle of the curve slightly to one side and not moving somebody from the middle to the edge of from one edge to the other. That means while you can make some people programmers you can't make anyone excellent programmers.
On a side note my experience is that people without strong spatial reasoning skills tend to find shortcuts early on that help them cope and those coping methods can eventually become strengths in their own right. For example they become adept at memorizing procedures (medicine) or start at the end state and work backwards (project management). To someone who relies on strong spatial reasoning abilities and never developed these techniques these people's abilities can seem like they are able to manage complex trees with speed (memorizing) or extremely deep trees with ease (project management).
They gave people an IQ test and took the top percentile of a group that, due to their interest, was already slightly selected for intellectual ability. This is not proof that anyone can program.
Did you even read the article? It is in accordance with the unfortunate fact that programming is a high IQ job that the majority of people are not capable of becoming proficient in. Though for many here this is not unfortunate, as it is the reason wages remain high despite a lack of licensure.
Humans differ in cognitive ability and most of this difference is genetic. Modern psychometrics and common sence agree with this. We cannot build a better word on false but pleasing ideological assumptions.
You don't need to be the top 1 percentile to make CRUD apps, they chose the best because they had the first pick, not necessarily because they needed to.
I mean, get out in the world and see what most people are like.
Sure we're all different and maybe 95% is high but its at least 50%. One out of every two people I meet I am confident they could become proficient at programming given a solid learning environment.
>One out of every two people I meet I am confident they could become proficient at programming given a solid learning environment.
That's quite possible, even if what I say is true. People tend to mix with people on their own intellectual level. The people you talk to enough to get a good estimate of their intelligence are unlikely to be randomly selected from the population.
If you believe average people can become good programmers, this implies you could make billions converting 100 IQ people into programmers and then undercutting everyone else. I predict you will fail, unless you figure out a way to vastly deskill the art of programming.
For example, the evolution of Javascript from a low status programming language to a high status one has paralleled a shift from a stable core language and a well documented API to the DOM to a combinatorial explosion of changing frameworks and complex development toolchains. Learning some combination gulp and babel and redux and angular(2) and webgl and ten other things is more a matter of access to people who will patiently answer questions than something a person can learn without working on a team.
I'm a learn-by-doing type though, YMMV.
At least half of these already self-selected and 80% filtered students were not really able to program (and eventually flunked or transferred to other departments - although some people who could program flunked and some who couldn't graduated, I think the two groups were quite well correlated).
I'm sure you can do better at teaching (and filtering) than the CS program at my university, but if such a focused group had a 50% failure rate I'm sure the general population is at the very least not better (remember that it's not just about 'raw' ability but also about interest and motivation).
But, maybe I'm over-thinking that part. Either way, I have witnessed first hand that not everyone can code, and we have probably all seen this. I mean, it's a vague statement to begin with. Sure, you can probably show most people how to write a for-loop, but that's a far cry from them being a proficient, professional coder, which is really what's implied by the phrase "learning to code" if used for any practical purpose.
And, you can't just chalk it up to bad teaching. I've seen many people, in school and at work, who just didn't have the thinking style. In school, so many people couldn't turn the corner, then switched majors and did perfectly well. They weren't unintelligent. Coding just never clicked. And, as a tutor, I really witnessed it up-close. For some, I was able to guide them to finding the solution, giving them just enough to turn on their inner coder and help introduce them to that part of their brain.
But, for others, no matter what I did, it just didn't click. I could show them pieces at best, but they could never seem to put it all together. Felt like it was just something about the way their minds worked.
And, there are some who somehow made it through school, but struggle professionally and it shows in the quality of their code. The idea that we can make anyone "good enough" is unrealistic.
Bad code costs money and it's economically no different from any other skilled field, wherein firms that employ highly skilled resources are at an advantage over those who employ less proficient resources. And, this is not just true for Google.
My experience is that being a good programmer is more than a matter of intelligence. It's a certain thinking style that lends itself well to organizing data flows and presentation. It's a certain ability to focus on abstract structures and keep chains of relationships in the mind while envisioning how to manipulate them. And a lots of otherwise smart people just don't think like this natively and "teaching" them is both painful for everyone and has limited effects.
I bet most of us have met perfectly smart people who just didn't click with coding. Just not a good fit for their thinking style. Even if they nominally want to be programmers for the money or cool factor or whatever. Even if they take a bunch of classes. They just never quite get there.
And square pegs beating themselves into round holes usually does indeed cost more than it produces. People should play to their strengths instead of chasing external expectations. It's better for them and for society in my estimation. But certainly if people want to give programming a try they should. And at least "some" experience in programming is better than none. But most people can't/won't become professionals.
But, the bigger part is being able to step back and "see" the path; to pull from what you know to approach the problem and formulate a solution.
Seems like there were three groups: those who just couldn't get it; those who wrestled and muddled their way through; and those who just kind of got it, almost intuitively. The latter is a minority, and I would bet that an outsized percentage of those people really can learn to code.
I suspect that the process selected 11 people because there were funds to educate ~11 people and that ~11 would have been enrolled in the program if the applicant population was significantly different regardless of that difference being a left or right skew.
One of the things each offers is sustained direct access to other people's time and in particular sustained direct access to expert's time. That's the difference between a personally tailored answer and closed as duplicate on StackOverflow. It's the difference between here's the answer and ten other things I can tell you about and here's someone else's question and several divergent answers to your duplicate question which might not have been the same.
For a while I thought the biggest value we provided as a bootcamp was direction and on-demand expert help. But now I don't think that's true. I think the biggest value we provide is that we make everyone show up at the same time every day and work until some other time, and we help direct what they should be working on during that time.
In short, it's social pressure, discipline, and scheduling. Those are everything.
Look at Thinkful's "part-time self directed" bootcamp - all the material is there, there's a mentor to help you once/week for a few mins, you pay $8,500 to do it - people are obviously dedicated to learning when they start. And the end graduation rate? ~31%.
I know another bootcamp that decided to just record their bootcamp and put it online, and charge you $2,000 for access to the videos. 28 people signed up and paid the $2,000, and one person watched past the first lesson.
I would guess that the percentage of people who can discipline themselves enough to learn on their own while balancing other responsibilities and not paying $2,000-8,000 is much, much smaller.
Think back to when you were in college - say it's a Calculus class. What do you think the graduation rate of that class would be if you gave everyone a Calculus book and said, "Fit it in when you can!" I'd guess it would approach zero except for a few superstars.
The same thing seems to be happening in programming. In 2017 the thing holding you back from learning something isn't resources. It's direction and discipline.
There's not really much science in non-academic computer science. We're just builders who make, fix, and break things.
Edit: added do
But 95% of people can't lay bricks precisely enough or at the speed a bricklaying company is going to hire them. And for sure 95% of people aren't interested in laying bricks.
Is it worth teaching 95% of people to code? I don't think it is. Most people don't have to lay bricks to live in house.
95 % of people can't make more money than coding. Some can and do. Many would if they could.
Both programming and physical labor are enjoyable and good for a person in different ways and both ruin a person in different ways if taken too far.
I guess if it all paid the same I'd lay bricks half a day and program the other half :)
Bricks aren't powerful programmable tools that most people already work with on a daily basis.
No they aren't. Either they're making the same salary either way, or else their employer has fired them and hired someone else to push that "button" at a fraction of that salary, once it became obvious that their job could be automated.
No problem, I'll generate one so big you won't be able to read it in a year! And it will only take 30 seconds.
Though it's all antidotal from Going through different college courses that teach both programming and contactor/ladder logic. The programming classes had something like 40% learn rates, while the ladder logic classes everyone eventually got it. And with chances of going out to the field utterly normal people have been able change our contactor/ladder logic to make things work and/or fix issues.
Sure, coding skills sharpen and evolve through experience, but coding was heavily emphasized and there was much lab work in my CS curriculum.
Most CS curricula should definitely not be focusing on any one language, no matter what the year. A typical first few courses are something like:
1) intro to computer science. This is typically teach entry level program flow techniques, loops, if/else, recursion, some OO. My school used java but the focus was not on the language.
2) Data Structures and Algorithms. Overview of your typical data structures and common operations. Gets in to big O, etc. My school accepted assignments in both java and c++, but didn't emphasize either one.
3) Architecture. This is low level CPU architecture. Pipelines, caches etc. We used some sort of assembly for assignments.
4) programming paradigms. This was basically SICP. Meta circular evaluators, etc. We used scheme for assignments but again no real emphasis on the language.
5) OSes. Basics of operating systems. Threads, memory management, networking etc. Assignments were in C.
I think this is the standard CS curriculum, at least according to my experiences and most of the people I've worked with with CS degrees.
Reducesuffering simply stated that some programming tools were taught in the first years of college and he or she did not say his curriculum excluded any of the topics in your list.
Source: Several dentists in the family and that's about what they say. (doesn't stop them from charging large fees though, I mean, they do have student loans to pay off:)
But the result back then was that even among young talented people who entered programming classes, a large percentage (40%-70%, don't remember) just couldn't do it.
The biggest "tell" was understanding pointers (in C). A lot of people just got stuck on that and couldn't move forward.
Not everyone can build a decent sized building, and the people designing and managing their construction are likely also in the top intelligence quartile. But they're not necessarily the ones doing the actual construction of the thing.
In programming, there seems to me to be a refusal do the kind of delegation that occurs in construction. Instead, we've got a huge market of tools designed to reduce boilerplate and increase abstraction so that the highly intelligent programmer can get more done faster.
That's all well and good, but at the end of the day there are programming nails that need to get hammered, and its not going to matter if they're hammered by a MENSA member or not. The current mindset seems to want to deny this, and make every programming task something that must be handled by the best of the best.
People try and try to apply the analogy to software. Heck that was the entire premise of EJBs. Have your smart people design the system. Then hire a bunch of foreign slave labor to implement the interfaces and BLAMO the program is done.
It just. doesn't. work.
No matter how good your up front design is, designs need to change over time. That is what makes software so powerful. But if you are just a code grunt and you don't KNOW how to design anything, you won't know when things need to change. So what do you do, keep adding more and more if blocks until a senior person can code review it? That is a crappy way to build software. WAYYY better to have 2-3 smart people working together than 1 genius and 14 code monkies.