What skills do self-taught programmers commonly lack?
quora.com
quora.com
> What pieces of the whole are missing?
The implication being that without a formal CS education, it is an impossibility to obtain a whole. As if whole matters; how does one obtain whole, anyway?
This is a very loaded question and perspective that betrays a serious bias, in my opinion. That we're making a generalization out of humanity's life experiences is futile in itself, but alas, the application of said generalization here is far more interesting to me.
But I say this as a self-taught programmer, so perhaps it's just that I'm envious of those who've had the benefit of a formal CS education.
After many years of experience and a lot of dedication—he expended much effort reading CS books on different topics—he came to be a solid practitioner and now is a leader in the Ruby community.
I think lack of confidence is a huge factor and it's one that's plagued me for a long time, though I don't want to project my issues with it onto all self-taught programmers.
<oversharing>
I had a somewhat unique situation when it came to choosing my degree course - having been brought up in a new-age spiritual belief system, I was pressured into asking a woman in Indonesia what I ought to pursue (yeah seriously :-S), and ended up doing civil engineering despite having no interest in it. I had grown up coding from age 9, and that along with maths were my passions.
I had the added pleasure of having a vast family crisis occur during the degree which caused me to fail a year and end up with, though a good grade (a british 2:1), nowhere near the performance I could have achieved had the shit not been going on.
So I've got a degree in the wrong subject, and have had to work from scratch into some sort of development career, and now I'm in an internal job working on CRUD apps.
</oversharing>
The really frustrating thing is that many (though thankfully not all) potential good employers seem convinced that you must have a computer science degree or otherwise you're not worth considering (and yeah, I'm looking at you google and microsoft), I know I can learn the things I'm missing and contribute to oss, etc. to become a viable coder at a good place, but if you are basically turned away at the door because you lack the right degree it just doesn't matter.
Obviously for me personally, my degree was plagued with problems which weren't my fault, another way in which I can potentially be deselected from the hiring pool.
To end on a positive note - I am working on fixing these things by filling in the gaps and contributing to OSS - a good solution for people who feel similarly inadequate I feel.
Also known as making deadline.
I've seen just as many people with real-world experience that have trouble "getting shit done" -- because getting shirt done is hard for every human being on this planet.
That said, many people coming from academia do suffer from disappointment with the state of the industry, where boring projects are the ones that generate immediate revenue.
Mind you, a lot of the stuff I learned studying CS at college was interesting. It just hasn't been particularly relevant to my career. My math classes (I had a double major in CS and math) have actually been much more professionally useful.
I was self-taught, then formally trained, and since self-taught. I would have to say that both have value and that you are missing something without the formal education. "Confidence" is a good reason, but exposure is important, too. I am sometimes surprised when the college math pops up in my work, spanning anywhere from programming drivers PCI cards to web interfaces. Work with a large enough dataset, and maybe you will need to make use of a different sort from the language-included "quicksort" algorithms.
I thought I could my way out of a paper sack before getting the CS degree. I ended up learning a few things, some trivial, some useful and connecting. You could probably pick it all up up in a couple decades, but four years is a nice jumpstart.
Simultaneously, the learning of approaches and techniques does not end there. For example, I sometimes wish my university had made mention of MOP instead of presenting OOP only the C++, Java, and Ada way.
I think there is a difference between people who can accomplish tasks and people who can accomplish those tasks in a way that they can be easily extended and maintained in the future; in one respect, we can call that experience, and in another, we can call that an exposure to enough approaches/patterns that it is easier to select the best for the job. Any jumpstart is a huge help and can aid in removing the bad habits learned from solo experimentation.
Have you read anything that really knocked you on your ass in terms of practical usefulness?
If you can't do fizz buzz in your chosen language, then it's highly unlikely you can do anything more complicated.
It doesn't test your ability to do any kind of high-level design. It just tests whether you can program at all.
The ability to do high-level design is only important in one of these two situations:
1) The position you are hiring for only involves doing high-level design and not doing any programming.
or
2) The position does involve programming, and the person you are hiring is a competent enough programmer to do fizz buzz.
To my mind, this question, and the answers given, would only begin to make sense if it were phrased "What skills do people who are not interested in Computer Science commonly lack?"
And pointers? Really? That would make sense if the question was "What skills do people who have never used a language with pointers commonly lack?"
It's my personal belief that a firm grasp of C and any processor's assembly -- protected-mode Intel is a can of worms, there's easier architectures like ARM -- is crucial to success as a programmer. Crucial. Enough so that I weigh a CS program based on their application of it, and so far I've been mostly disappointed. Hence why I remain an autodidact.
In all honesty, for a while i felt like i was lacking knowledge compared to my fellow coworkers, but after a while in the job, there is one truth that i only believe: you are either a natural programmer or not, and that's where the difference will be.
I never took real CS courses, i have a degree in Software Engineering, but was basically just how to write software for administration in .NET, design databases and write proper SQL. Never learned C, ASM, algorithm, data structures or stuff like that at school. But i still get a better understanding of those things that most CS graduate i know...
School will not make you a good programmer, if you are good it will help, but you could have probably achieved the same level of knowledge and skill without it.
So I don't agree with the hypothesis.
That said, the list in the article is not an especially good one. It might as well have said "The Basics", as far as I'm reading it.
You can also join courses of interest if you've got a good university around you; as I haven't seen teachers objecting to outsiders participating in their course.
It is true that effort is required without immediate gratification (so it is hard to learn such subjects on your own), but it is feasible, because if the "hard CS" fields you mention don't peak your interest, I doubt they would've had an impact on you if you attended a CS college. Just go and learn, keeping in mind that it may take a while and you need to keep doing it.
The problem isn't one of ability to learn. It's just that it's hard to figure out what you should be looking at.
I am a partially self taught programmer. I did take several courses in university to get a minor in computer science. These clued me in to the holes in my education. Otherwise, I might have figured it out eventually, but it would have been harder.
The people answering on Quora are people who are interested in CS or else they wouldn't be on Quora answering the question. That interest is the reason they know that stuff, being taught it in college just made it easier for them.
Read Knuth's Concrete Mathematics, do all the exercises you can, but this time this is not a requirement.
Forget about Java related design patterns.
Now you know more about programming and CS than 99% of population. Problem solved.
I am a self-taught programmer. That being said, I'm not lacking in any desire or ability to teach myself. In fact I am quite active about it and not just in programming. Sitting on my bookshelf is a current set of AoCP and the companion, Concrete Mathematics. I keep journals of my thoughts, progress, and notes about excercises. I converse with knowledgable people on usenet and irc. I build things to know how they work.
On the other hand, I can understand why such a question is important. Someone new to programming might simply not know what questions to ask or where to go once they've finished the tutorials. Or perhaps they just reach the limits of their knowledge and hit a road block.
However, there are lots of people who load this question with a lot of FUD about self-taught programmers. I just want to let them all in on a little secret: hardly anyone cares about your degree. It's an investment in an institution and doesn't grant you any knowledge that you couldn't gain on your own with a little work and self-discipline. That being said, such an investment does have its advantages. Automatic knowledge and the intuition to apply it is not one of them.
1) Your average database/object driven application. There is user input. This translates pretty directly to output. There may be some interesting algorithms in between, but it's pretty much UI programming.
2) Solving difficult problems. A logistics routing application. The bulk of the code is based on graph theory, reducing the problem perhaps into smaller segments that can be solved in different ways. The UI is just the surface.
There is a need for both types of programmers. The first type are increasingly graphic designers who decided to learn PHP or some similar situation. There are tons of great applications out there that really aren't that complex (except when scaled to extreme proportions - ie Twitter). Wordpress, Gmail, even Microsoft Office isn't terribly complex (at least, the 90% of it that everyone uses).
The second group seems to be a bit more selective. Applications like Dropbox, which need to route data in the most effective way, or Adsense, in which profit needs to be optimized in choosing what ad to display as a page loads. These are complex problems, with complex solutions. That's where O(n) analysis is important. That's where an understanding of graph theory and established algorithms is critical.
While these two groups aren't completely exclusive, I'd say many self taught programmers find themselves in the first group.
2.1) Solving information problems. What you describe.
2.2) Solving physical/mathematical problems. Think signal processing. Think physical simulation. The bulk of the code is based on some mathematical theorem or linear algebra that is just too complex to be calculated by hand. The UI is just the surface.
The 2.2 group seems a bit more selective. Applications like audio workstations, simulation grids or wheather forecast centers need this. Universities use this for research.
While these two groups aren't completely exclusive, I'd say many CS graduates lack the engineering/mathematics/physics prowess needed for the problem spaces encountered in 2.2.
You claim that GMail isn't complex. Jeezus, a tiny % of programmers are capable of recreating that well. Or Microsoft Office! Go get the source code to OpenOffice and say that again. Think about the problem a bit harder and you'll realise it's a freaking compiler that's far more complex than most programming languages.
Far, far, far, far more complex than Dropbox.
I bet the hard bit of Dropox was the seamless UI integration with the OSes and not the routing of data. The data routing was probably solved in an afternoon. That was probably the fun bit.
You seem to have no clue about what is actually hard in programming. Hard problems, pffft.
It's as if I went to projecteuler.net and looked at some code and went 'oh, look, implementing algorithms is easy. Any A-level maths student could do that...'
Graphic designers generally aren't capable of programming or maintaining a large CRUD app, and when they try what usually happens is that some professional has to come and gradually rewrite the whole thing. Without breaking anything. That's hard.
If they are capable then they usually call themselves a programmer, and rightly so. And if they wanted to solve the 'hard' problems, they could. They'd just have to learn about a different area of computing. And I'm mightly jealous of them for having mastered two hard subjects instead of just one.
So next time you want to declare that 90% of programmers could be replaced by people with no programming skills, go look at some source code and then shut up.
Hearing someone say they're a software architect or that a company has a software architect is usually a big red flag to run like hell.
Also a large code base is identical to a complex problem. Check the definition of complexity. A complex problem can be broken down into simple components.
Finally the best glue is not complex, it's simple. Complex glue tends to result in brittle magic, a poor abstraction, like traditional asp.net compared to something far more elegant and smaller like ruby on rails.
Interestingly, historically, there's usually been a war or famine or other hardship that has forced people in their late teens to grow up quickly. Is our society really better on a macro level for the ease that teenagers have now?
Additionally, schooling after a few years as an apprentice is extremely helpful in that you have a familiarity and context about the field and can instantly filter the busy work from the useful information. One may also be in better financial condition by that point, making loans less necessary and ultimately saving the student a lot of money.
Personally I plan to encourage my children to do something else for a few years before they enter post-secondary education (if they plan to do so at all).
This belies the fact that programming and computing have a long and rich tradition of attracting brilliant individuals who, despite taking alternative paths, still manage to go very deep by virtue of their own drives and all-consuming interests.
I've worked closely with many dozens of CS grads in my career. I haven't detected much correspondence between "has degree" and "knows what they are doing." I've seen an overwhelming correspondence between "is truly passionate about programming/computing topics" and "knows what they are doing."
I would have somewhat more sympathy for the dichotomy implied by this question, if all CS grads graduated at the top of their class from a very good CS school.
There is no programming skill that a school can teach that a motivated individual cannot learn outside of school. That is one of the great joys of working in this most democratic and meritocratic of fields. Its secrets are not locked away in an ivory tower, they will reveal themselves to all who seriously seek them. The only tuition required is hard work and persistence.
I have also never learned a single thing from sitting in a lecture hall (though I did do a two year CS diploma, the hardest thing we ever had to do was an Address Book in VB), the most important things I have learned with regard to programming have all come from tutorials on the net and the few books I have bought over the years. In a sense, I have been taught by some of the best people in their fields including K&R, Abelson and Sussman, Denthor, CLRS, _why and too many others to mention.
Since I am self-taught, I can't really give a good answer to the question, but imho, our biggest problem, is that we don't know what we don't know... And that we usually don't a solid understanding of the maths behind what we are doing, something I recently realised the importance of, and am trying to remedy in myself.
Aside: What is really meant by "self-taught programmer" anyway? I have managed and worked with people who came out of university and couldn't program their way out of a paper bag.
This one always makes me raise an eyebrow too. My experience at university was that students who didn't teach themselves anything didn't really succeed in class either.
I interviewed dozens upon dozens of candidates who couldn't describe to me the underlying data structure for a hash table, all with degrees from reputable schools. This was at Amazon of all places, where they did a decent job of filtering before they even got to me.
Don't even get me started on post-grad degrees. Those that have only PhD's or Masters in CS have been especially bad in my experience.
Passing a course, even doing well, is a very different thing than actually internalizing the material.
They may not be good in work environment doing some random UI work, it would turn their brains to mash.
When all you have is a PhD, everything looks like a nail.
Seconding your view on reality. I've only met one programmer with a masters / doctorate that knew what he was doing. The rest -- close to a dozen of 'em -- spent all their time trying to shoe-horn any project they were working on into their thesis.
Some of us never had a formal programming education, we've just spent years (perhaps decades) chasing things that have interested us and learned plenty of useful skills along the way.
I feel that way about everything I've tried to learn on my own. The process of becoming an expert in a field I think is largely learning what you don't know.
So long as there isn't a deficit in the total volume of knowledge, maybe it's a good thing that there be more variety in which subset everyone picks up.
Compilers and Machine learning are probably the two that you don't see in self-taught people much. The ones you do see it in generally go to university shortly after having been self-taught anyway.
Most of the other things on the list you learn if you deal with particular programming languages. And a university degree doesn't really supply breadth much more than being self-taught does. But someone who was self-taught and then did a degree will be much broader in skill, which is why those people seem to have such diverse skills.
The actual answer is that the self-taught programmer needs to keep learning and broadening into other languages etc. Which is exactly the same thing any other programmer needs to do.
FWIW, I'm a self-taught information-retrieval / compiler / linguistics geek, currently studying machine learning. I've been programming since I was 5, and I always wanted to be a super-librarian, whatever that meant.
I think it reinforces the point that self-taught people become very knowledgeable about the things they're interested in. The average self-taught programmer is likely to be more motivated than the average new CS grad. Although this may be becoming less true as more of the less purely interested people move to the more "practical" software related degrees that exist.
I know more than most of my fellow students, due to the few extra years of experience and personal effort, but I definitely had blind spots. It isn't even entire categories of things, but rather little pockets here and there in individual classes.
I have learned a lot, but deciding to get a math BS alongside it has helped the most. I've taken this experience in school as one to soak up as much hard information as possible, so if my personal efforts are any indication, I can see why the combo ends up with a better skills list than either alone.
I've come to really value the stuff that is taught in universities (at a decent enough school anyway). I suspect the longest lived impact of all of this is an ability to read and consume a higher level of information (journals, etc) on a broader variety of topics. It beats blogs, more often than not.
I guess my point is that the hacker/academic distinction is not necessarily as broad as one would think reading some of these comments, and that many of us CS types think of ourselves as hackers as well as academics.
1. They learned one language (PHP or C#), just enough to be productive, and manage to get jobs and make a career out of small "programming" jobs. Sharepoint monkeys, small consulting gigs for web development clients, etc.
2. They have an insatiable appetite for programming and never have stopped learning or expanding their skill set. I fall in this category. I'm constantly reading books, learning from coworkers and never settle for my skill set. I've also gone back and taken some college-level CS courses, which have helped me greatly as well. I'm currently in the process of reading all the seminal computer science books (currently reading the gang of four design patterns book).
In general though, having a CS background doesn't make you a good developer any more than getting an MBA makes you good at business. It's about how you apply it. Plus, you can be a good developer and valuable employee for lots of other reasons besides being book smarts: dependable, productive, smart instincts, etc.
- Renowned CS programs spend less time than you think teaching you how to actually program. Programming is simply a tool to teach things like theory, algorithms, mathematics, logic, artificial intelligence, operating systems, graphics, and so on. I actually took a class on programming C++ and it was one of those independent self-teaching classes. :)
- I think one needs to differentiate between programs that teach programming as a trade and a CS program at a top school. I imagine the experiences are quite different. Much like there would be a difference between someone who learned from Learn C++ in 21 Days vs the hallowed Abelsson and Sussman (Alyssa P Hacker anyone?).
- I think most lower division books can be read by anyone and they would glean the same amount of knowledge. In fact, I would say there isn't much difference if someone went to somewhere like OpenCourseWare and learned it themselves.
- I think you'll find more difficulty at the top end. While it's possible that self-taught programmers would do these exercises, if I ever meet one I'll bow down before him. I'm talking about classes like CS 162 Operating Systems (http://inst.eecs.berkeley.edu/~cs162/sp11/) or CS 170 Efficient Algorithms and Intractable Problems (http://inst.eecs.berkeley.edu/~cs170/sp11/).
- With that said, I personally rarely (if ever) use the things I learned in these classes. Perhaps if I wanted to write my own language, my compilers class would be useful. Or maybe if I got really deep into machine learning, then my AI class would have been more use.
So, I guess with that said, it's really about what doors were open to me on matters that, even when taught, seemed impossible to understand. Doing it self-taught is just that much harder unless you're the guy from Good Will Hunting.
All in all, I'd say that for the majority of people who are not that specialized (like web developers) it doesn't make much of a difference. The people for whom it made a real difference went on to do research in a specific area and are the ones who are hired for some specific knowledge they have (eg. classification algorithms, machine learning algorithms, security, complex statistical models).
It's like people couldn't think of an original question that might actually be of some use to the actual job you'd be doing.
Quite the contrary: if you're in the industry, the difference between a thread a process should be very hot in your page cache. Understanding why ``system("cd ..");'' won't work is pretty vital.
As for sorting algorithm, you should at least know the big-Oh for a good sorting algorithm. In many specialties of programming, understanding what "amortized" means (e.g., in the context of quicksort's performance) is also important.
Somebody out of school may naively think that quicksort is always good as it's O(log N) or (if they never took an OS class-- and OS classes are, unfortunately, optional in some universities) not fully understand why their code is burning up 100% of a single core in a 8-core machine and leaving the other 7 idle.
On the other hand, I can agree that asking questions which are only answered from memory (i.e., either you know the trick or you don't) that will only be in a recent graduates page cache (e.g., remembering all the rules of a red black tree, or a dynamic programming solution to a classic problem) but can -- and should -- be looked up, doesn't make sense (if I see you implementing a balanced tree in a project without at least cracking CLRS open and looking at existing implementations, I'll have a chat with you...)
Web is just a UI to layer software that _does something_, algorithms are a way to get that something done. Have you ever needed to understand why e.g., a SQL JOIN is taking too long? That's an example where algorithms matter (in selecting the index type, knowing whether to use a join between two tables or to denormalize etc...)
Knowing how to do your own memory management and knowing Objective C is great and valuable, but if mobile/Mac desktop application development were to become less valuable and more commodity (right now, I don't think it will happen-- but I can't predict the market), will you be able to apply these skills to (say) working on more complex C and C++ software such as a web browser?
Understanding query cost has more to do with data structures than algorithms. Why does the optimizer seek vs scan? What column(s) do I need to index and how should it be structured? You really don't need to understand how things get sorted in a b-tree.
Knowing normal forms is also different from algorithms. Ergo, it would be more useful to ask "When would you denormalized your data?" instead of "What's the difference between Quicksort and Bubble Sort?"
Objective-C is really just one of many languages I know and use. It just happens to be the most recent. Oddly enough I did spend some time (many years ago) implementing my own browser for a job. We used Java and, again, I never really had to know the complexities of sorting algorithms.
The formal education didn't teach me any skills I couldn't have picked up on my own.
It did however, teach me to ask questions I didn't know existed, lovely abstractions and a lot of useful theoretical concepts. Instead of constantly being surprised by things like "oh, wow, Java's static classes are really similar to python modules of free functions", I can clearly see that they are both manifestations of the same idea, but shaped differently by the language design. This makes it much easier and quicker to pick up new languages and technology.
For him, Visual Basic was programming. Everything else had to be translated to VB for him to understand it.
This is one of the pitfalls of being self-taught, at least if you only learn scripting languages. You don't see the forest for the trees.
(This might be different for people who are self-taught with C, because it's so close to the machine, they instead might be asking the question "but how does the compiler translate that into a machine representation", which is a MUCH better question to ask.)
I once had a project to extract customer contact information from an Excel spredsheet. I use Bayesian probability to determine if a column was a first or last name and trained it using US census data. Then used Levenshtein distance to find names that were possible misspellings. It worked great, but on the POS computers that most people in the company had it took so long they usually just gave up. I would have been better off just sticking a DDL and letting them select what each column was.
Oh well, maybe If I was actually trained I would have figured out how to do it by writing my own compiler or Excel extraction DSL
At the vast majority of even quite decent research universities, CS majors are there to get in, get out, and get a job writing very basic plumbing/form-handling/gluing-stuff-together-code. Or they get an ops job where configuring stuff and keeping it running is important. It works for most of them, too, as that's probably what most programmer-related work is. And most of it doesn't need to scale, so it doesn't hurt too badly that they don't understand algorithmic complexity.
I used to cobble together VBA macros for Excel at work, based on code snippets and the built-in help files. At first, although I got things done, I really had not a blinking clue what I was doing. Then after a few weeks I bought Excel VBA for Dummies - which taught me how to do things properly and understand the essence of all the constructs I was using.
I read more books, and I read web tutorials and watched video lectures. They taught me a lot. Then I left work to get a post-graduate-conversion certification in IT. I always said I was doing it for the cert, not the teaching. The course was good but only because it instilled discipline. Really attending a lecture is no different than watching one on YouTube or iTunesU. The teachers don't have time to give you personal tuition. Their notes are not more instructive than the classic CS/software books in publication. The learning materials available elsewhere are decent rivals to professional education courses. The only thing I can see being a huge benefit is doing pair-programming with an expert for a few years, but how many courses offer that? Not to mention, the learning that's supposed to go on at universities is hardly automatic.
So therefore the question is meaningless, unless you mean actually self-taught people, who would probably (if they managed to develop into competent professionals) have some strange quirks. Like self-taught musicians who never learnt common techniques I guess.
But then again, they know a heck of a lot about some specific problem space, be that audio algorithms, weather forecast or nuclear fission reactions.
This is one area where CS graduates are just about useless. Without knowledge of the problem space, those programming skills still won't solve the problem.
Anyway, I know first hand (from interviewing quite a number of people) that a lot of university graduates lack the listed skills. Sure, they might be familiar with the term "compiler," but that doesn't mean that they have the skills to actually write one.
Don't get me wrong -- for some people, a university education is perfect. There are plenty of grads that know what the hell they're doing. But getting a degree is far from the only way to learn what you need to know to be a decent programmer, and it certainly doesn't guarantee that you'll be one.
In my profession, I ended up becoming a "technology guru", including some development. But as the only developer I never have had anyone else to lean on for expertise or support.
I think that for a self-taught programmer, having (good) mentors is probably a far more effective way to learn real-world development skills than a CS degree. I feel, for myself, that I would thrive in a development team where I could learn for co-workers and receive criticism and correction for my work.
Without that outside influence, it's hard to know if what I'm doing is really the best or even a good way of doing it.
I think every developer needs a mentor, and that's what I feel I missing most.
(P.S. Does anyone out there want to be my mentor? I am looking for a technical co-founder for a startup idea I'm working on)
Now, this knowledge would be useless if I'm not in a position to guide development of a product but I certainly wouldn't discount a degree (or any formal education) as only being a launching point. I think the general consensus is that the best learning mechanism is a mix of both formal education and work experience. Formal education to learn theory and work experience to solidify the knowledge.
It's a hard question to answer because "self-taught" spans too wide a range of skill.
That said, I think the hardest thing to learn outside of academia is the big picture, the general landscape of computer science and software development. It's really useful to know what you don't know, but it's hard to get that without actively seeking out something resembling a CS curriculum.
It leads me to wonder why we aren't asking, "What skills do school-taught programmers commonly lack?"
It's a complacent sort of attitude, like 'I did a degree, so obviously they taught me everything worth knowing.'
I think the use of labels in this instance are not helpful. A person who hasn't touched a piece of code before they enter university is unlikely to magically become a great programmer in the course of three or four years. Indeed, my first-ever submission to HN was spurred on by a bit of disgruntlement at the quality of some of my peers (http://news.ycombinator.com/item?id=1902687 - not much in the way of discussion :).
My opinion on what you might get with a degree that you would be less likely to get without formal study: > More study of development processes and tools (this might apply more to SE than CS) > More study of the broad theory of computation > Earlier exposure to team programming (this comparison is clearly with "self-taught" programmers that aren't working in the industry) > Much, much more cruft that you're not really interested in :)
I'm personally glad that I studied SE at a tertiary level. It balanced out my other degree, it was a good way to meet other like-minded folks (and to compare my own skills against them), and perhaps most importantly I was exposed to a lot of stuff that I feel I wouldn't have sought out on my own. That said, I would feel it the height of presumption to "look down" on a programmer with a lack of degree. I know firsthand that a piece of paper does not make you a good programmer, and vice versa. The real determinant of how good a programmer you are is how good a programmer you are.
To use an analogy, I think of myself as a decent carpenter, but I'm always blown away when I watch "This Old House," because Tom Silva is always busting out really great shortcuts that make things like scribing molding to the wall look really easy. I'm sure he invented some of those tricks on his own, but I'm also betting that he learned a lot of them from his days as an apprentice carpenter to someone older and wiser.
I think it's definitely possible to get such an education without ever setting foot in a school, for example by working closely with a skilled mentor, but I do think it would be hard to naturally stumble upon all of these key areas without someone laying out a self-study plan for you.
The person/company offering the apprenticeship would get cheap labour for a few years in return for helping the young apprentice learn everything they need.
Academia and college educations are getting increasingly difficult to idealize as information becomes redistributed and consumed in unsanctioned ways. And sanctioned ways, too. See all flavors of OCW.
I love learning, and I still do a lot of it by myself. But there's an infinite amount of cool shit out there to learn, and a finite amount of time.
That's why--despite having written several commercial software products, and having worked on systems deployed for years at a stretch--I can't even code a bubble sort or a quicksort, in any language, without resorting to google. ☆blush☆
The implied deficiency doesn't offend me; I don't really want to sit through two semesters of algorithms classes in C or Java, but at this point I definitely wouldn't mind having done so fifteen years ago.
This is actually sometimes important. A self-taught programmer, who really was a whiz at coding had some prototype code for data-analysis. It worked great on the sample data, but was O(n^3) (not just worst-case, average case) and we had a hell of a time convincing him that it wouldn't scale to the quantities of data we had.
Of course constant factors make a difference, but it is frustrating to waste time trying to convince someone that nlogn is going to beat n^3 on a large data-set.
You cannot know everything anyway, no? And CS courses differs from an university to another. The benefit of being self-taught is that you choose the materials yourself and you are enlightened when you study it.
The problem I have with that question (as already pointed out) is that it is phrased as if those things are crucial aspects of "being a programmer", or being good at it.
Meh.
I use bits and pieces of the skillset; but I realised a while ago that the bits I use are things I knew (and made use of) way before knowing the topic in depth. Large parts of those topics are theoretical underpinning which is undeniably useful, but something you can get along without if necessary.
And that, I think, is the main difference between self-taught and taught programmers; the latter have a lot more theoretical understanding of programming concepts. In most cases it doesn't set them apart, but in the case of hard problems, or unique solutions having the theory is required for a solution.
I argue that the problem is classifying these things as "skills" rather than theory/concepts.
You are not vetted by final exams, you are vetted by creating something of value.
I have close friends who are utterly top-notch software engineers who didn't learn any of their skills in a formal educational setting. Often they have been able to learn-as-they-go. After all, these days the field is so large that nobody can be an expert at everything. And we often change jobs enough that what we need to know changes over time. So we all need the ability to learn-on-demand.
I was fortunate to get a computer science undergrad degree from M.I.T., but at the time, they didn't have any courses whatsoever on database systems. I ended up in a position where I needed to write a DBMS, so I found the textbooks and papers and learned how. A lot of my career has been based on that. It's not necessarily all that hard to learn things yourself.
I think the self taught are both fine and justified in their worries that they are missing something. I'll try and explain as best I can.
Imagine that your mind is like a work shop, it's a place you go to create things. Let's consider two workshops: the neat and organized shop and the messy shop. I'm going to suggest that the neat shop is more like a programmer with formal training and the messy shop is more like the self taught. Some self taught folks will argue that their mind is well organized, which is fine, but my opinion from experience is that this view has some amount of validity in the real world. Your experience may vary.
The question here is "is it possible to produce really great work in either shop?" I think that's sort of what the original question was getting at, they talk about skills but the point is what you do with those skills, what you produce. And we all want to produce great work. So can both sorts of shops (minds) produce great work?
My view is that self taught people are typically sharp, sometimes very sharp, but their minds are a little "messy". Formal training in terms of learning basic skills is no better than self taught. But the farther you go the more useful the training becomes. The shop analogy, a bit stretched I'll grant you, is that the training organizes your mind. When you need a tool, you know where it is and you go get it and use it. For example, if you are doing a compiler, you already know that you need an AST (I had a smart guy, with compiler experience, waste quite a bit of time trying to do a compiler without an AST. In spite of another guy saying "Don't we need an AST?". First guy: no formal training, second guy, formal training.)
I think a question that might be more enlightening is "given two equally talented programmers, one with formal training and one without, which one can produce good results, over a broad domain of tasks, faster?"
Even good programmers have huge holes in their knowledge.
He also nails it again in his post, "The Perils of JavaSchools" - http://www.joelonsoftware.com/articles/ThePerilsofJavaSchool...
University CS courses are terrible at being vocational training - but they are absolutely the best place to be if you are interested in research and the theoretical underpinnings of the subject - which are pretty vital if you want to go on and do posgrad work (which I did).
Data Structures, Programming Languages (http://www.cis.upenn.edu/~bcpierce/tapl/), Code-as-Data, Patterns (mostly in the guise of how pattern Y is an inferior version of feature X oh & monads are super patterns), Functional Programming, Object Composition, Recursion, Lambda Calculus, Type Systems, Category Theory
Each of the above expands and leads to its own world. As a self learner you just have to keep exploring. For example with category theory, you pick up type theory and learn how they and sets all relate. From sites like this one you learn about the importance of unit testing and version control. From lambda calculus you can rewind to Frege, unrewind to zermelo and learn about first order logic and trace a line from Haskell to Weierstrass program - taken to its absurd conclusion with Bourbaki - to rigorize Calculus (along the way you may learn of infinitesimals and the hyperreals formulation of Calculus by robinson which I found more intuitive).
After a while I realized that I was really into Artificial intelligence, Graph theory and Subjective Probability theory. The latter two, I think will be the Calculus of the future[1]. This led me through Machine Learning, more much more numerical methods and brings me to today. I don't know much about search or compilers or a great understanding of system internals but I can pick it up if it interests me or I need it.
The downside to self learning is that with no teacher everything is harder. With no teacher you can't double check your model so really understanding takes longer. There is no need to test yourself so you are in danger of jumping around without having properly learned anything.
My solution is to read voraciously to index and just work on what I want so that if I need a concept, knowing of its existence allows me to know that I should learn more on that topic. at the least I can make that connection. Revisiting is key, if you don't understand something now move on but be sure to come back later. Relate/Analogize/search for treatments that most suit you. Good with programming and learning differentiation? Then derivatives as higher order functions paired with Euler's notation makes it way easier and makes expanding to higher dimensions more straightforward. Learning hard things gets easier if you keep at it and you continually expand your base. Its all very slow going though and knowing when to Explore and Exploit your current knowledge is tricky. Till recently I leaned too much towards explore but if you want to get stuff done you need to exploit with what you got. I doubt this approach would have been viable 15 years ago. Or before Google and Wikipedia citations. Finally, I hate academic papers behind paywalls.
[1]As the corner stone of techniques. I see the concept of entropy appearing everywhere and find the idea of quantum mechanics as a complex probability theory just incredible.
That reminds me of another hacker:
"I think one of the most important guiding principles has been this: — that every moment of my waking hours has always been occupied by some train of inquiry. In far the largest number of instances the subject might be simple or even trivial, but still work of inquiry, of some kind or other, was always going on.
The difficulty consisted in adapting the work to the state of the body. The necessary training was difficult. Whenever at night I found myself sleepless, and wished to sleep, I took a subject for examination that required little mental effort, and which also had little influence on worldly affairs by its success or failure.
On the other hand, when I wanted to concentrate my whole mind upon an important subject I studied during the day all the minor accessories, and after two o'clock in the morning I found that repose which the nuisances of the London streets only allow from that hour until six in the morning."
Passages from the life of a philosopher Charles Babbage
Education can lead to an acquisition of knowledge, but it is by no means the only way of acquiring it (experience for example is another way).
Knowledge is what employers look for, and it is a better indicator of ability than education - especially for non-grad positions.
“[T]here are known knowns; there are things we know we know. We also know there are known unknowns; that is to say we know there are some things we do not know. But there are also unknown unknowns – the ones we don't know we don't know." -Donald Rumsfeld
Of course, they default to waterfall. (!!!)
For one thing, I've seen many self taught enterprise software programmers get themselves into serious pain the first time they try to do concurrency.
Funny thing is that the former gets lots of work and the later none at all.
For example this:
>> And as a follow-up, where can said self-taught programmers find good resources on the above subject matter?
Come on. In 2011, where could one possibly find good resources for the above. Let me rack my brain... Hmmmm.... Maybe.... rhymes with Internet? Rhymes with Google? Rhymes with bookstores? I don't know. I give up. I wish I had a PhD in CS so I had the formal education needed to figure this one out. Thank goodness for Quora! (Wait, that's part of the Internet. I missed the class.)
Seriously.
The problem is that these are also effective ways to find bad resources. At Quora, OP can find people with education/experience to identify which resources are worth the time/money.
But I overstepped myself. I couldn't possibly have these thoughts, or reach these conclusions, without having been spoon fed it from a professor in a university course. I'm sorry. I forgot my place. Back to the servant kitchens for me....
...oh look, a book on algorithms, what's that doing in the servant kitchens? I'll sneak a peak when nobody is looking. :)
Even universities don't teach social skills for life.