I mostly agree with this, although I don't think classically trained programmers fare much better on average. I've had many university educated programmers that I've had to teach basic parsing, data structures, and algorithms such as tree traversal.
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.
The list they've put together it long enough that I would expect nearly everyone to be missing a few.
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.
Maybe I'm an outlier, but the self-taught people I know fare particularly well on compilers and machine-learning among my peers. Maybe it's the circles I travel in, though. :)
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.
The majority of people I've come across started by doing web stuff or Basic way back in the day. I think in general that's the largest population. The best self-taught people I know have by now read everything that would be in a university reading list anyway.
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'm self-taught and after a few years in industry, decided to go back to school so I could really accelerate my learning.
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.
Self taught programmer here. I would like to think I have at least a bit of knowledge about each of these topics (though definitely not an expertise in most) I would say the one I know the least about is Machine learning, but i'm actively working on changing that :) I just bought this book (and enjoying it!) http://www.amazon.com/gp/product/0262013193
My hypothesis is that a CS education would be most useful after you have already spent 5-10 years in industry. Unfortunately for most people life just isn't structured in a way to allow for full time education later in life.
one of the thing's I've learned is that the assumptions I make nearly always come back and bite me. I think that's what's happening to you here.
The assumption you appear to be making is that a self taught programmer is one who tries but fails to gain acceptance to a CS course, so then has to teach themselves.
I'd classify myself as self taught because I've been writing code since my pre-teen years in the 80's. I also did an engineering degree which helped give me a much better theoretical grounding
I've believed for a long time now that most people would be better off spending a few years in "the real world" before they were admitted to a university. Right now, for many if not most Americans at least, college is an unsupervised extension of high school. It's treated that way not just by patrons but also their parents and administrators. The requisite maturity just isn't there.
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).
I grew up on computers, and am exclusively self-taught, yet I have an in-depth knowledge of how computers actually work from spending time learning how to crack programs. A decent understanding of some fairly complex algorithms from writing RTS, Chess and other games and working on some awesome ML applications professionally. And a good understanding of FP from playing with langs like Haskell and implementing a lisp interpreter.
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.
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.
> Those that have only PhD's or Masters in CS have been especially had in my experience.
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.
As far as I can tell, "self-taught programmer" is a left-handed compliment of sorts, referring somebody who actually gives a shit about programming, rather than someone who passively received some sort of education (however long ago), and has since methodically applied it (exactly as it was). Others went to school, but realized graduation wasn't the end of exploration.
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.
I concur. I'm self-taught and would agree that "we don't know what we don't know". I'm not sure that's exclusive to programmers. Give me a tip about what I don't know that though and I'll research it obsessively. That's just my nature.
There's a much wider range of ability among self-proclaimed self-taught programmers. Some may be "self-taught" to the level that they have completed and understood the entire Art of Computer Programming (those released already, anyway). Some may be "self-taught" to the level that they can write a couple for loops in PHP and Javascript.
It's a hard question to answer because "self-taught" spans too wide a range of skill.
I agree with your point of view, but TAOCP isn't really a work to be completed, and I'm willing to wager that anybody who says they have completed it flipped through it and put it back on the shelf.
It's interesting that this question implied the negative -- not what's the difference between, not even what are the strengths and weaknesses of, but:
> 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.
I'm inclined to disagree. The converse -- what skills does a programmer who has never left academia lack? -- strikes me as perfectly valid. And surely there must be some benefit to taking four (or more) years out of your productive life to the study of programming?
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.
I didn't know you were self-taught — I wasn't projecting, but literally confessing my agreement toward the bias you described. As to the parent, envy is typically felt from a position of disadvantage or inferiority.
Missed the connection between your reply and the second paragraph of your parent on first read. I responded initially to your combination of comments with that oversight in mind -- connected inferiority to inclined to disagree to me -- so I owe you an apology. Forgive me.
Look to someone like Aaron Patterson. He studied CS at university but he did not really understand programming. Out of school, he took a job where he wrote bad Perl.
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, for one, feel incredibly inadequate for lacking the stuff that you'd get on a CS course which I think actually matters - stuff like algos, operating systems architecture, etc.
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.
I don't think you can come up with a stereotype for that.
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.
And the ability of seeing the bigger picture (I know it sounds enterprisey, but that's how I see it). I can still remember our 1st year Physics professor telling us, a class of nerdy CS kids, about how familiarity and a deeper understanding of the field you're writing your programs for is way more important than pointers, data structures etc.
Speaking as someone who was self-taught, spent four years getting a formal CS education, and then has 16 years post-college professional experience, I don't think you probably missed much. I think the only really practical thing I learned in school was big-O notation, and you can probably pick up the essentials of that in about one day of moderate studying. I can't recall ever learning a data structure more complicated than an AVL tree in school, and I think that was in an extra directed-study class. (If you've not heard of an AVL tree, that's not because they're terribly tricky -- it's because they're now nearly obsolete.)
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 agree with you about the math class. As I mentioned elsewhere in the thread, I ended up doing a minor in CS (which comes out to about 6 courses). I focused these courses on the more theoretical/mathy options, and that has definitely served me well.
As a self-taught programmer myself, I confess this is exactly how I would frame the question. I'm constantly worried there's something crucial to which I'm oblivious.
So then the logical answer is that self taught programmers lack the confidence to realize that they are just as good as formally educated programmers. :)
And I wonder if often better. There is value to having the motivation to learn something before being formally trained in it. I was not too impressed with some of my peers in CS, especially those who could not figure out how to open a file in C in their senior year.
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.
The dangerous programmers are those who don't know what they don't know. You have moved on. Once you know that there are things that you don't know you can always pick up some key texts and fill in the gaps. MIT have some great CS videos online, you might want to check them out.
I'm in the same boat and also worry about it to a certain extent. However, 7 years of getting paid to write software has mostly given me more confidence. Also, I know a lot of really smart people (a lot smarter than I) who studied Computer Science and couldn't program their way out of a paper bag.
I'm not 100% sure that fizz buzz is really the indicator that people make it out to be ... I mean, it doesn't really test software design skills, or the ability to design a complex system with loosely coupled objects.
Fizz buzz is very simple. It's easy to communicate, implement and test, there's nothing fiddly about it. It's the entry level indicator and requires no prior knowledge, other than the ability to turn a simple, stable specification into software.
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.
So do something about it. Between the Internet and possibly some nearby university (where you could sneak in and find out exactly what books all their classes require of the CS students), you'll have access to 99% of the same relevant things you'll need to "come up to par" with the so-called college trained programmer. Wikipedia beckons. Amazon (both as bookstore and cloud hosting provider) beckons. Your terminal beckons. Etc.
I'm also saddened to see such a misguided stereotype on the front page here. It's damaging in the same way as the old question, "When did you stop beating your wife?"
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?"
In fairness, once pointers clicked for me, a heaping pile of computing made sense. I banged my head on x86 assembly for a few weeks when I was 14, went back to C and got pointers, then reapproached assembly later and was delighted at how easily it fell into place.
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.
I wasn't disagreeing with the importance of pointers at all. And I agree strongly that a firm grasp of C and assembly is extremely valuable. My disbelief was with the notion that self-taught programmers wouldn't understand pointers. I was saying that the only way you could get away without knowing pointers would be if you'd avoided programming in asm/C/C++/etc.
Which lets face it, is pretty common nowadays with all the scripting languages.
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.
Hmm. I did a quick poll of the programmers I know personally & would consider successful (for a reasonable value of success). One has a firm grasp of assembly (which makes sense because he uses it a lot), a handful have a firm grasp of C (most claim to have a "little" C but from experience with them they couldn't build anything w/o a book for guidance :P).
As a mostly self taught programmer, I disagree. I think this is an extremely relevant question. There are fields of CS that are generally not encountered when learning programming, in spite of being relevant and often useful. Formal verification and proofs, the lambda calculus, language theory, and other "hard CS" subjects which have real world applications (well, in some fields, anyways) are also relatively rare to run across when self-teaching.
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.
There are many good books and even videos of courses for those things you mention.
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.
There are indeed. However, without courses to direct you to them, many self-taught programmers don't realize that they should be reading them, or watching the lectures.
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.
You can't even guarantee people with a CS degree know any of that stuff. In my experience, many of the people I've worked with that had CS dregrees had forgotten that stuff long ago, if they ever knew it.
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.
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.
I thought "category theory" was a very strange thing to include in the list, so I searched down and found this equally strange comment: "I wish I had time to spend a year learning category theory to better understand how to structure things to be compositional". This is akin to saying, "I wish I had time to spend a year studying fluid dynamics so I can learn how to fly a plane".
The most common I have seen is to obsess over code as an ends in itself. Writing pretty code when the solution doesn't really require it. The other is premature optimization, where all code must be fast, regardless of whether the problem requires it. These both lead to lacking a "get it done" attitude that I've seen in the self-taughts.
In my experience they often lack the curiosity to find background information and possess an adequate overview. Like they'll be able to write quite decent code in C++, but in an interview they'll fail at an easy question like 'what are the differences between C, C++, and C#.' (like they'll have no idea about different paradigms)
It's a complacent sort of attitude, like 'I did a degree, so obviously they taught me everything worth knowing.'
Not surprising. That is a list of things 99% of working developers do not do on a daily basis. And I'm not sure most of that will help 99% of developers on a day to day basis.
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
I'm a self taught programmer and have been doing a lot of interviews with developers, both self taught and schooled lately. In general, self taught programmers seem to fall in to two categories.
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.
The question must have been typoed. Given that list, I think the question was supposed to be, "What skills do novice programmers commonly lack?"
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.
This category "self-taught programmers" is an insidious over-generalization. Used in this context, it seems intended to conjure the image of an undisciplined hack who learned how to cobble code together from an "In 21 Days" book.
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.
How many of these things can one really be missing and still call themselves a programmer? I'm self taught myself. Pointers? Really? You can learn pointers in about 20 minutes.
It's interesting, but it seems some people need a lot more work when learning pointers than others. I struggled with operator precedence issues when I first encountered pointers, but didn't have a problem with the concept itself. But I know people who never really managed to wrap their minds around it.
- 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).
One more thing: This is why I always find it sort of useless during tech interviews to ask someone who's been out of school for a long time the difference between a thread and a process or the difference between sorting algorithms.
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.
> ask someone who's been out of school for a long time the difference between a thread and a process
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...)
But "amortized" is irrelevant in the context of quicksort, as it is not an amortized algorithm. You may hit an unlucky streak and get the worst case of O(n^2) behaviour on every call. An amortized algorithm on the other had would guarantee that while each individual operation on a data structure may hit the worst case, it will always (and not just in the average case) average out over many operations on the same data structure.
Doh, screw up on my part. You are completely right. An amortized algorithm would be something like a dynamic array (std::vector or ArrayList) in this case, which is doubled every time it hits capacity.
Err, as fhars poster pointed out quicksort is not an amortized algorithm, I should have used a better example. It is, however, a good example of an algorithm with a worst case running time of N^2.
On the contrary, it's irrelevant if you're not writing a sorting algorithm or your main role doesn't consist of writing any algorithms. Most web developers I know simply call sort() in whatever language they're using instead of reinventing the wheel. Even my work in Objective-C where I handle retaining and releasing memory, I still call sort() (and compare()) without caring about algorithm efficiency.
If you're calling a sorting algorithm, you should still know about the efficiency of that sorting algorithm takes so you can make a choice between sorting an array or indexing using a data structure (which data structure).
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?
IMO, I think you're spending more time talking about edge cases than the norm. How many people are web developers vs those developing web browsers?
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 best programmers I know are self taught. This is because they have a passion and hunger to learn and improve. This is what it takes to be a good programmer. I've met many people that have a CS degree because they simply didn't know what else to do while in school.
You are not vetted by final exams, you are vetted by creating something of value.
A main anti-pattern I've observed from self-taught programmers (including myself during my early career as a junior dev) is lack of planning. This leads to being time-inefficient, cow-boy coding and generally misplacing priorities. Furthermore, an individual's personality type preferences contributes to this.
159 comments
[ 4.6 ms ] story [ 27.3 ms ] threadAt 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.
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.
Even universities don't teach social skills for life.
Dr. Laurence J. Peter
The assumption you appear to be making is that a self taught programmer is one who tries but fails to gain acceptance to a CS course, so then has to teach themselves.
I'd classify myself as self taught because I've been writing code since my pre-teen years in the 80's. I also did an engineering degree which helped give me a much better theoretical grounding
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).
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.
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.
It's a hard question to answer because "self-taught" spans too wide a range of skill.
> 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.
http://blog.hipmunk.com/hipmunk-for-iphone-post-mortem
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.
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 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
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.
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.
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.
- 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.
You are not vetted by final exams, you are vetted by creating something of value.
Funny thing is that the former gets lots of work and the later none at all.